/*
 *
 *    Copyright (c) 2015-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *    @file
 *     This file implements a unit test suite for <tt>nl::Inet::IPAddress</tt>,
 *     a class to store and format IPV4 and IPV6 Internet Protocol addresses.
 *
 */

#include <InetLayer/IPAddress.h>
#include "ToolCommon.h"

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
#include "lwip/init.h"
#include "lwip/ip_addr.h"
#else
#include <sys/socket.h>
#include <netinet/in.h>
#endif

#include <nltest.h>

#define LLA_PREFIX             0xfe800000
#define ULA_PREFIX             0xfd000000
#define MCAST_PREFIX           0xff000000
#define NUM_MCAST_SCOPES       7
#define NUM_MCAST_GROUPS       2
#define NUM_BYTES_IN_IPV6      16
#define ULA_UP_24_BIT_MASK     0xffffff0000
#define ULA_LO_16_BIT_MASK     0x000000ffff
#define NUM_FIELDS_IN_ADDR     sizeof(IPAddress)/sizeof(uint32_t)

using namespace nl::Inet;


// Test input vector format.


struct TestContext {
    uint32_t                   addr[4];
    const IPAddressType        ipAddrType;

    const char                 *ip;

    bool                       isIPv4;
    bool                       isMcast;
    bool                       isULA;
    bool                       isLLA;

    uint64_t                   global;
    uint16_t                   subnet;
    uint64_t                   interface;
};


// Test input data.


static struct TestContext sContext[] = {
    {
        { 0x26200000, 0x10e70400, 0xe83fb28f, 0x9c3a1941 }, kIPAddressType_IPv6,
        "2620:0:10e7:400:e83f:b28f:9c3a:1941",
        0, 0, 0, 0,
        0, 0, 0
    },
    {
        { 0xfe800000, 0x00000000, 0x8edcd4ff, 0xfe3aebfb }, kIPAddressType_IPv6,
        "fe80::8edc:d4ff:fe3a:ebfb",
        0, 0, 0, 1,
        0, 0, 0
    },
    {
        { 0xff010000, 0x00000000, 0x00000000, 0x00000001 }, kIPAddressType_IPv6,
        "ff01::1",
        0, 1, 0, 0,
        0, 0, 0
    },
    {
        { 0xfd000000, 0x00010001, 0x00000000, 0x00000001 }, kIPAddressType_IPv6,
        "fd00:0:1:1::1",
        0, 0, 1, 0,
        0x1, 1, 1
    },
    {
        { 0xfd123456, 0x0001abcd, 0xabcdef00, 0xfedcba09 }, kIPAddressType_IPv6,
        "fd12:3456:1:abcd:abcd:ef00:fedc:ba09",
        0, 0, 1, 0,
        0x1234560001, 0xabcd, 0xabcdef00fedcba09
    },
    {
        { 0xfdffffff, 0xffffffff, 0xffffffff, 0xffffffff }, kIPAddressType_IPv6,
        "fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
        0, 0, 1, 0,
        0xffffffffff, 0xffff, 0xffffffffffffffff
    },
#if INET_CONFIG_ENABLE_IPV4
    {
        { 0x00000000, 0x00000000, 0x0000ffff, 0xffffff00 }, kIPAddressType_IPv4,
        "255.255.255.0",
        1, 0, 0, 0,
        0, 0, 0
    },
    {
        { 0x00000000, 0x00000000, 0x0000ffff, 0x7f000001 }, kIPAddressType_IPv4,
        "127.0.0.1",
        1, 0, 0, 0,
        0, 0, 0
    },
#endif // INET_CONFIG_ENABLE_IPV4
    {
        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, kIPAddressType_Any,
        "::",
        0, 0, 0, 0,
        0, 0, 0
    }
};

static const size_t kTestElements = sizeof(sContext)/sizeof(struct TestContext);

// Utility functions.

/**
 *   Load input test directly into IPAddress.
 */
