mirror of
https://github.com/espressif/openthread.git
synced 2026-07-06 12:20:22 +00:00
Abtin Keshavarzian
bbab3074ed
This commit new configuration option `enable-multiple-instances` and its corresponding option `OPENTHREAD_ENABLE_MULTIPLE_INSTANCES`. When enabled OpenThread supports handling of multiple instances. By default this is disabled. This commit also adds two optimizations for single instance case to simplify the code and also help reduce memory/RAM usage: (1) OpenThread objects/classes typically keep a reference to a higher level object (e.g., many classes keep track of owning `ThreadNetif`) to be able to access other objects/methods within OpenThread class hierarchy. In single instance mode, the reference member variables are removed and instead global functions are used to access the singleton objects from one class to the other. To implement this, a group of `<Object>Locator` classes are defined (e.g., `ThreadNetifLocator`, etc.) which are then used as base class of other OpenThread classes. (2) OpenThread objects which provide a callback/handler (e.g., `Timer`, `Tasklet`, etc.) have `void *mContext` member variable which is used to keep track of the owner of the object. In single instance mode the `mConext` member variables are removed since the owner is expected to be a singleton and can be uniquely determined from the callback function. To implement this, two changes are made: First the handler methods are modified to provide a reference to the object (e.g., `Timer` handler will provide a `Timer &aTimer` as a parameter of its handler callback). Second, a new base class `Context` is introduced which hides the implementation providing an arbitrary context information. A new static method `GetOwner(aContext)` is added to classes which own a callback providing objects. This method help convert a `Context` to the reference of the owner class object.
1967 lines
69 KiB
C++
1967 lines
69 KiB
C++
/*
|
|
* Copyright (c) 2016, The OpenThread Authors.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. 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.
|
|
* 3. Neither the name of the copyright holder 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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 "test_lowpan.hpp"
|
|
|
|
#include "test_platform.h"
|
|
#include "test_util.hpp"
|
|
|
|
using namespace ot;
|
|
using ot::Encoding::BigEndian::HostSwap16;
|
|
|
|
namespace ot {
|
|
|
|
otInstance *sInstance;
|
|
Ip6::Ip6 *sIp6;
|
|
ThreadNetif *sThreadNetif;
|
|
Lowpan::Lowpan *sLowpan;
|
|
|
|
void TestIphcVector::GetCompressedStream(uint8_t *aIphc, uint16_t &aIphcLength)
|
|
{
|
|
memcpy(aIphc, mIphcHeader.mData, mIphcHeader.mLength);
|
|
memcpy(aIphc + mIphcHeader.mLength, mPayload.mData, mPayload.mLength);
|
|
|
|
aIphcLength = mIphcHeader.mLength + mPayload.mLength;
|
|
}
|
|
|
|
void TestIphcVector::GetUncompressedStream(uint8_t *aIp6, uint16_t &aIp6Length)
|
|
{
|
|
aIp6Length = 0;
|
|
|
|
memcpy(aIp6, reinterpret_cast<uint8_t *>(&mIpHeader), sizeof(mIpHeader));
|
|
aIp6Length += sizeof(mIpHeader);
|
|
|
|
if (mExtHeader.mLength)
|
|
{
|
|
memcpy(aIp6 + aIp6Length, mExtHeader.mData, mExtHeader.mLength);
|
|
aIp6Length += mExtHeader.mLength;
|
|
}
|
|
|
|
if (mIpTunneledHeader.GetPayloadLength())
|
|
{
|
|
memcpy(aIp6 + aIp6Length, reinterpret_cast<uint8_t *>(&mIpTunneledHeader), sizeof(mIpTunneledHeader));
|
|
aIp6Length += sizeof(mIpTunneledHeader);
|
|
}
|
|
|
|
if (mUdpHeader.GetLength())
|
|
{
|
|
memcpy(aIp6 + aIp6Length, reinterpret_cast<uint8_t *>(&mUdpHeader), sizeof(mUdpHeader));
|
|
aIp6Length += sizeof(mUdpHeader);
|
|
}
|
|
|
|
memcpy(aIp6 + aIp6Length, mPayload.mData, mPayload.mLength);
|
|
aIp6Length += mPayload.mLength;
|
|
}
|
|
|
|
void TestIphcVector::GetUncompressedStream(Message &aMessage)
|
|
{
|
|
SuccessOrQuit(aMessage.Append(reinterpret_cast<uint8_t *>(&mIpHeader), sizeof(mIpHeader)),
|
|
"6lo: Message::Append failed");
|
|
|
|
if (mExtHeader.mLength)
|
|
{
|
|
SuccessOrQuit(aMessage.Append(mExtHeader.mData, mExtHeader.mLength),
|
|
"6lo: Message::Append failed");
|
|
}
|
|
|
|
if (mIpTunneledHeader.GetPayloadLength())
|
|
{
|
|
SuccessOrQuit(aMessage.Append(reinterpret_cast<uint8_t *>(&mIpTunneledHeader), sizeof(mIpTunneledHeader)),
|
|
"6lo: Message::Append failed");
|
|
}
|
|
|
|
if (mUdpHeader.GetLength())
|
|
{
|
|
SuccessOrQuit(aMessage.Append(reinterpret_cast<uint8_t *>(&mUdpHeader), sizeof(mUdpHeader)),
|
|
"6lo: Message::Append failed");
|
|
}
|
|
|
|
SuccessOrQuit(aMessage.Append(mPayload.mData, mPayload.mLength), "6lo: Message::Append failed5");
|
|
}
|
|
|
|
/**
|
|
* This function initializes Thread Interface.
|
|
*
|
|
*/
|
|
static void Init()
|
|
{
|
|
uint8_t meshLocalPrefix[] = {0xfd, 0x00, 0xca, 0xfe, 0xfa, 0xce, 0x12, 0x34};
|
|
sThreadNetif->GetMle().SetMeshLocalPrefix(meshLocalPrefix);
|
|
|
|
// Emulate global prefixes with contextes.
|
|
uint8_t mockNetworkData[] =
|
|
{
|
|
// Prefix 2001:2:0:1::/64
|
|
0x03, 0x0e, // Prefix TLV
|
|
0x00, 0x40,
|
|
0x20, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
|
|
0x07, 0x02, // 6LoWPAN Context ID TLV
|
|
0x11, 0x40, // Context ID = 1, C = TRUE
|
|
|
|
// Prefix 2001:2:0:2::/64
|
|
0x03, 0x0e, // Prefix TLV
|
|
0x00, 0x40,
|
|
0x20, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
|
|
0x07, 0x02, // 6LoWPAN Context ID TLV
|
|
0x02, 0x40 // Context ID = 2, C = FALSE
|
|
};
|
|
|
|
sThreadNetif->GetNetworkDataLeader().SetNetworkData(0, 0, true, mockNetworkData, sizeof(mockNetworkData));
|
|
}
|
|
|
|
/**
|
|
* This function performs compression or/and decompression based on the given test vector.
|
|
*
|
|
* @note Performing decompression and compression on the same LOWPAN_IPHC frame may give different result.
|
|
* This situation may occur when sender does not use the best possible compression,
|
|
* e.g. doesn't use LOWPAN_NHC for UDP - which is still valid.
|
|
*
|
|
* @param aVector Test vector that has to be tested.
|
|
* @param aCompress Set to TRUE, if compression should be tested.
|
|
* @param aDecompress Set to TRUE, if decomrpession should be tested.
|
|
*/
|
|
static void Test(TestIphcVector &aVector, bool aCompress, bool aDecompress)
|
|
{
|
|
Message *message = NULL;
|
|
uint8_t result[512];
|
|
uint8_t iphc[512];
|
|
uint8_t ip6[512];
|
|
uint16_t iphcLength;
|
|
uint16_t ip6Length;
|
|
|
|
aVector.GetCompressedStream(iphc, iphcLength);
|
|
aVector.GetUncompressedStream(ip6, ip6Length);
|
|
|
|
printf("\n=== Test name: %s ===\n\n", aVector.mTestName);
|
|
|
|
printf("Expected error -------------- %s\n", aVector.mError ? "yes" : "no");
|
|
printf("UDP present ----------------- %s\n", aVector.mUdpHeader.GetLength() ? "yes" : "no");
|
|
printf("Extension Headers present --- %s\n", aVector.mExtHeader.mLength ? "yes" : "no");
|
|
printf("IP-in-IP present ------------ %s\n", aVector.mIpTunneledHeader.GetPayloadLength() ? "yes" : "no");
|
|
printf("LOWPAN_IPHC length ---------- %d\n", aVector.mIphcHeader.mLength);
|
|
printf("IPv6 uncompressed offset ---- %d\n\n", aVector.mPayloadOffset);
|
|
|
|
printf("Expected IPv6 uncompressed packet: \n");
|
|
otTestPrintHex(ip6, ip6Length);
|
|
printf("\n");
|
|
|
|
printf("Expected LOWPAN_IPHC compressed frame: \n");
|
|
otTestPrintHex(iphc, iphcLength);
|
|
printf("\n");
|
|
|
|
if (aCompress)
|
|
{
|
|
VerifyOrQuit((message = sIp6->mMessagePool.New(Message::kTypeIp6, 0)) != NULL,
|
|
"6lo: Ip6::NewMessage failed");
|
|
|
|
aVector.GetUncompressedStream(*message);
|
|
|
|
int compressBytes = sLowpan->Compress(*message, aVector.mMacSource, aVector.mMacDestination,
|
|
result);
|
|
|
|
if (aVector.mError == OT_ERROR_NONE)
|
|
{
|
|
// Append payload to the LOWPAN_IPHC.
|
|
message->Read(message->GetOffset(),
|
|
message->GetLength() - message->GetOffset(),
|
|
result + compressBytes);
|
|
|
|
printf("Resulted LOWPAN_IPHC compressed frame: \n");
|
|
otTestPrintHex(result, compressBytes + message->GetLength() - message->GetOffset());
|
|
printf("\n");
|
|
|
|
VerifyOrQuit(compressBytes == aVector.mIphcHeader.mLength, "6lo: Lowpan::Compress failed");
|
|
VerifyOrQuit(message->GetOffset() == aVector.mPayloadOffset, "6lo: Lowpan::Compress failed");
|
|
VerifyOrQuit(memcmp(iphc, result, iphcLength) == 0,
|
|
"6lo: Lowpan::Compress failed");
|
|
}
|
|
else
|
|
{
|
|
VerifyOrQuit(compressBytes < 0, "6lo: Lowpan::Compress failed");
|
|
}
|
|
|
|
message->Free();
|
|
message = NULL;
|
|
}
|
|
|
|
if (aDecompress)
|
|
{
|
|
VerifyOrQuit((message = sIp6->mMessagePool.New(Message::kTypeIp6, 0)) != NULL,
|
|
"6lo: Ip6::NewMessage failed");
|
|
|
|
int decompressedBytes = sLowpan->Decompress(*message, aVector.mMacSource, aVector.mMacDestination,
|
|
iphc, iphcLength, 0);
|
|
|
|
message->Read(0, message->GetLength(), result);
|
|
|
|
if (aVector.mError == OT_ERROR_NONE)
|
|
{
|
|
// Append payload to the IPv6 Packet.
|
|
memcpy(result + message->GetLength(), iphc + decompressedBytes,
|
|
iphcLength - static_cast<uint16_t>(decompressedBytes));
|
|
|
|
printf("Resulted IPv6 uncompressed packet: \n");
|
|
otTestPrintHex(result, message->GetLength() + iphcLength - decompressedBytes);
|
|
printf("\n");
|
|
|
|
VerifyOrQuit(decompressedBytes == aVector.mIphcHeader.mLength, "6lo: Lowpan::Decompress failed");
|
|
VerifyOrQuit(message->GetOffset() == aVector.mPayloadOffset, "6lo: Lowpan::Decompress failed");
|
|
VerifyOrQuit(message->GetOffset() == message->GetLength(), "6lo: Lowpan::Decompress failed");
|
|
VerifyOrQuit(memcmp(ip6, result, ip6Length) == 0, "6lo: Lowpan::Decompress failed");
|
|
}
|
|
else
|
|
{
|
|
VerifyOrQuit(decompressedBytes < 0, "6lo: Lowpan::Decompress failed");
|
|
}
|
|
|
|
message->Free();
|
|
message = NULL;
|
|
}
|
|
|
|
printf("PASS\n\n");
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
* @section Test constants.
|
|
**************************************************************************************************/
|
|
static const uint8_t sTestMacSourceDefaultLong[] = {0x00, 0x00, 0x5e, 0xef, 0x10, 0x22, 0x11, 0x00};
|
|
static const uint8_t sTestMacDestinationDefaultLong[] = {0x00, 0x00, 0x5e, 0xef, 0x10, 0xaa, 0xbb, 0xcc};
|
|
|
|
static uint16_t sTestMacSourceDefaultShort = 0x0000;
|
|
static uint16_t sTestMacDestinationDefaultShort = 0xc003;
|
|
static uint16_t sTestMacDestinationBroadcast = 0xffff;
|
|
|
|
static const uint8_t sTestPayloadDefault[] = {0x80, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
|
|
|
|
/***************************************************************************************************
|
|
* @section Test cases.
|
|
**************************************************************************************************/
|
|
|
|
static void TestFullyCompressableLongAddresses(void)
|
|
{
|
|
TestIphcVector testVector("Fully compressable IPv6 addresses using long MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x33, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestFullyCompressableShortAddresses(void)
|
|
{
|
|
TestIphcVector testVector("Fully compressable IPv6 addresses using short MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::ff:fe00:0000",
|
|
"fe80::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x33, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestFullyCompressableShortLongAddresses(void)
|
|
{
|
|
TestIphcVector testVector("Fully compressable IPv6 addresses using short and long MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::ff:fe00:0000",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x33, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestFullyCompressableLongShortAddresses(void)
|
|
{
|
|
TestIphcVector testVector("Fully compressable IPv6 addresses using long and short MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x33, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestSourceUnspecifiedAddress(void)
|
|
{
|
|
TestIphcVector testVector("Unspecified source IPv6 address");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"::",
|
|
"fe80::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x43, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestSource128bitDestination128bitAddresses(void)
|
|
{
|
|
TestIphcVector testVector("IPv6 addresses inline");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"2001:2:0:3:aaaa:bbbb:cccc:dddd",
|
|
"2001:2:0:4::");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x00, 0x3a, 0x20, 0x01, 0x00, 0x02, 0x00,
|
|
0x00, 0x00, 0x03, 0xaa, 0xaa, 0xbb, 0xbb, 0xcc,
|
|
0xcc, 0xdd, 0xdd, 0x20, 0x01, 0x00, 0x02, 0x00,
|
|
0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestSource64bitDestination64bitLongAddresses(void)
|
|
{
|
|
TestIphcVector testVector("IPv6 addresses 64-bit using long MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1101",
|
|
"fe80::200:5eef:10aa:bbcd");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x11, 0x3a, 0x02, 0x00, 0x5e, 0xef, 0x10,
|
|
0x22, 0x11, 0x01, 0x02, 0x00, 0x5e, 0xef, 0x10,
|
|
0xaa, 0xbb, 0xcd
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestSource64bitDestination64bitShortAddresses(void)
|
|
{
|
|
TestIphcVector testVector("IPv6 addresses 64-bit using short MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1101",
|
|
"fe80::200:5eef:10aa:bbcd");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x11, 0x3a, 0x02, 0x00, 0x5e, 0xef, 0x10,
|
|
0x22, 0x11, 0x01, 0x02, 0x00, 0x5e, 0xef, 0x10,
|
|
0xaa, 0xbb, 0xcd
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestSource16bitDestination16bitAddresses(void)
|
|
{
|
|
TestIphcVector testVector("IPv6 addresses 16-bit using short MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::ff:fe00:0001",
|
|
"fe80::ff:fe00:c004");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x22, 0x3a, 0x00, 0x01, 0xc0, 0x04};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestSourceCompressedDestination16bitAddresses(void)
|
|
{
|
|
TestIphcVector testVector("Fully compressable IPv6 source and destination 16-bit using long MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::ff:fe00:beaf");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x32, 0x3a, 0xbe, 0xaf};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestSourceCompressedDestination128bitAddresses(void)
|
|
{
|
|
TestIphcVector testVector("Fully compressable IPv6 source and destination inline using long MAC addresses");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"2001:2:0:4::");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x30, 0x3a, 0x20, 0x01, 0x00, 0x02, 0x00,
|
|
0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
|
|
static void TestMulticast128bitAddress(void)
|
|
{
|
|
TestIphcVector testVector("Multicast address inline");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"ff05::100:0030:0001");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x38, 0x3a, 0xff, 0x05, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
|
|
0x30, 0x00, 0x01
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestMulticast48bitAddress(void)
|
|
{
|
|
TestIphcVector testVector("Multicast address 48-bit");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"ff05::1:0030:0001");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x39, 0x3a, 0x05, 0x01, 0x00, 0x30, 0x00,
|
|
0x01
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestMulticast32bitAddress(void)
|
|
{
|
|
TestIphcVector testVector("Multicast address 32-bit");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"ff03::fc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x1a, 0x3a, 0x02, 0x00, 0x5e, 0xef, 0x10,
|
|
0x22, 0x11, 0x00, 0x03, 0x00, 0x00, 0xfc
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestMulticast8bitAddress(void)
|
|
{
|
|
TestIphcVector testVector("Multicast address 8-bit");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"ff02::2");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x3b, 0x3a, 0x02};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestStatefulSource64bitDestination64bitContext0(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression source and destination addresses 64-bit, context 0");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fd00:cafe:face:1234:abcd:ef01:2345:6789",
|
|
"fd00:cafe:face:1234:c31d:a702:0d41:beef");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x55, 0x3a, 0xab, 0xcd, 0xef, 0x01, 0x23,
|
|
0x45, 0x67, 0x89, 0xc3, 0x1d, 0xa7, 0x02, 0x0d,
|
|
0x41, 0xbe, 0xef
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestStatefulSource64bitDestination64bitContext0IfContextInLine(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression source and destination addresses 64-bit, context 0 inline");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fd00:cafe:face:1234:abcd:ef01:2345:6789",
|
|
"fd00:cafe:face:1234:c31d:a702:0d41:beef");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0xd5, 0x00, 0x3a, 0xab, 0xcd, 0xef, 0x01, 0x23,
|
|
0x45, 0x67, 0x89, 0xc3, 0x1d, 0xa7, 0x02, 0x0d,
|
|
0x41, 0xbe, 0xef
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform decompression test only.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestStatefulSource16bitDestination16bitContext0(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression source and destination addresses 16-bit, context 0");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:fffc",
|
|
"fd00:cafe:face:1234::ff:fe00:fffe");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x66, 0x3a, 0xff, 0xfc, 0xff, 0xfe};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestStatefulCompressableLongAddressesContext0(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression compressable long addresses, context 0");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fd00:cafe:face:1234:0200:5eef:1022:1100",
|
|
"fd00:cafe:face:1234:0200:5eef:10aa:bbcc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x77, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestStatefulCompressableShortAddressesContext0(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression compressable short addresses, context 0");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"fd00:cafe:face:1234::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x77, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestStatefulCompressableLongShortAddressesContext0(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression compressable long and short addresses, context 0");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fd00:cafe:face:1234:0200:5eef:1022:1100",
|
|
"fd00:cafe:face:1234::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x77, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestStatefulSource64bitDestination128bitContext1(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression source addresses 64-bit and destination inline, context 1");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"2001:2:0:1:abcd:ef01:2345:6789",
|
|
"2001:2:0:3:c31d:a702:0d41:beef");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0xd0, 0x10, 0x3a, 0xab, 0xcd, 0xef, 0x01, 0x23,
|
|
0x45, 0x67, 0x89, 0x20, 0x01, 0x00, 0x02, 0x00, 0x00,
|
|
0x00, 0x03, 0xc3, 0x1d, 0xa7, 0x02, 0x0d, 0x41, 0xbe,
|
|
0xef
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestStatefulSource64bitDestination64bitContext1(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression source and destination addresses 64-bit, context 1");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"2001:2:0:1:abcd:ef01:2345:6789",
|
|
"2001:2:0:1:c31d:a702:0d41:beef");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0xd5, 0x11, 0x3a, 0xab, 0xcd, 0xef, 0x01, 0x23,
|
|
0x45, 0x67, 0x89, 0xc3, 0x1d, 0xa7, 0x02, 0x0d, 0x41,
|
|
0xbe, 0xef
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestStatefulSourceDestinationInlineContext2CIDFalse(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression source and destination addresses inline, context 2 (C=FALSE)");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"2001:2:0:2:abcd:ef01:2345:6789",
|
|
"2001:2:0:2:c31d:a702:0d41:beef");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x00, 0x3a, 0x20, 0x01, 0x00, 0x02, 0x00,
|
|
0x00, 0x00, 0x02, 0xab, 0xcd, 0xef, 0x01, 0x23,
|
|
0x45, 0x67, 0x89, 0x20, 0x01, 0x00, 0x02, 0x00,
|
|
0x00, 0x00, 0x02, 0xc3, 0x1d, 0xa7, 0x02, 0x0d,
|
|
0x41, 0xbe, 0xef
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression test only.
|
|
Test(testVector, true, false);
|
|
}
|
|
|
|
static void TestStatefulMulticastDestination48bitContext0(void)
|
|
{
|
|
TestIphcVector testVector("Stateful compression multicast address, context 0");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fd00:cafe:face:1234:0200:5eef:1022:1100",
|
|
"ff33:0040:fd00:cafe:face:1234:0000:0001");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x7c, 0x3a, 0x33, 0x00, 0x00, 0x00, 0x00,
|
|
0x01
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestTrafficClassFlowLabel3Bytes(void)
|
|
{
|
|
TestIphcVector testVector("Traffic Class and Flow Label 3 bytes");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x6011ac59, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x6a, 0x33, 0x41, 0xac, 0x59, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestTrafficClassFlowLabel1Byte(void)
|
|
{
|
|
TestIphcVector testVector("Traffic Class and Flow Label 1 byte");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60d00000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x72, 0x33, 0x43, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestTrafficClassFlowLabel1ByteEcnOnly(void)
|
|
{
|
|
TestIphcVector testVector("Traffic Class and Flow Label 1 byte with ecn only");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60100000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x72, 0x33, 0x40, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestTrafficClassFlowLabelInline(void)
|
|
{
|
|
TestIphcVector testVector("Traffic Class and Flow Label inline");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x6ea12345, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x62, 0x33, 0xBA, 0x01, 0x23, 0x45, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestHopLimit1(void)
|
|
{
|
|
TestIphcVector testVector("Hop Limit 1");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 1,
|
|
"fe80::ff:fe00:0000",
|
|
"fe80::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x79, 0x33, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestHopLimit255(void)
|
|
{
|
|
TestIphcVector testVector("Hop Limit 255");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 255,
|
|
"fe80::ff:fe00:0000",
|
|
"fe80::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7B, 0x33, 0x3a};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestHopLimitInline(void)
|
|
{
|
|
TestIphcVector testVector("Hop Limit Inline");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 63,
|
|
"fe80::ff:fe00:0000",
|
|
"fe80::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x78, 0x33, 0x3a, 0x3f};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestUdpSourceDestinationInline(void)
|
|
{
|
|
TestIphcVector testVector("UDP source and destination inline");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Setup UDP header.
|
|
testVector.SetUDPHeader(5683, 5684, sizeof(sTestPayloadDefault) + 8, 0xbeef);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x33, 0xf0, 0x16, 0x33, 0x16, 0x34, 0xbe, 0xef};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestUdpSourceInlineDestination8bit(void)
|
|
{
|
|
TestIphcVector testVector("UDP source inline destination 8-bit");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Setup UDP header.
|
|
testVector.SetUDPHeader(5683, 61441, sizeof(sTestPayloadDefault) + 8, 0xbeef);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x33, 0xf1, 0x16, 0x33, 0x01, 0xbe, 0xef};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestUdpSource8bitDestinationInline(void)
|
|
{
|
|
TestIphcVector testVector("UDP source 8-bit destination 8-bit");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Setup UDP header.
|
|
testVector.SetUDPHeader(61695, 5683, sizeof(sTestPayloadDefault) + 8, 0xbeef);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x33, 0xf2, 0xff, 0x16, 0x33, 0xbe, 0xef};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestUdpFullyCompressed(void)
|
|
{
|
|
TestIphcVector testVector("UDP fully compressed");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Setup UDP header.
|
|
testVector.SetUDPHeader(61616, 61631, sizeof(sTestPayloadDefault) + 8, 0xface);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x33, 0xf3, 0x0f, 0xfa, 0xce};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestUdpFullyCompressedMulticast(void)
|
|
{
|
|
TestIphcVector testVector("UDP fully compressed with IP multicast");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"ff02::1");
|
|
|
|
// Setup UDP header.
|
|
testVector.SetUDPHeader(61616, 61631, sizeof(sTestPayloadDefault) + 8, 0xface);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x3b, 0x01, 0xf3, 0x0f, 0xfa, 0xce};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestUdpWithoutNhc(void)
|
|
{
|
|
TestIphcVector testVector("UDP without LOWPAN_NHC compression");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultShort);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoUdp, 64,
|
|
"fe80::ff:fe00:0000",
|
|
"fe80::ff:fe00:c003");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x33, 0x11};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(40);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform only decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopNoPadding(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with no padding");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x04, 0x60, 0x11, 0x00, 0x0c};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a,
|
|
0x06, 0x6d, 0x04, 0x60, 0x11, 0x00, 0x0c
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopPad1(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with Pad1");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x03, 0x60, 0x11, 0x00, 0x00};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a,
|
|
0x05, 0x6d, 0x03, 0x60, 0x11, 0x00
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopPadN2(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN2");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x02, 0x60, 0x11, 0x01, 0x00};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a,
|
|
0x04, 0x6d, 0x02, 0x60, 0x11
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopPadN3(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN3");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x01, 0x60, 0x01, 0x01, 0x00};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a,
|
|
0x03, 0x6d, 0x01, 0x60
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopPadN4(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN4");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x00, 0x01, 0x02, 0x00, 0x00};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a,
|
|
0x02, 0x6d, 0x00
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(48);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopPadN5(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN5");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 16, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x3a, 0x01, 0x6d, 0x07, 0x01, 0x02, 0x01, 0x00,
|
|
0x00, 0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00
|
|
};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a,
|
|
0x09, 0x6d, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00,
|
|
0x00, 0x33
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(56);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopPadN6(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN6");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 24, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x3a, 0x02, 0x6d, 0x0e, 0x01, 0x02, 0x01, 0x00,
|
|
0x00, 0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00,
|
|
0x11, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a,
|
|
0x10, 0x6d, 0x0e, 0x01, 0x02, 0x01, 0x00, 0x00,
|
|
0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00, 0x11,
|
|
0x00
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(64);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopPadN7(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN7");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 24, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x3a, 0x02, 0x6d, 0x0d, 0x01, 0x02, 0x01, 0x00,
|
|
0x00, 0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00,
|
|
0x11, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a,
|
|
0x0f, 0x6d, 0x0d, 0x01, 0x02, 0x01, 0x00, 0x00,
|
|
0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00, 0x11
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(64);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestExtensionHeaderHopByHopPadN2UdpFullyCompressed(void)
|
|
{
|
|
TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN2 and UDP");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 16, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::1");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x11, 0x00, 0x6d, 0x02, 0x60, 0x11, 0x01, 0x00};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Setup UDP header.
|
|
testVector.SetUDPHeader(61616, 61631, sizeof(sTestPayloadDefault) + 8, 0xface);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe1, 0x04,
|
|
0x6d, 0x02, 0x60, 0x11, 0xf3, 0x0f, 0xfa, 0xce
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(56);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestIpInIpHopByHopPadN2UdpSourceDestinationInline(void)
|
|
{
|
|
TestIphcVector testVector("IP-in-IP with Hop-by-Hop with PadN2 and UDP");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultShort);
|
|
testVector.SetMacDestination(sTestMacDestinationBroadcast);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 56, Ip6::kProtoHopOpts, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff03::fc");
|
|
|
|
// Setup extension header.
|
|
uint8_t extHeader[] = {0x29, 0x00, 0x6d, 0x02, 0x00, 0x11, 0x01, 0x00};
|
|
testVector.SetExtHeader(extHeader, sizeof(extHeader));
|
|
|
|
// Setup IPv6 tunneled header.
|
|
testVector.SetIpTunneledHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64,
|
|
"fd00:cafe:face:1234::ff:fe00:0000",
|
|
"ff05::1");
|
|
|
|
// Setup UDP header.
|
|
testVector.SetUDPHeader(5683, 5684, sizeof(sTestPayloadDefault) + 8, 0xbeef);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0xfc, 0xe1, 0x04,
|
|
0x6d, 0x02, 0x00, 0x11, 0xee, 0x7e, 0x7a, 0x05,
|
|
0x00, 0x00, 0x01, 0xf0, 0x16, 0x33, 0x16, 0x34,
|
|
0xbe, 0xef
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(96);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestIpInIpWithoutExtensionHeader(void)
|
|
{
|
|
TestIphcVector testVector("IP-in-IP without extension header");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Setup IPv6 header.
|
|
testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 40, Ip6::kProtoIp6, 64,
|
|
"fe80::200:5eef:1022:1100",
|
|
"ff03::1");
|
|
|
|
// Setup IPv6 tunneled header.
|
|
testVector.SetIpTunneledHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 1,
|
|
"fe80::200:5eef:1022:1100",
|
|
"fe80::200:5eef:10aa:bbcc");
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x3a, 0x03, 0x00, 0x00, 0x01, 0xee, 0x79,
|
|
0x33, 0x3a
|
|
};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault));
|
|
testVector.SetPayloadOffset(80);
|
|
testVector.SetError(OT_ERROR_NONE);
|
|
|
|
// Perform compression and decompression tests.
|
|
Test(testVector, true, true);
|
|
}
|
|
|
|
static void TestErrorNoIphcDispatch(void)
|
|
{
|
|
TestIphcVector testVector("Invalid dispatch");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x40, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestErrorTruncatedIphc(void)
|
|
{
|
|
TestIphcVector testVector("Truncated LOWPAN_IPHC");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x00};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestErrorReservedValueDestination0100(void)
|
|
{
|
|
TestIphcVector testVector("Reserved value of M-DAC-DAM - 0100");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x34, 0x3A};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestErrorReservedValueDestination1101(void)
|
|
{
|
|
TestIphcVector testVector("Reserved value of M-DAC-DAM - 1101");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x3D, 0x3A};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestErrorReservedValueDestination1110(void)
|
|
{
|
|
TestIphcVector testVector("Reserved value of M-DAC-DAM - 1110");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x3E, 0x3A};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestErrorReservedValueDestination1111(void)
|
|
{
|
|
TestIphcVector testVector("Reserved value of M-DAC-DAM - 1111");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7a, 0x3F, 0x3A};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestErrorUnknownNhc(void)
|
|
{
|
|
TestIphcVector testVector("Unknown value of LOWPAN_NHC ID");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x33, 0x00};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestErrorReservedNhc5(void)
|
|
{
|
|
TestIphcVector testVector("Reserved value of LOWPAN_NHC EID - 0x05");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x33, 0xea};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
static void TestErrorReservedNhc6(void)
|
|
{
|
|
TestIphcVector testVector("Reserved value of LOWPAN_NHC EID - 0x06");
|
|
|
|
// Setup MAC addresses.
|
|
testVector.SetMacSource(sTestMacSourceDefaultLong);
|
|
testVector.SetMacDestination(sTestMacDestinationDefaultLong);
|
|
|
|
// Set LOWPAN_IPHC header.
|
|
uint8_t iphc[] = {0x7e, 0x33, 0xec};
|
|
testVector.SetIphcHeader(iphc, sizeof(iphc));
|
|
|
|
// Set payload and error.
|
|
testVector.SetError(OT_ERROR_PARSE);
|
|
|
|
// Perform decompression test.
|
|
Test(testVector, false, true);
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
* @section Main test.
|
|
**************************************************************************************************/
|
|
|
|
void TestLowpanIphc(void)
|
|
{
|
|
sInstance = testInitInstance();
|
|
|
|
VerifyOrQuit(sInstance != NULL, "NULL instance");
|
|
|
|
sIp6 = &sInstance->mIp6;
|
|
sThreadNetif = &sInstance->mThreadNetif;
|
|
sLowpan = &sThreadNetif->GetLowpan();
|
|
|
|
Init();
|
|
|
|
// Stateless unicast addresses compression / decompression tests.
|
|
TestFullyCompressableLongAddresses();
|
|
TestFullyCompressableShortAddresses();
|
|
TestFullyCompressableShortLongAddresses();
|
|
TestFullyCompressableLongShortAddresses();
|
|
TestSourceUnspecifiedAddress();
|
|
TestSource128bitDestination128bitAddresses();
|
|
TestSource64bitDestination64bitLongAddresses();
|
|
TestSource64bitDestination64bitShortAddresses();
|
|
TestSource16bitDestination16bitAddresses();
|
|
TestSourceCompressedDestination16bitAddresses();
|
|
TestSourceCompressedDestination128bitAddresses();
|
|
|
|
// Stateless multicast addresses compression / decompression tests.
|
|
TestMulticast128bitAddress();
|
|
TestMulticast48bitAddress();
|
|
TestMulticast32bitAddress();
|
|
TestMulticast8bitAddress();
|
|
|
|
// Stateful unicast addresses compression / decompression tests.
|
|
TestStatefulSource64bitDestination64bitContext0();
|
|
TestStatefulSource64bitDestination64bitContext0IfContextInLine();
|
|
TestStatefulSource16bitDestination16bitContext0();
|
|
TestStatefulCompressableLongAddressesContext0();
|
|
TestStatefulCompressableShortAddressesContext0();
|
|
TestStatefulCompressableLongShortAddressesContext0();
|
|
TestStatefulSource64bitDestination128bitContext1();
|
|
TestStatefulSource64bitDestination64bitContext1();
|
|
TestStatefulSourceDestinationInlineContext2CIDFalse();
|
|
|
|
// Stateful multicast addresses compression / decompression tests.
|
|
TestStatefulMulticastDestination48bitContext0();
|
|
|
|
// Traffic Class and Flow Label compression / decompression tests.
|
|
TestTrafficClassFlowLabel3Bytes();
|
|
TestTrafficClassFlowLabel1Byte();
|
|
TestTrafficClassFlowLabel1ByteEcnOnly();
|
|
TestTrafficClassFlowLabelInline();
|
|
|
|
// Hop Limit compression / decompression tests.
|
|
TestHopLimit1();
|
|
TestHopLimit255();
|
|
TestHopLimitInline();
|
|
|
|
// UDP compression / decompression tests.
|
|
TestUdpSourceDestinationInline();
|
|
TestUdpSourceInlineDestination8bit();
|
|
TestUdpSource8bitDestinationInline();
|
|
TestUdpFullyCompressed();
|
|
TestUdpFullyCompressedMulticast();
|
|
TestUdpWithoutNhc();
|
|
|
|
// Extension Headers compression / decompression tests.
|
|
TestExtensionHeaderHopByHopNoPadding();
|
|
TestExtensionHeaderHopByHopPad1();
|
|
TestExtensionHeaderHopByHopPadN2();
|
|
TestExtensionHeaderHopByHopPadN3();
|
|
TestExtensionHeaderHopByHopPadN4();
|
|
TestExtensionHeaderHopByHopPadN5();
|
|
TestExtensionHeaderHopByHopPadN6();
|
|
TestExtensionHeaderHopByHopPadN7();
|
|
TestExtensionHeaderHopByHopPadN2UdpFullyCompressed();
|
|
|
|
// IP-in-IP compression / decompression tests.
|
|
TestIpInIpHopByHopPadN2UdpSourceDestinationInline();
|
|
TestIpInIpWithoutExtensionHeader();
|
|
|
|
// Invalid frame to be decompressed.
|
|
TestErrorNoIphcDispatch();
|
|
TestErrorTruncatedIphc();
|
|
TestErrorReservedValueDestination0100();
|
|
TestErrorReservedValueDestination1101();
|
|
TestErrorReservedValueDestination1110();
|
|
TestErrorReservedValueDestination1111();
|
|
TestErrorUnknownNhc();
|
|
TestErrorReservedNhc5();
|
|
TestErrorReservedNhc6();
|
|
|
|
testFreeInstance(sInstance);
|
|
}
|
|
|
|
} // namespace ot
|
|
|
|
#ifdef ENABLE_TEST_MAIN
|
|
int main(void)
|
|
{
|
|
TestLowpanIphc();
|
|
|
|
printf("All tests passed\n");
|
|
return 0;
|
|
}
|
|
#endif
|