espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-08-23 02:39:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

[test] define all unit tests in ot namespace (#9617)

Browse Source 
This commit updates unit test modules to be defined under the `ot`
namespace. This aligns all the unit tests to follow the same
model, eliminating the need to use `ot::` prefix in unit test
code.
This commit is contained in:
Abtin Keshavarzian
2023-11-19 18:40:20 -08:00
committed by GitHub
parent b77573586c
commit 23c0fc4d4b
28 changed files with 436 additions and 389 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/test_ip_address.cpp
+139 -134
View File
@@ -36,16 +36,18 @@
#include "test_util.h"
namespace ot {
template <typename AddressType> struct TestVector
{
const char *mString;
const uint8_t mAddr[sizeof(AddressType)];
ot::Error mError;
Error mError;
};
template <typename AddressType> static void checkAddressFromString(TestVector<AddressType> *aTestVector)
{
ot::Error error;
Error error;
AddressType address;
address.Clear();
@@ -53,11 +55,11 @@ template <typename AddressType> static void checkAddressFromString(TestVector<Ad
error = address.FromString(aTestVector->mString);
printf("%-42s -> %-42s\n", aTestVector->mString,
(error == ot::kErrorNone) ? address.ToString().AsCString() : "(parse error)");
(error == kErrorNone) ? address.ToString().AsCString() : "(parse error)");
VerifyOrQuit(error == aTestVector->mError, "Address::FromString returned unexpected error code");
if (error == ot::kErrorNone)
if (error == kErrorNone)
{
VerifyOrQuit(0 == memcmp(address.GetBytes(), aTestVector->mAddr, sizeof(AddressType)),
"Address::FromString parsing failed");
@@ -66,102 +68,102 @@ template <typename AddressType> static void checkAddressFromString(TestVector<Ad
void TestIp6AddressFromString(void)
{
typedef TestVector<ot::Ip6::Address> Ip6AddressTestVector;
typedef TestVector<Ip6::Address> Ip6AddressTestVector;
Ip6AddressTestVector testVectors[] = {
// Valid full IPv6 address.
{"0102:0304:0506:0708:090a:0b0c:0d0e:0f00",
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00},
ot::kErrorNone},
kErrorNone},
// Valid full address using capital letters.
{"0102:0304:0506:0708:090A:0B0C:0D0E:0F00",
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00},
ot::kErrorNone},
kErrorNone},
// Valid full IPv6 address with mixed capital and small letters.
{"0102:0304:0506:0708:090a:0B0C:0d0E:0F00",
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00},
ot::kErrorNone},
kErrorNone},
// Short prefix and full IID.
{"fd11::abcd:e0e0:d10e:0001",
{0xfd, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0xcd, 0xe0, 0xe0, 0xd1, 0x0e, 0x00, 0x01},
ot::kErrorNone},
kErrorNone},
// Valid IPv6 address with unnecessary :: symbol.
{"fd11:1234:5678:abcd::abcd:e0e0:d10e:1000",
{0xfd, 0x11, 0x12, 0x34, 0x56, 0x78, 0xab, 0xcd, 0xab, 0xcd, 0xe0, 0xe0, 0xd1, 0x0e, 0x10, 0x00},
ot::kErrorNone},
kErrorNone},
// Short multicast address.
{"ff03::0b",
{0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b},
ot::kErrorNone},
kErrorNone},
// Unspecified address.
{"::", {0}, ot::kErrorNone},
{"::", {0}, kErrorNone},
// Starts with ::
{"::1:2:3:4",
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04},
ot::kErrorNone},
kErrorNone},
// Ends with ::
{"1001:2002:3003:4004::",
{0x10, 0x01, 0x20, 0x02, 0x30, 0x03, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
ot::kErrorNone},
kErrorNone},
// Valid embedded IPv4 address.
{"64:ff9b::100.200.15.4",
{0x00, 0x64, 0xff, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0xc8, 0x0f, 0x04},
ot::kErrorNone},
kErrorNone},
// Valid embedded IPv4 address.
{"2001:db8::abc:def1:127.0.0.1",
{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xbc, 0xde, 0xf1, 0x7f, 0x00, 0x00, 0x01},
ot::kErrorNone},
kErrorNone},
// Valid embedded IPv4 address.
{"1:2:3:4:5:6:127.1.2.3",
{0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x7f, 0x01, 0x02, 0x03},
ot::kErrorNone},
kErrorNone},
// Two :: should cause a parse error.
{"2001:db8::a::b", {0}, ot::kErrorParse},
{"2001:db8::a::b", {0}, kErrorParse},
// The "g" and "h" are not the hex characters.
{"2001:db8::abcd:efgh", {0}, ot::kErrorParse},
{"2001:db8::abcd:efgh", {0}, kErrorParse},
// Too many colons.
{"1:2:3:4:5:6:7:8:9", {0}, ot::kErrorParse},
{"1:2:3:4:5:6:7:8:9", {0}, kErrorParse},
// Too many characters in a single part.
{"2001:db8::abc:def12:1:2", {0}, ot::kErrorParse},
{"2001:db8::abc:def12:1:2", {0}, kErrorParse},
// Invalid embedded IPv4 address.
{"64:ff9b::123.231.0.257", {0}, ot::kErrorParse},
{"64:ff9b::123.231.0.257", {0}, kErrorParse},
// Invalid embedded IPv4 address.
{"64:ff9b::1.22.33", {0}, ot::kErrorParse},
{"64:ff9b::1.22.33", {0}, kErrorParse},
// Invalid embedded IPv4 address.
{"64:ff9b::1.22.33.44.5", {0}, ot::kErrorParse},
{"64:ff9b::1.22.33.44.5", {0}, kErrorParse},
// Too long with embedded IPv4 address.
{"1:2:3:4:5:6:7:127.1.2.3", {0}, ot::kErrorParse},
{"1:2:3:4:5:6:7:127.1.2.3", {0}, kErrorParse},
// Invalid embedded IPv4 address.
{".", {0}, ot::kErrorParse},
{".", {0}, kErrorParse},
// Invalid embedded IPv4 address.
{":.", {0}, ot::kErrorParse},
{":.", {0}, kErrorParse},
// Invalid embedded IPv4 address.
{"::.", {0}, ot::kErrorParse},
{"::.", {0}, kErrorParse},
// Invalid embedded IPv4 address.
{":f:0:0:c:0:f:f:.", {0}, ot::kErrorParse},
{":f:0:0:c:0:f:f:.", {0}, kErrorParse},
};
for (Ip6AddressTestVector &testVector : testVectors)
@@ -175,11 +177,11 @@ void TestIp6AddressFromString(void)
{
constexpr uint16_t kMaxString = 80;
ot::Ip6::Prefix prefix;
char string[kMaxString];
uint16_t length;
Ip6::Prefix prefix;
char string[kMaxString];
uint16_t length;
length = ot::StringLength(testVector.mString, kMaxString);
length = StringLength(testVector.mString, kMaxString);
memcpy(string, testVector.mString, length);
VerifyOrQuit(length + sizeof("/128") <= kMaxString);
strcpy(&string[length], "/128");
@@ -188,9 +190,9 @@ void TestIp6AddressFromString(void)
VerifyOrQuit(prefix.FromString(string) == testVector.mError);
if (testVector.mError == ot::kErrorNone)
if (testVector.mError == kErrorNone)
{
VerifyOrQuit(memcmp(prefix.GetBytes(), testVector.mAddr, sizeof(ot::Ip6::Address)) == 0);
VerifyOrQuit(memcmp(prefix.GetBytes(), testVector.mAddr, sizeof(Ip6::Address)) == 0);
VerifyOrQuit(prefix.GetLength() == 128);
}
}
@@ -198,7 +200,7 @@ void TestIp6AddressFromString(void)
void TestIp6PrefixFromString(void)
{
ot::Ip6::Prefix prefix;
Ip6::Prefix prefix;
SuccessOrQuit(prefix.FromString("::/128"));
VerifyOrQuit(prefix.GetLength() == 128);
@@ -212,32 +214,32 @@ void TestIp6PrefixFromString(void)
SuccessOrQuit(prefix.FromString("::/0"));
VerifyOrQuit(prefix.GetLength() == 0);
VerifyOrQuit(prefix.FromString("::") == ot::kErrorParse);
VerifyOrQuit(prefix.FromString("::/") == ot::kErrorParse);
VerifyOrQuit(prefix.FromString("::/129") == ot::kErrorParse);
VerifyOrQuit(prefix.FromString(":: /12") == ot::kErrorParse);
VerifyOrQuit(prefix.FromString("::/a1") == ot::kErrorParse);
VerifyOrQuit(prefix.FromString("::/12 ") == ot::kErrorParse);
VerifyOrQuit(prefix.FromString("::") == kErrorParse);
VerifyOrQuit(prefix.FromString("::/") == kErrorParse);
VerifyOrQuit(prefix.FromString("::/129") == kErrorParse);
VerifyOrQuit(prefix.FromString(":: /12") == kErrorParse);
VerifyOrQuit(prefix.FromString("::/a1") == kErrorParse);
VerifyOrQuit(prefix.FromString("::/12 ") == kErrorParse);
}
void TestIp4AddressFromString(void)
{
typedef TestVector<ot::Ip4::Address> Ip4AddressTestVector;
typedef TestVector<Ip4::Address> Ip4AddressTestVector;
Ip4AddressTestVector testVectors[] = {
{"0.0.0.0", {0, 0, 0, 0}, ot::kErrorNone},
{"255.255.255.255", {255, 255, 255, 255}, ot::kErrorNone},
{"127.0.0.1", {127, 0, 0, 1}, ot::kErrorNone},
{"1.2.3.4", {1, 2, 3, 4}, ot::kErrorNone},
{"001.002.003.004", {1, 2, 3, 4}, ot::kErrorNone},
{"00000127.000.000.000001", {127, 0, 0, 1}, ot::kErrorNone},
{"123.231.0.256", {0}, ot::kErrorParse}, // Invalid byte value.
{"100123.231.0.256", {0}, ot::kErrorParse}, // Invalid byte value.
{"1.22.33", {0}, ot::kErrorParse}, // Too few bytes.
{"1.22.33.44.5", {0}, ot::kErrorParse}, // Too many bytes.
{"a.b.c.d", {0}, ot::kErrorParse}, // Wrong digit char.
{"123.23.45 .12", {0}, ot::kErrorParse}, // Extra space.
{".", {0}, ot::kErrorParse}, // Invalid.
{"0.0.0.0", {0, 0, 0, 0}, kErrorNone},
{"255.255.255.255", {255, 255, 255, 255}, kErrorNone},
{"127.0.0.1", {127, 0, 0, 1}, kErrorNone},
{"1.2.3.4", {1, 2, 3, 4}, kErrorNone},
{"001.002.003.004", {1, 2, 3, 4}, kErrorNone},
{"00000127.000.000.000001", {127, 0, 0, 1}, kErrorNone},
{"123.231.0.256", {0}, kErrorParse}, // Invalid byte value.
{"100123.231.0.256", {0}, kErrorParse}, // Invalid byte value.
{"1.22.33", {0}, kErrorParse}, // Too few bytes.
{"1.22.33.44.5", {0}, kErrorParse}, // Too many bytes.
{"a.b.c.d", {0}, kErrorParse}, // Wrong digit char.
{"123.23.45 .12", {0}, kErrorParse}, // Extra space.
{".", {0}, kErrorParse}, // Invalid.
};
for (Ip4AddressTestVector &testVector : testVectors)
@@ -251,24 +253,24 @@ struct CidrTestVector
const char *mString;
const uint8_t mAddr[sizeof(otIp4Address)];
const uint8_t mLength;
ot::Error mError;
Error mError;
};
static void checkCidrFromString(CidrTestVector *aTestVector)
{
ot::Error error;
ot::Ip4::Cidr cidr;
Error error;
Ip4::Cidr cidr;
cidr.Clear();
error = cidr.FromString(aTestVector->mString);
printf("%-42s -> %-42s\n", aTestVector->mString,
(error == ot::kErrorNone) ? cidr.ToString().AsCString() : "(parse error)");
(error == kErrorNone) ? cidr.ToString().AsCString() : "(parse error)");
VerifyOrQuit(error == aTestVector->mError, "Address::FromString returned unexpected error code");
if (error == ot::kErrorNone)
if (error == kErrorNone)
{
VerifyOrQuit(0 == memcmp(cidr.GetBytes(), aTestVector->mAddr, sizeof(aTestVector->mAddr)),
"Cidr::FromString parsing failed");
@@ -279,37 +281,37 @@ static void checkCidrFromString(CidrTestVector *aTestVector)
void TestIp4CidrFromString(void)
{
CidrTestVector testVectors[] = {
{"0.0.0.0/0", {0, 0, 0, 0}, 0, ot::kErrorNone},
{"255.255.255.255/32", {255, 255, 255, 255}, 32, ot::kErrorNone},
{"127.0.0.1/8", {127, 0, 0, 1}, 8, ot::kErrorNone},
{"1.2.3.4/24", {1, 2, 3, 4}, 24, ot::kErrorNone},
{"001.002.003.004/20", {1, 2, 3, 4}, 20, ot::kErrorNone},
{"00000127.000.000.000001/8", {127, 0, 0, 1}, 8, ot::kErrorNone},
{"0.0.0.0/0", {0, 0, 0, 0}, 0, kErrorNone},
{"255.255.255.255/32", {255, 255, 255, 255}, 32, kErrorNone},
{"127.0.0.1/8", {127, 0, 0, 1}, 8, kErrorNone},
{"1.2.3.4/24", {1, 2, 3, 4}, 24, kErrorNone},
{"001.002.003.004/20", {1, 2, 3, 4}, 20, kErrorNone},
{"00000127.000.000.000001/8", {127, 0, 0, 1}, 8, kErrorNone},
// Valid suffix, invalid address
{"123.231.0.256/4", {0}, 0, ot::kErrorParse}, // Invalid byte value.
{"100123.231.0.256/4", {0}, 0, ot::kErrorParse}, // Invalid byte value.
{"1.22.33/4", {0}, 0, ot::kErrorParse}, // Too few bytes.
{"1.22.33.44.5/4", {0}, 0, ot::kErrorParse}, // Too many bytes.
{"a.b.c.d/4", {0}, 0, ot::kErrorParse}, // Wrong digit char.
{"123.23.45 .12/4", {0}, 0, ot::kErrorParse}, // Extra space.
{"./4", {0}, 0, ot::kErrorParse}, // Invalid.
{"123.231.0.256/4", {0}, 0, kErrorParse}, // Invalid byte value.
{"100123.231.0.256/4", {0}, 0, kErrorParse}, // Invalid byte value.
{"1.22.33/4", {0}, 0, kErrorParse}, // Too few bytes.
{"1.22.33.44.5/4", {0}, 0, kErrorParse}, // Too many bytes.
{"a.b.c.d/4", {0}, 0, kErrorParse}, // Wrong digit char.
{"123.23.45 .12/4", {0}, 0, kErrorParse}, // Extra space.
{"./4", {0}, 0, kErrorParse}, // Invalid.
// valid address, invalid suffix
{"1.2.3.4/33", {0}, 0, ot::kErrorParse}, // Prefix length too large
{"1.2.3.4/12345678", {0}, 0, ot::kErrorParse}, // Prefix length too large?
{"1.2.3.4/12a", {0}, 0, ot::kErrorParse}, // Extra char after prefix length.
{"1.2.3.4/-1", {0}, 0, ot::kErrorParse}, // Not even a non-negative integer.
{"1.2.3.4/3.14", {0}, 0, ot::kErrorParse}, // Not even a integer.
{"1.2.3.4/abcd", {0}, 0, ot::kErrorParse}, // Not even a number.
{"1.2.3.4/", {0}, 0, ot::kErrorParse}, // Where is the suffix?
{"1.2.3.4", {0}, 0, ot::kErrorParse}, // Where is the suffix?
{"1.2.3.4/33", {0}, 0, kErrorParse}, // Prefix length too large
{"1.2.3.4/12345678", {0}, 0, kErrorParse}, // Prefix length too large?
{"1.2.3.4/12a", {0}, 0, kErrorParse}, // Extra char after prefix length.
{"1.2.3.4/-1", {0}, 0, kErrorParse}, // Not even a non-negative integer.
{"1.2.3.4/3.14", {0}, 0, kErrorParse}, // Not even a integer.
{"1.2.3.4/abcd", {0}, 0, kErrorParse}, // Not even a number.
{"1.2.3.4/", {0}, 0, kErrorParse}, // Where is the suffix?
{"1.2.3.4", {0}, 0, kErrorParse}, // Where is the suffix?
// invalid address and invalid suffix
{"123.231.0.256/41", {0}, 0, ot::kErrorParse}, // Invalid byte value.
{"100123.231.0.256/abc", {0}, 0, ot::kErrorParse}, // Invalid byte value.
{"1.22.33", {0}, 0, ot::kErrorParse}, // Too few bytes.
{"1.22.33.44.5/36", {0}, 0, ot::kErrorParse}, // Too many bytes.
{"a.b.c.d/99", {0}, 0, ot::kErrorParse}, // Wrong digit char.
{"123.23.45 .12", {0}, 0, ot::kErrorParse}, // Extra space.
{".", {0}, 0, ot::kErrorParse}, // Invalid.
{"123.231.0.256/41", {0}, 0, kErrorParse}, // Invalid byte value.
{"100123.231.0.256/abc", {0}, 0, kErrorParse}, // Invalid byte value.
{"1.22.33", {0}, 0, kErrorParse}, // Too few bytes.
{"1.22.33.44.5/36", {0}, 0, kErrorParse}, // Too many bytes.
{"a.b.c.d/99", {0}, 0, kErrorParse}, // Wrong digit char.
{"123.23.45 .12", {0}, 0, kErrorParse}, // Extra space.
{".", {0}, 0, kErrorParse}, // Invalid.
};
for (CidrTestVector &testVector : testVectors)
@@ -318,7 +320,7 @@ void TestIp4CidrFromString(void)
}
}
bool CheckPrefix(const ot::Ip6::Address &aAddress, const uint8_t *aPrefix, uint8_t aPrefixLength)
bool CheckPrefix(const Ip6::Address &aAddress, const uint8_t *aPrefix, uint8_t aPrefixLength)
{
// Check the first aPrefixLength bits of aAddress to match the given aPrefix.
@@ -339,7 +341,7 @@ bool CheckPrefix(const ot::Ip6::Address &aAddress, const uint8_t *aPrefix, uint8
return matches;
}
bool CheckPrefixInIid(const ot::Ip6::InterfaceIdentifier &aIid, const uint8_t *aPrefix, uint8_t aPrefixLength)
bool CheckPrefixInIid(const Ip6::InterfaceIdentifier &aIid, const uint8_t *aPrefix, uint8_t aPrefixLength)
{
// Check the IID to contain the prefix bits (applicable when prefix length is longer than 64).
@@ -360,13 +362,13 @@ bool CheckPrefixInIid(const ot::Ip6::InterfaceIdentifier &aIid, const uint8_t *a
return matches;
}
bool CheckInterfaceId(const ot::Ip6::Address &aAddress1, const ot::Ip6::Address &aAddress2, uint8_t aPrefixLength)
bool CheckInterfaceId(const Ip6::Address &aAddress1, const Ip6::Address &aAddress2, uint8_t aPrefixLength)
{
// Check whether all the bits after aPrefixLength of the two given IPv6 Address match or not.
bool matches = true;
for (size_t bit = aPrefixLength; bit < sizeof(ot::Ip6::Address) * CHAR_BIT; bit++)
for (size_t bit = aPrefixLength; bit < sizeof(Ip6::Address) * CHAR_BIT; bit++)
{
uint8_t index = bit / CHAR_BIT;
uint8_t mask = (0x80 >> (bit % CHAR_BIT));
@@ -390,10 +392,10 @@ void TestIp6AddressSetPrefix(void)
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
};
ot::Ip6::Address address;
ot::Ip6::Address allZeroAddress;
ot::Ip6::Address allOneAddress;
ot::Ip6::Prefix ip6Prefix;
Ip6::Address address;
Ip6::Address allZeroAddress;
Ip6::Address allOneAddress;
Ip6::Prefix ip6Prefix;
allZeroAddress.Clear();
memset(&allOneAddress, 0xff, sizeof(allOneAddress));
@@ -403,7 +405,7 @@ void TestIp6AddressSetPrefix(void)
memcpy(address.mFields.m8, prefix, sizeof(address));
printf("Prefix is %s\n", address.ToString().AsCString());
for (size_t prefixLength = 0; prefixLength <= sizeof(ot::Ip6::Address) * CHAR_BIT; prefixLength++)
for (size_t prefixLength = 0; prefixLength <= sizeof(Ip6::Address) * CHAR_BIT; prefixLength++)
{
ip6Prefix.Clear();
ip6Prefix.Set(prefix, prefixLength);
@@ -436,10 +438,10 @@ void TestIp6AddressSetPrefix(void)
}
}
ot::Ip6::Prefix PrefixFrom(const char *aAddressString, uint8_t aPrefixLength)
Ip6::Prefix PrefixFrom(const char *aAddressString, uint8_t aPrefixLength)
{
ot::Ip6::Prefix prefix;
ot::Ip6::Address address;
Ip6::Prefix prefix;
Ip6::Address address;
SuccessOrQuit(address.FromString(aAddressString));
prefix.Set(address.GetBytes(), aPrefixLength);
@@ -455,8 +457,8 @@ void TestIp6Prefix(void)
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
};
ot::Ip6::Prefix prefix;
ot::Ip6::Address address1, address2;
Ip6::Prefix prefix;
Ip6::Address address1, address2;
for (auto prefixBytes : kPrefixes)
{
@@ -464,7 +466,7 @@ void TestIp6Prefix(void)
address2 = address1;
address2.mFields.m8[0] ^= 0x80; // Change first bit.
for (uint8_t prefixLength = 1; prefixLength <= ot::Ip6::Prefix::kMaxLength; prefixLength++)
for (uint8_t prefixLength = 1; prefixLength <= Ip6::Prefix::kMaxLength; prefixLength++)
{
prefix.Set(prefixBytes, prefixLength);
@@ -482,7 +484,7 @@ void TestIp6Prefix(void)
for (uint8_t subPrefixLength = 1; subPrefixLength <= prefixLength; subPrefixLength++)
{
ot::Ip6::Prefix subPrefix;
Ip6::Prefix subPrefix;
subPrefix.Set(prefixBytes, subPrefixLength);
@@ -504,10 +506,10 @@ void TestIp6Prefix(void)
for (uint8_t bitNumber = 0; bitNumber < prefixLength; bitNumber++)
{
ot::Ip6::Prefix prefix2;
uint8_t mask = static_cast<uint8_t>(1U << (7 - (bitNumber & 7)));
uint8_t index = (bitNumber / 8);
bool isPrefixSmaller;
Ip6::Prefix prefix2;
uint8_t mask = static_cast<uint8_t>(1U << (7 - (bitNumber & 7)));
uint8_t index = (bitNumber / 8);
bool isPrefixSmaller;
prefix2 = prefix;
VerifyOrQuit(prefix == prefix2);
@@ -528,8 +530,8 @@ void TestIp6Prefix(void)
{
struct TestCase
{
ot::Ip6::Prefix mPrefixA;
ot::Ip6::Prefix mPrefixB;
Ip6::Prefix mPrefixA;
Ip6::Prefix mPrefixB;
};
TestCase kTestCases[] = {
@@ -735,16 +737,16 @@ void TestIp6PrefixTidy(void)
for (auto test : kPrefixes)
{
for (uint16_t i = 0; i < ot::GetArrayLength(test.prefixStringAfterTidy); i++)
for (uint16_t i = 0; i < GetArrayLength(test.prefixStringAfterTidy); i++)
{
ot::Ip6::Prefix prefix, answer;
Ip6::Prefix prefix, answer;
SuccessOrQuit(answer.FromString(test.prefixStringAfterTidy[i]));
prefix.Set(test.originalPrefix, i);
prefix.Tidy();
{
ot::Ip6::Prefix::InfoString prefixString = prefix.ToString();
Ip6::Prefix::InfoString prefixString = prefix.ToString();
printf("Prefix: %-36s TidyResult: %-36s\n", test.prefixStringAfterTidy[i],
prefix.ToString().AsCString());
@@ -781,7 +783,7 @@ void TestIp4Ip6Translation(void)
const uint8_t kIp4Address[] = {192, 0, 2, 33};
ot::Ip4::Address ip4Address;
Ip4::Address ip4Address;
printf("\nTestIp4Ip6Translation()\n");
@@ -789,9 +791,9 @@ void TestIp4Ip6Translation(void)
for (const TestCase &testCase : kTestCases)
{
ot::Ip6::Prefix prefix;
ot::Ip6::Address address;
ot::Ip6::Address expectedAddress;
Ip6::Prefix prefix;
Ip6::Address address;
Ip6::Address expectedAddress;
SuccessOrQuit(address.FromString(testCase.mPrefix));
prefix.Set(address.GetBytes(), testCase.mLength);
@@ -809,9 +811,9 @@ void TestIp4Ip6Translation(void)
for (const TestCase &testCase : kTestCases)
{
const ot::Ip4::Address expectedAddress = ip4Address;
ot::Ip4::Address address;
ot::Ip6::Address ip6Address;
const Ip4::Address expectedAddress = ip4Address;
Ip4::Address address;
Ip6::Address ip6Address;
SuccessOrQuit(ip6Address.FromString(testCase.mIp6Address));
@@ -826,7 +828,7 @@ void TestIp4Ip6Translation(void)
void TestIp4Cidr(void)
{
using ot::Encoding::BigEndian::HostSwap32;
using Encoding::BigEndian::HostSwap32;
struct TestCase
{
const char *mNetwork;
@@ -857,9 +859,9 @@ void TestIp4Cidr(void)
for (const TestCase &testCase : kTestCases)
{
ot::Ip4::Address network;
ot::Ip4::Cidr cidr;
ot::Ip4::Address generated;
Ip4::Address network;
Ip4::Cidr cidr;
Ip4::Address generated;
SuccessOrQuit(network.FromString(testCase.mNetwork));
cidr.mAddress = network;
@@ -875,17 +877,20 @@ void TestIp4Cidr(void)
}
}
} // namespace ot
int main(void)
{
TestIp6AddressSetPrefix();
TestIp4AddressFromString();
TestIp6AddressFromString();
TestIp6PrefixFromString();
TestIp6Prefix();
TestIp6PrefixTidy();
TestIp4Ip6Translation();
TestIp4Cidr();
TestIp4CidrFromString();
ot::TestIp6AddressSetPrefix();
ot::TestIp4AddressFromString();
ot::TestIp6AddressFromString();
ot::TestIp6PrefixFromString();
ot::TestIp6Prefix();
ot::TestIp6PrefixTidy();
ot::TestIp4Ip6Translation();
ot::TestIp4Cidr();
ot::TestIp4CidrFromString();
printf("All tests passed\n");
return 0;
}