static void SetupIPAddress(IPAddress& addr, struct TestContext *inContext)
{
    for (size_t i = 0; i < NUM_FIELDS_IN_ADDR; i++)
    {
        addr.Addr[i] = htonl(inContext->addr[i]);
    }
}

/**
 *   Zero out IP address.
 */
static void ClearIPAddress(IPAddress& addr)
{
    for (size_t i = 0; i < NUM_FIELDS_IN_ADDR; i++)
    {
        addr.Addr[i] = 0;
    }
}


// Test functions invoked from the suite.


/**
 *  Test IP address conversion from a string.
 */
static void CheckFromString(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        IPAddress::FromString(theContext->ip, test_addr);

        NL_TEST_ASSERT(inSuite, test_addr.Addr[0] == htonl(theContext->addr[0]));
        NL_TEST_ASSERT(inSuite, test_addr.Addr[1] == htonl(theContext->addr[1]));
        NL_TEST_ASSERT(inSuite, test_addr.Addr[2] == htonl(theContext->addr[2]));
        NL_TEST_ASSERT(inSuite, test_addr.Addr[3] == htonl(theContext->addr[3]));

        theContext++;
    }
}

/**
 *  Test correct identification of IPv6 ULA addresses.
 */
static void CheckIsIPv6ULA(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

        NL_TEST_ASSERT(inSuite, test_addr.IsIPv6ULA() == theContext->isULA);

        theContext++;
    }
}

/**
 *  Test correct identification of IPv6 Link Local addresses.
 */
static void CheckIsIPv6LLA(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

        NL_TEST_ASSERT(inSuite, test_addr.IsIPv6LinkLocal() == theContext->isLLA);

        theContext++;
    }
}

/**
 *  Test correct identification of IPv6 multicast addresses.
 */
static void CheckIsMulticast(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

        NL_TEST_ASSERT(inSuite, test_addr.IsMulticast() == theContext->isMcast);

        theContext++;
    }
}

/**
 *  Test IPAddress equal operator.
 */
static void CheckOperatorEqual(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theFirstContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr_1;
        struct TestContext *theSecondContext = static_cast<struct TestContext *>(inContext);

        SetupIPAddress(test_addr_1, theFirstContext);

        for (size_t jth = 0; jth < kTestElements; jth++)
        {
            IPAddress test_addr_2;

            SetupIPAddress(test_addr_2, theSecondContext);

            if (theFirstContext == theSecondContext)
            {
                NL_TEST_ASSERT(inSuite, test_addr_1 == test_addr_2);
            }
            else
            {
                NL_TEST_ASSERT(inSuite, !(test_addr_1 == test_addr_2));
            }
            theSecondContext++;
        }
        theFirstContext++;
    }
}

/**
 *  Test IPAddress not-equal operator.
 */
static void CheckOperatorNotEqual(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theFirstContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr_1;
        struct TestContext *theSecondContext = static_cast<struct TestContext *>(inContext);

        SetupIPAddress(test_addr_1, theFirstContext);

        for (size_t jth = 0; jth < kTestElements; jth++)
        {
            IPAddress test_addr_2;

            SetupIPAddress(test_addr_2, theSecondContext);

            if (theFirstContext == theSecondContext)
            {
                NL_TEST_ASSERT(inSuite, !(test_addr_1 != test_addr_2));
            }
            else
            {
                NL_TEST_ASSERT(inSuite, test_addr_1 != test_addr_2);
            }
            theSecondContext++;
        }
        theFirstContext++;
    }
}

/**
 *  Test IPAddress assign operator.
 */
static void CheckOperatorAssign(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theFirstContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        struct TestContext *theSecondContext = static_cast<struct TestContext *>(inContext);

        for (size_t jth = 0; jth < kTestElements; jth++)
        {
            IPAddress test_addr_1, test_addr_2;

            ClearIPAddress(test_addr_1);
            SetupIPAddress(test_addr_2, theSecondContext);

            // Use operator to assign IPAddress from test_addr_2 to test_addr_1
            test_addr_1 = test_addr_2;

            NL_TEST_ASSERT(inSuite, test_addr_1.Addr[0] == test_addr_2.Addr[0]);
            NL_TEST_ASSERT(inSuite, test_addr_1.Addr[1] == test_addr_2.Addr[1]);
            NL_TEST_ASSERT(inSuite, test_addr_1.Addr[2] == test_addr_2.Addr[2]);
            NL_TEST_ASSERT(inSuite, test_addr_1.Addr[3] == test_addr_2.Addr[3]);

            theSecondContext++;
        }
        theFirstContext++;
    }
}

/**
 *   Test IPAddress v6 conversion to native representation.
 */
static void CheckToIPv6(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;
        uint32_t addr[4];

        addr[0] = htonl(theContext->addr[0]);
        addr[1] = htonl(theContext->addr[1]);
        addr[2] = htonl(theContext->addr[2]);
        addr[3] = htonl(theContext->addr[3]);

        SetupIPAddress(test_addr, theContext);

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
        ip6_addr_t ip_addr_1, ip_addr_2;
        ip_addr_1 = *(ip6_addr_t *)addr;
#else
        struct in6_addr ip_addr_1, ip_addr_2;
        ip_addr_1 = *(struct in6_addr *)addr;
#endif
        ip_addr_2 = test_addr.ToIPv6();

        NL_TEST_ASSERT(inSuite, !memcmp(&ip_addr_1, &ip_addr_2, sizeof(ip_addr_1)));

        theContext++;
    }
}

/**
 *   Test native IPv6 conversion into IPAddress.
 */
static void CheckFromIPv6(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr_1, test_addr_2;
        uint32_t addr[4];

        addr[0] = htonl(theContext->addr[0]);
        addr[1] = htonl(theContext->addr[1]);
        addr[2] = htonl(theContext->addr[2]);
        addr[3] = htonl(theContext->addr[3]);

        SetupIPAddress(test_addr_1, theContext);
        ClearIPAddress(test_addr_2);

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
        ip6_addr_t ip_addr;
        ip_addr = *(ip6_addr_t *)addr;
#else
        struct in6_addr ip_addr;
        ip_addr = *(struct in6_addr *)addr;
#endif
        test_addr_2 = IPAddress::FromIPv6(ip_addr);

        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[0] == test_addr_2.Addr[0]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[1] == test_addr_2.Addr[1]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[2] == test_addr_2.Addr[2]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[3] == test_addr_2.Addr[3]);

        theContext++;
    }
}

#if INET_CONFIG_ENABLE_IPV4
/**
 *  Test correct identification of IPv4 addresses.
 */
static void CheckIsIPv4(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

        NL_TEST_ASSERT(inSuite, test_addr.IsIPv4() == theContext->isIPv4);

        theContext++;
    }
}

/**
 *   Test IPAddress v4 conversion to native representation.
 */
static void CheckToIPv4(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
        ip4_addr_t ip_addr_1, ip_addr_2;

        ip_addr_1.addr = lwip_htonl(theContext->addr[3]);
#else
        struct in_addr ip_addr_1, ip_addr_2;

        ip_addr_1.s_addr = htonl(theContext->addr[3]);
#endif
        ip_addr_2 = test_addr.ToIPv4();

        NL_TEST_ASSERT(inSuite, !memcmp(&ip_addr_1, &ip_addr_2, sizeof(ip_addr_1)));

        theContext++;
    }
}

/**
 *   Test native IPv4 conversion into IPAddress.
 */
static void CheckFromIPv4(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr_1, test_addr_2;

        SetupIPAddress(test_addr_1, theContext);
        // Convert to IPv4 (test_addr_1);
        test_addr_1.Addr[0] = 0;
        test_addr_1.Addr[1] = 0;
        test_addr_1.Addr[2] = htonl(0xffff);
        ClearIPAddress(test_addr_2);

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
        ip4_addr_t ip_addr;
        ip_addr.addr = lwip_htonl(theContext->addr[3]);
#else
        struct in_addr ip_addr;
        ip_addr.s_addr = htonl(theContext->addr[3]);
#endif
        test_addr_2 = IPAddress::FromIPv4(ip_addr);

        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[0] == test_addr_2.Addr[0]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[1] == test_addr_2.Addr[1]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[2] == test_addr_2.Addr[2]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[3] == test_addr_2.Addr[3]);

        theContext++;
    }
}
#endif // INET_CONFIG_ENABLE_IPV4

/**
 *   Test IPAddress address conversion from socket.
 */
static void CheckFromSocket(nlTestSuite *inSuite, void *inContext)
{
#if WEAVE_SYSTEM_CONFIG_USE_LWIP
    (void)inSuite;
    // This test is only supported for non LWIP stack.
#else // INET_LWIP
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr_1, test_addr_2;
        uint32_t addr[4];
        struct sockaddr_in6 sock_v6;
#if INET_CONFIG_ENABLE_IPV4
        struct sockaddr_in sock_v4;
#endif // INET_CONFIG_ENABLE_IPV4

        addr[0] = htonl(theContext->addr[0]);
        addr[1] = htonl(theContext->addr[1]);
        addr[2] = htonl(theContext->addr[2]);
        addr[3] = htonl(theContext->addr[3]);

        SetupIPAddress(test_addr_1, theContext);
        ClearIPAddress(test_addr_2);

        switch (theContext->ipAddrType)
        {
#if INET_CONFIG_ENABLE_IPV4
        case kIPAddressType_IPv4:
            memset(&sock_v4, 0, sizeof(struct sockaddr_in));
            sock_v4.sin_family = AF_INET;
            memcpy(&sock_v4.sin_addr.s_addr, &addr[3], sizeof(struct in_addr));
            test_addr_2 = IPAddress::FromSockAddr((struct sockaddr &)sock_v4);
            break;
#endif // INET_CONFIG_ENABLE_IPV4

        case kIPAddressType_IPv6:
            memset(&sock_v6, 0, sizeof(struct sockaddr_in6));
            sock_v6.sin6_family = AF_INET6;
            memcpy(&sock_v6.sin6_addr.s6_addr, addr, sizeof(struct in6_addr));
            test_addr_2 = IPAddress::FromSockAddr((struct sockaddr &)sock_v6);
            break;

        case kIPAddressType_Any:
            memset(&sock_v6, 0, sizeof(struct sockaddr_in6));
            sock_v6.sin6_family = 0;
            memcpy(&sock_v6.sin6_addr.s6_addr, addr, sizeof(struct in6_addr));
            test_addr_2 = IPAddress::FromSockAddr((struct sockaddr &)sock_v6);
            break;

        default:
            continue;
        }

        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[0] == test_addr_2.Addr[0]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[1] == test_addr_2.Addr[1]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[2] == test_addr_2.Addr[2]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[3] == test_addr_2.Addr[3]);

        theContext++;
    }
#endif // INET_LWIP
}

/**
 *  Test IP address type.
 */
static void CheckType(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

        NL_TEST_ASSERT(inSuite, test_addr.Type() == theContext->ipAddrType);

        theContext++;
    }
}

/**
 *  Test IP address interface ID.
 */
static void CheckInterface(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

        NL_TEST_ASSERT(inSuite, test_addr.InterfaceId() == theContext->interface);

        theContext++;
    }
}

/**
 *  Test IP address subnet.
 */
static void CheckSubnet(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

        NL_TEST_ASSERT(inSuite, test_addr.Subnet() == theContext->subnet);

        theContext++;
    }
}

/**
 *  Test IP address global ID.
 */
static void CheckGlobal(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        SetupIPAddress(test_addr, theContext);

        NL_TEST_ASSERT(inSuite, test_addr.GlobalId() == theContext->global);

        theContext++;
    }
}

/**
 *  Test address encoding with Weave::Encoding.
 */
static void CheckEncoding(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;
        uint8_t *p;
        uint8_t buffer[NUM_BYTES_IN_IPV6];

        SetupIPAddress(test_addr, theContext);
        memset(&buffer, 0, NUM_BYTES_IN_IPV6);
        p = buffer;

        // Call EncodeAddress function that we test.
        test_addr.WriteAddress(p);

        // buffer has address in network byte order
        NL_TEST_ASSERT(inSuite, buffer[3] == (uint8_t)(theContext->addr[0]));
        NL_TEST_ASSERT(inSuite, buffer[2] == (uint8_t)(theContext->addr[0] >> 8));
        NL_TEST_ASSERT(inSuite, buffer[1] == (uint8_t)(theContext->addr[0] >> 16));
        NL_TEST_ASSERT(inSuite, buffer[0] == (uint8_t)(theContext->addr[0] >> 24));

        NL_TEST_ASSERT(inSuite, buffer[7] == (uint8_t)(theContext->addr[1]));
        NL_TEST_ASSERT(inSuite, buffer[6] == (uint8_t)(theContext->addr[1] >> 8));
        NL_TEST_ASSERT(inSuite, buffer[5] == (uint8_t)(theContext->addr[1] >> 16));
        NL_TEST_ASSERT(inSuite, buffer[4] == (uint8_t)(theContext->addr[1] >> 24));

        NL_TEST_ASSERT(inSuite, buffer[11] == (uint8_t)(theContext->addr[2]));
        NL_TEST_ASSERT(inSuite, buffer[10] == (uint8_t)(theContext->addr[2] >> 8));
        NL_TEST_ASSERT(inSuite, buffer[9] == (uint8_t)(theContext->addr[2] >> 16));
        NL_TEST_ASSERT(inSuite, buffer[8] == (uint8_t)(theContext->addr[2] >> 24));

        NL_TEST_ASSERT(inSuite, buffer[15] == (uint8_t)(theContext->addr[3]));
        NL_TEST_ASSERT(inSuite, buffer[14] == (uint8_t)(theContext->addr[3] >> 8));
        NL_TEST_ASSERT(inSuite, buffer[13] == (uint8_t)(theContext->addr[3] >> 16));
        NL_TEST_ASSERT(inSuite, buffer[12] == (uint8_t)(theContext->addr[3] >> 24));

        theContext++;
    }
}

/**
 *  Test address decoding with Weave::Decoding.
 */
static void CheckDecoding(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr_1, test_addr_2;
        uint8_t buffer[NUM_BYTES_IN_IPV6];
        uint8_t *p;
        uint8_t b;

        SetupIPAddress(test_addr_1, theContext);
        ClearIPAddress(test_addr_2);
        memset(&buffer, 0, NUM_BYTES_IN_IPV6);
        p = buffer;

        for (b = 0; b < NUM_BYTES_IN_IPV6; b++)
        {
            buffer[b] = (uint8_t)(theContext->addr[b / 4] >> ((3 - b % 4) * 8));
        }

        // Call ReadAddress function that we test.
        IPAddress::ReadAddress(p, test_addr_2);

        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[0] == test_addr_2.Addr[0]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[1] == test_addr_2.Addr[1]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[2] == test_addr_2.Addr[2]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[3] == test_addr_2.Addr[3]);

        theContext++;
    }
}

/**
 *  Test address symmetricity of encoding and decoding with Weave::(De/En)code.
 */
static void CheckEcodeDecodeSymmetricity(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr_1, test_addr_2;
        uint8_t buffer[NUM_BYTES_IN_IPV6];
        uint8_t *p;

        SetupIPAddress(test_addr_1, theContext);
        ClearIPAddress(test_addr_2);
        memset(&buffer, 0, NUM_BYTES_IN_IPV6);

        p = buffer;

        // Call EncodeAddress function that we test.
        test_addr_1.WriteAddress(p);

        // Move pointer back to the beginning of the buffer.
        p = buffer;

        // Call ReadAddress function that we test.
        IPAddress::ReadAddress(p, test_addr_2);

        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[0] == test_addr_2.Addr[0]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[1] == test_addr_2.Addr[1]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[2] == test_addr_2.Addr[2]);
        NL_TEST_ASSERT(inSuite, test_addr_1.Addr[3] == test_addr_2.Addr[3]);

        theContext++;
    }
}

/**
 *  Test assembling ULA address.
 */
static void CheckMakeULA(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        // Call MakeULA function that we test.
        test_addr = IPAddress::MakeULA(theContext->global, theContext->subnet,
            theContext->interface);

        NL_TEST_ASSERT(inSuite, test_addr.Addr[0] ==
                htonl(ULA_PREFIX | (theContext->global & ULA_UP_24_BIT_MASK) >> 16));
        NL_TEST_ASSERT(inSuite,    test_addr.Addr[1] ==
                htonl((theContext->global & ULA_LO_16_BIT_MASK) << 16 | theContext->subnet));
        NL_TEST_ASSERT(inSuite,    test_addr.Addr[2] == htonl(theContext->interface >> 32));
        NL_TEST_ASSERT(inSuite,    test_addr.Addr[3] == htonl(theContext->interface));

        theContext++;
    }
}

/**
 *  Test assembling LLA address.
 */
static void CheckMakeLLA(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPAddress test_addr;

        // Call MakeLLA function that we test.
        test_addr = IPAddress::MakeLLA(theContext->interface);

        NL_TEST_ASSERT(inSuite, test_addr.Addr[0] == htonl(LLA_PREFIX));
        NL_TEST_ASSERT(inSuite, test_addr.Addr[1] == 0);
        NL_TEST_ASSERT(inSuite, test_addr.Addr[2] == htonl(theContext->interface >> 32));
        NL_TEST_ASSERT(inSuite, test_addr.Addr[3] == htonl(theContext->interface));

        theContext++;
    }
}

/**
 *  Test assembling IPv6 Multicast address.
 */
static void CheckMakeIPv6Multicast(nlTestSuite *inSuite, void *inContext)
{
    int s, g;

    IPv6MulticastScope scope[NUM_MCAST_SCOPES] =
    {
        kIPv6MulticastScope_Interface,
        kIPv6MulticastScope_Link,
#if INET_CONFIG_ENABLE_IPV4
        kIPv6MulticastScope_IPv4,
#endif // INET_CONFIG_ENABLE_IPV4
        kIPv6MulticastScope_Admin,
        kIPv6MulticastScope_Site,
        kIPv6MulticastScope_Organization,
        kIPv6MulticastScope_Global
    };

    IPV6MulticastGroup group[NUM_MCAST_GROUPS] =
    {
        kIPV6MulticastGroup_AllNodes,
        kIPV6MulticastGroup_AllRouters
    };

    for (s = 0; s < NUM_MCAST_SCOPES; s++)
    {
        for (g = 0; g < NUM_MCAST_GROUPS; g++)
        {
            IPAddress test_addr;

            // Call MakeIPv6Multicast function that we test.
            test_addr = IPAddress::MakeIPv6Multicast(scope[s], group[g]);

            NL_TEST_ASSERT(inSuite, test_addr.Addr[0] == htonl(MCAST_PREFIX | (scope[s] << 16)));
            NL_TEST_ASSERT(inSuite, test_addr.Addr[1] == 0);
            NL_TEST_ASSERT(inSuite, test_addr.Addr[2] == 0);
            NL_TEST_ASSERT(inSuite, test_addr.Addr[3] == htonl(group[g]));
        }
    }
}

/**
 *  Test IPPrefix.
 */
static void CheckIPPrefix(nlTestSuite *inSuite, void *inContext)
{
    struct TestContext *theFirstContext = static_cast<struct TestContext *>(inContext);

    for (size_t ith = 0; ith < kTestElements; ith++)
    {
        IPPrefix ipprefix_1, ipprefix_2;
        IPAddress test_addr_1;

        SetupIPAddress(test_addr_1, theFirstContext);
        ipprefix_1.IPAddr = test_addr_1;
        ipprefix_1.Length = 128 - ith;
        ipprefix_2 = ipprefix_1;

        NL_TEST_ASSERT(inSuite, !ipprefix_1.IsZero());
        NL_TEST_ASSERT(inSuite, !ipprefix_2.IsZero());
        NL_TEST_ASSERT(inSuite, ipprefix_1 == ipprefix_2);
        NL_TEST_ASSERT(inSuite, !(ipprefix_1 != ipprefix_2));
#if !WEAVE_SYSTEM_CONFIG_USE_LWIP
        NL_TEST_ASSERT(inSuite, ipprefix_1.MatchAddress(test_addr_1));
#endif
        theFirstContext++;
    }
}
// Test Suite


/**
 *   Test Suite. It lists all the test functions.
 */
static const nlTest sTests[] = {
    NL_TEST_DEF("From String Conversion",               CheckFromString),
#if INET_CONFIG_ENABLE_IPV4
    NL_TEST_DEF("IPv4 Detection",                       CheckIsIPv4),
    NL_TEST_DEF("Convert IPv4 to IPAddress",            CheckFromIPv4),
    NL_TEST_DEF("Convert IPAddress to IPv4",            CheckToIPv4),
#endif // INET_CONFIG_ENABLE_IPV4
    NL_TEST_DEF("IPv6 ULA Detection",                   CheckIsIPv6ULA),
    NL_TEST_DEF("IPv6 Link Local Detection",            CheckIsIPv6LLA),
    NL_TEST_DEF("IPv6 Multicast Detection",             CheckIsMulticast),
    NL_TEST_DEF("Equivalence Operator",                 CheckOperatorEqual),
    NL_TEST_DEF("Non-Equivalence Operator",             CheckOperatorNotEqual),
    NL_TEST_DEF("Assign Operator",                      CheckOperatorAssign),
    NL_TEST_DEF("Convert IPv6 to IPAddress",            CheckFromIPv6),
    NL_TEST_DEF("Convert IPAddress to IPv6",            CheckToIPv6),
    NL_TEST_DEF("Assign address from socket",           CheckFromSocket),
    NL_TEST_DEF("Address Type",                         CheckType),
    NL_TEST_DEF("Address Interface ID",                 CheckInterface),
    NL_TEST_DEF("Address Subnet",                       CheckSubnet),
    NL_TEST_DEF("Address Global ID",                    CheckGlobal),
    NL_TEST_DEF("Assemble IPv6 ULA address",            CheckMakeULA),
    NL_TEST_DEF("Assemble IPv6 LLA address",            CheckMakeLLA),
    NL_TEST_DEF("Assemble IPv6 Multicast address",      CheckMakeIPv6Multicast),
    NL_TEST_DEF("Weave Encoding",                       CheckEncoding),
    NL_TEST_DEF("Weave Decoding",                       CheckDecoding),
    NL_TEST_DEF("Weave Encode / Decode Symmetricity",   CheckEcodeDecodeSymmetricity),
    NL_TEST_DEF("IPPrefix test",                        CheckIPPrefix),
    NL_TEST_SENTINEL()
};

/**
 *  Set up the test suite.
 */
static int TestSetup(void *inContext)
{
    return (SUCCESS);
}

/**
 *  Tear down the test suite.
 */
static int TestTeardown(void *inContext)
{
    return (SUCCESS);
}

int main(void)
{
    nlTestSuite theSuite = {
        "inet-address",
        &sTests[0],
        TestSetup,
        TestTeardown
    };

    // Generate machine-readable, comma-separated value (CSV) output.
    nl_test_set_output_style(OUTPUT_CSV);

    // Run test suit againt one context.
    nlTestRunner(&theSuite, &sContext);

    return nlTestRunnerStats(&theSuite);
}