tests/unit/test_child.cpp - third_party/openthread - Git at Google

 /*
  *  Copyright (c) 2018, 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_platform.h"

 #include <openthread/config.h>

 #include "test_util.h"
 #include "common/code_utils.hpp"
 #include "common/instance.hpp"
 #include "thread/child.hpp"

 namespace ot {

 static ot::Instance *sInstance;

 enum
 {
     kMaxChildIp6Addresses = OPENTHREAD_CONFIG_MLE_IP_ADDRS_PER_CHILD,
 };

 void VerifyChildIp6Addresses(const Child &aChild, uint8_t aAddressListLength, const Ip6::Address aAddressList[])
 {
     Ip6::Address::TypeFilter filters[] = {Ip6::Address::kTypeUnicast, Ip6::Address::kTypeMulticast};
     bool                     addressObserved[kMaxChildIp6Addresses];
     bool                     hasMeshLocal = false;

     for (uint8_t index = 0; index < aAddressListLength; index++)
     {
         VerifyOrQuit(aChild.HasIp6Address(aAddressList[index]));
     }

     memset(addressObserved, 0, sizeof(addressObserved));

     for (const Ip6::Address &address : aChild.IterateIp6Addresses())
     {
         bool addressIsInList = false;

         for (uint8_t index = 0; index < aAddressListLength; index++)
         {
             if (address == aAddressList[index])
             {
                 addressIsInList        = true;
                 addressObserved[index] = true;
                 break;
             }
         }

         VerifyOrQuit(addressIsInList, "Child::IterateIp6Addresses() returned an address not in the expected list");
     }

     for (uint8_t index = 0; index < aAddressListLength; index++)
     {
         Ip6::Address address;

         VerifyOrQuit(addressObserved[index], "Child::IterateIp6Addresses() missed an entry from the expected list");

         if (sInstance->Get<Mle::MleRouter>().IsMeshLocalAddress(aAddressList[index]))
         {
             SuccessOrQuit(aChild.GetMeshLocalIp6Address(address));
             VerifyOrQuit(address == aAddressList[index], "GetMeshLocalIp6Address() did not return expected address");
             hasMeshLocal = true;
         }
     }

     if (!hasMeshLocal)
     {
         Ip6::Address address;

         VerifyOrQuit(aChild.GetMeshLocalIp6Address(address) == kErrorNotFound,
                      "Child::GetMeshLocalIp6Address() returned an address not in the expected list");
     }

     // Iterate over unicast and multicast addresses separately.

     memset(addressObserved, 0, sizeof(addressObserved));

     for (Ip6::Address::TypeFilter filter : filters)
     {
         for (const Ip6::Address &address : aChild.IterateIp6Addresses(filter))
         {
             bool addressIsInList = false;

             switch (filter)
             {
             case Ip6::Address::kTypeMulticast:
                 VerifyOrQuit(address.IsMulticast(), "Address::TypeFilter failed");
                 break;

             case Ip6::Address::kTypeUnicast:
                 VerifyOrQuit(!address.IsMulticast(), "Address::TypeFilter failed");
                 break;

             default:
                 break;
             }

             VerifyOrQuit(address.MatchesFilter(filter));

             for (uint8_t index = 0; index < aAddressListLength; index++)
             {
                 if (address == aAddressList[index])
                 {
                     VerifyOrQuit(addressObserved[index] == false,
                                  "Child::IterateIp6Addresses() returned duplicate addr");
                     addressObserved[index] = true;
                     addressIsInList        = true;
                     break;
                 }
             }

             VerifyOrQuit(addressIsInList, "Child::IterateIp6Addresses() returned an address not in the expected list");
         }
     }

     for (uint8_t index = 0; index < aAddressListLength; index++)
     {
         VerifyOrQuit(addressObserved[index], "Child::IterateIp6Addresses() missed an entry from the expected list");
     }

     // Verify behavior of `Child::AddressIterator
     {
         Child::AddressIterator        iter1(aChild);
         Child::AddressIterator        iter2(aChild);
         Child::AddressIterator::Index iterIndex;

         for (const Ip6::Address &address : aChild.IterateIp6Addresses())
         {
             VerifyOrQuit(iter1 == iter2);
             VerifyOrQuit(!iter1.IsDone());
             VerifyOrQuit(*iter1.GetAddress() == address);
             VerifyOrQuit(*iter1.GetAddress() == *iter2.GetAddress());

             iterIndex = iter1.GetAsIndex();
             VerifyOrQuit(iter2.GetAsIndex() == iterIndex);

             {
                 Child::AddressIterator iter3(aChild, iterIndex);
                 VerifyOrQuit(iter3 == iter1, "AddressIterator(iterIndex) failed");

                 iter3++;
                 VerifyOrQuit(iter3 != iter1, "AddressIterator(iterIndex) failed");
             }

             iter1++;
             VerifyOrQuit(iter1 != iter2);
             iter2++;
         }

         VerifyOrQuit(iter1.IsDone());
         VerifyOrQuit(iter2.IsDone());
         VerifyOrQuit(iter1 == iter2);

         iterIndex = iter1.GetAsIndex();
         VerifyOrQuit(iter2.GetAsIndex() == iterIndex);

         {
             Child::AddressIterator iter3(aChild, iterIndex);
             VerifyOrQuit(iter3 == iter1, "AddressIterator(iterIndex) failed");
         }
     }
 }

 void TestChildIp6Address(void)
 {
     Child        child;
     Ip6::Address addresses[kMaxChildIp6Addresses];
     uint8_t      numAddresses;
     const char  *ip6Addresses[] = {
          "fd00:1234::1234",
          "ff6b:e251:52fb:0:12e6:b94c:1c28:c56a",
          "fd00:1234::204c:3d7c:98f6:9a1b",
     };

     const uint8_t            meshLocalIidArray[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
     Ip6::InterfaceIdentifier meshLocalIid;

     meshLocalIid.SetBytes(meshLocalIidArray);

     sInstance = testInitInstance();
     VerifyOrQuit(sInstance != nullptr);

     child.Init(*sInstance);

     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

     printf("\nConverting IPv6 addresses from string");

     numAddresses = 0;

     // First addresses uses the mesh local prefix (mesh-local address).
     addresses[numAddresses] = sInstance->Get<Mle::MleRouter>().GetMeshLocal64();
     addresses[numAddresses].SetIid(meshLocalIid);

     numAddresses++;

     for (const char *ip6Address : ip6Addresses)
     {
         VerifyOrQuit(numAddresses < kMaxChildIp6Addresses, "Too many IPv6 addresses in the unit test");
         SuccessOrQuit(addresses[numAddresses++].FromString(ip6Address));
     }

     printf(" -- PASS\n");

     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     printf("Child state after init");
     child.Clear();
     VerifyChildIp6Addresses(child, 0, nullptr);
     printf(" -- PASS\n");

     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     printf("Adding a single IPv6 address");

     for (uint8_t index = 0; index < numAddresses; index++)
     {
         SuccessOrQuit(child.AddIp6Address(addresses[index]));
         VerifyChildIp6Addresses(child, 1, &addresses[index]);

         child.ClearIp6Addresses();
         VerifyChildIp6Addresses(child, 0, nullptr);
     }

     printf(" -- PASS\n");

     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     printf("Adding multiple IPv6 addresses");

     for (uint8_t index = 0; index < numAddresses; index++)
     {
         SuccessOrQuit(child.AddIp6Address(addresses[index]));
         VerifyChildIp6Addresses(child, index + 1, addresses);
     }

     printf(" -- PASS\n");

     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     printf("Checking for failure when adding an address already in list");

     for (uint8_t index = 0; index < numAddresses; index++)
     {
         VerifyOrQuit(child.AddIp6Address(addresses[index]) == kErrorAlready,
                      "AddIp6Address() did not fail when adding same address");
         VerifyChildIp6Addresses(child, numAddresses, addresses);
     }

     printf(" -- PASS\n");

     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     printf("Removing addresses from list starting from front of the list");

     for (uint8_t index = 0; index < numAddresses; index++)
     {
         SuccessOrQuit(child.RemoveIp6Address(addresses[index]));
         VerifyChildIp6Addresses(child, numAddresses - 1 - index, &addresses[index + 1]);

         VerifyOrQuit(child.RemoveIp6Address(addresses[index]) == kErrorNotFound,
                      "RemoveIp6Address() did not fail when removing an address not on the list");
     }

     VerifyChildIp6Addresses(child, 0, nullptr);
     printf(" -- PASS\n");

     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     printf("Removing addresses from list starting from back of the list");

     for (uint8_t index = 0; index < numAddresses; index++)
     {
         SuccessOrQuit(child.AddIp6Address(addresses[index]));
     }

     for (uint8_t index = numAddresses - 1; index > 0; index--)
     {
         SuccessOrQuit(child.RemoveIp6Address(addresses[index]));
         VerifyChildIp6Addresses(child, index, &addresses[0]);

         VerifyOrQuit(child.RemoveIp6Address(addresses[index]) == kErrorNotFound,
                      "RemoveIp6Address() did not fail when removing an address not on the list");
     }

     printf(" -- PASS\n");

     //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     printf("Removing address entries from middle of the list");

     for (uint8_t indexToRemove = 1; indexToRemove < numAddresses - 1; indexToRemove++)
     {
         child.ClearIp6Addresses();

         for (uint8_t index = 0; index < numAddresses; index++)
         {
             SuccessOrQuit(child.AddIp6Address(addresses[index]));
         }

         SuccessOrQuit(child.RemoveIp6Address(addresses[indexToRemove]));

         VerifyOrQuit(child.RemoveIp6Address(addresses[indexToRemove]) == kErrorNotFound,
                      "RemoveIp6Address() did not fail when removing an address not on the list");

         {
             Ip6::Address updatedAddressList[kMaxChildIp6Addresses];
             uint8_t      updatedListIndex = 0;

             for (uint8_t index = 0; index < numAddresses; index++)
             {
                 if (index != indexToRemove)
                 {
                     updatedAddressList[updatedListIndex++] = addresses[index];
                 }
             }

             VerifyChildIp6Addresses(child, updatedListIndex, updatedAddressList);
         }
     }

     printf(" -- PASS\n");

     testFreeInstance(sInstance);
 }

 } // namespace ot

 int main(void)
 {
     ot::TestChildIp6Address();
     printf("\nAll tests passed.\n");
     return 0;
 }
	/*
	* Copyright (c) 2018, 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_platform.h"

	#include <openthread/config.h>

	#include "test_util.h"
	#include "common/code_utils.hpp"
	#include "common/instance.hpp"
	#include "thread/child.hpp"

	namespace ot {

	static ot::Instance *sInstance;

	enum
	{
	kMaxChildIp6Addresses = OPENTHREAD_CONFIG_MLE_IP_ADDRS_PER_CHILD,
	};

	void VerifyChildIp6Addresses(const Child &aChild, uint8_t aAddressListLength, const Ip6::Address aAddressList[])
	{
	Ip6::Address::TypeFilter filters[] = {Ip6::Address::kTypeUnicast, Ip6::Address::kTypeMulticast};
	bool addressObserved[kMaxChildIp6Addresses];
	bool hasMeshLocal = false;

	for (uint8_t index = 0; index < aAddressListLength; index++)
	{
	VerifyOrQuit(aChild.HasIp6Address(aAddressList[index]));
	}

	memset(addressObserved, 0, sizeof(addressObserved));

	for (const Ip6::Address &address : aChild.IterateIp6Addresses())
	{
	bool addressIsInList = false;

	for (uint8_t index = 0; index < aAddressListLength; index++)
	{
	if (address == aAddressList[index])
	{
	addressIsInList = true;
	addressObserved[index] = true;
	break;
	}
	}

	VerifyOrQuit(addressIsInList, "Child::IterateIp6Addresses() returned an address not in the expected list");
	}

	for (uint8_t index = 0; index < aAddressListLength; index++)
	{
	Ip6::Address address;

	VerifyOrQuit(addressObserved[index], "Child::IterateIp6Addresses() missed an entry from the expected list");

	if (sInstance->Get<Mle::MleRouter>().IsMeshLocalAddress(aAddressList[index]))
	{
	SuccessOrQuit(aChild.GetMeshLocalIp6Address(address));
	VerifyOrQuit(address == aAddressList[index], "GetMeshLocalIp6Address() did not return expected address");
	hasMeshLocal = true;
	}
	}

	if (!hasMeshLocal)
	{
	Ip6::Address address;

	VerifyOrQuit(aChild.GetMeshLocalIp6Address(address) == kErrorNotFound,
	"Child::GetMeshLocalIp6Address() returned an address not in the expected list");
	}

	// Iterate over unicast and multicast addresses separately.

	memset(addressObserved, 0, sizeof(addressObserved));

	for (Ip6::Address::TypeFilter filter : filters)
	{
	for (const Ip6::Address &address : aChild.IterateIp6Addresses(filter))
	{
	bool addressIsInList = false;

	switch (filter)
	{
	case Ip6::Address::kTypeMulticast:
	VerifyOrQuit(address.IsMulticast(), "Address::TypeFilter failed");
	break;

	case Ip6::Address::kTypeUnicast:
	VerifyOrQuit(!address.IsMulticast(), "Address::TypeFilter failed");
	break;

	default:
	break;
	}

	VerifyOrQuit(address.MatchesFilter(filter));

	for (uint8_t index = 0; index < aAddressListLength; index++)
	{
	if (address == aAddressList[index])
	{
	VerifyOrQuit(addressObserved[index] == false,
	"Child::IterateIp6Addresses() returned duplicate addr");
	addressObserved[index] = true;
	addressIsInList = true;
	break;
	}
	}

	VerifyOrQuit(addressIsInList, "Child::IterateIp6Addresses() returned an address not in the expected list");
	}
	}

	for (uint8_t index = 0; index < aAddressListLength; index++)
	{
	VerifyOrQuit(addressObserved[index], "Child::IterateIp6Addresses() missed an entry from the expected list");
	}

	// Verify behavior of `Child::AddressIterator
	{
	Child::AddressIterator iter1(aChild);
	Child::AddressIterator iter2(aChild);
	Child::AddressIterator::Index iterIndex;

	for (const Ip6::Address &address : aChild.IterateIp6Addresses())
	{
	VerifyOrQuit(iter1 == iter2);
	VerifyOrQuit(!iter1.IsDone());
	VerifyOrQuit(*iter1.GetAddress() == address);
	VerifyOrQuit(iter1.GetAddress() == iter2.GetAddress());

	iterIndex = iter1.GetAsIndex();
	VerifyOrQuit(iter2.GetAsIndex() == iterIndex);

	{
	Child::AddressIterator iter3(aChild, iterIndex);
	VerifyOrQuit(iter3 == iter1, "AddressIterator(iterIndex) failed");

	iter3++;
	VerifyOrQuit(iter3 != iter1, "AddressIterator(iterIndex) failed");
	}

	iter1++;
	VerifyOrQuit(iter1 != iter2);
	iter2++;
	}

	VerifyOrQuit(iter1.IsDone());
	VerifyOrQuit(iter2.IsDone());
	VerifyOrQuit(iter1 == iter2);

	iterIndex = iter1.GetAsIndex();
	VerifyOrQuit(iter2.GetAsIndex() == iterIndex);

	{
	Child::AddressIterator iter3(aChild, iterIndex);
	VerifyOrQuit(iter3 == iter1, "AddressIterator(iterIndex) failed");
	}
	}
	}

	void TestChildIp6Address(void)
	{
	Child child;
	Ip6::Address addresses[kMaxChildIp6Addresses];
	uint8_t numAddresses;
	const char *ip6Addresses[] = {
	"fd00:1234::1234",
	"ff6b:e251:52fb:0:12e6:b94c:1c28:c56a",
	"fd00:1234::204c:3d7c:98f6:9a1b",
	};

	const uint8_t meshLocalIidArray[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
	Ip6::InterfaceIdentifier meshLocalIid;

	meshLocalIid.SetBytes(meshLocalIidArray);

	sInstance = testInitInstance();
	VerifyOrQuit(sInstance != nullptr);

	child.Init(*sInstance);

	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

	printf("\nConverting IPv6 addresses from string");

	numAddresses = 0;

	// First addresses uses the mesh local prefix (mesh-local address).
	addresses[numAddresses] = sInstance->Get<Mle::MleRouter>().GetMeshLocal64();
	addresses[numAddresses].SetIid(meshLocalIid);

	numAddresses++;

	for (const char *ip6Address : ip6Addresses)
	{
	VerifyOrQuit(numAddresses < kMaxChildIp6Addresses, "Too many IPv6 addresses in the unit test");
	SuccessOrQuit(addresses[numAddresses++].FromString(ip6Address));
	}

	printf(" -- PASS\n");

	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	printf("Child state after init");
	child.Clear();
	VerifyChildIp6Addresses(child, 0, nullptr);
	printf(" -- PASS\n");

	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	printf("Adding a single IPv6 address");

	for (uint8_t index = 0; index < numAddresses; index++)
	{
	SuccessOrQuit(child.AddIp6Address(addresses[index]));
	VerifyChildIp6Addresses(child, 1, &addresses[index]);

	child.ClearIp6Addresses();
	VerifyChildIp6Addresses(child, 0, nullptr);
	}

	printf(" -- PASS\n");

	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	printf("Adding multiple IPv6 addresses");

	for (uint8_t index = 0; index < numAddresses; index++)
	{
	SuccessOrQuit(child.AddIp6Address(addresses[index]));
	VerifyChildIp6Addresses(child, index + 1, addresses);
	}

	printf(" -- PASS\n");

	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	printf("Checking for failure when adding an address already in list");

	for (uint8_t index = 0; index < numAddresses; index++)
	{
	VerifyOrQuit(child.AddIp6Address(addresses[index]) == kErrorAlready,
	"AddIp6Address() did not fail when adding same address");
	VerifyChildIp6Addresses(child, numAddresses, addresses);
	}

	printf(" -- PASS\n");

	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	printf("Removing addresses from list starting from front of the list");

	for (uint8_t index = 0; index < numAddresses; index++)
	{
	SuccessOrQuit(child.RemoveIp6Address(addresses[index]));
	VerifyChildIp6Addresses(child, numAddresses - 1 - index, &addresses[index + 1]);

	VerifyOrQuit(child.RemoveIp6Address(addresses[index]) == kErrorNotFound,
	"RemoveIp6Address() did not fail when removing an address not on the list");
	}

	VerifyChildIp6Addresses(child, 0, nullptr);
	printf(" -- PASS\n");

	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	printf("Removing addresses from list starting from back of the list");

	for (uint8_t index = 0; index < numAddresses; index++)
	{
	SuccessOrQuit(child.AddIp6Address(addresses[index]));
	}

	for (uint8_t index = numAddresses - 1; index > 0; index--)
	{
	SuccessOrQuit(child.RemoveIp6Address(addresses[index]));
	VerifyChildIp6Addresses(child, index, &addresses[0]);

	VerifyOrQuit(child.RemoveIp6Address(addresses[index]) == kErrorNotFound,
	"RemoveIp6Address() did not fail when removing an address not on the list");
	}

	printf(" -- PASS\n");

	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	printf("Removing address entries from middle of the list");

	for (uint8_t indexToRemove = 1; indexToRemove < numAddresses - 1; indexToRemove++)
	{
	child.ClearIp6Addresses();

	for (uint8_t index = 0; index < numAddresses; index++)
	{
	SuccessOrQuit(child.AddIp6Address(addresses[index]));
	}

	SuccessOrQuit(child.RemoveIp6Address(addresses[indexToRemove]));

	VerifyOrQuit(child.RemoveIp6Address(addresses[indexToRemove]) == kErrorNotFound,
	"RemoveIp6Address() did not fail when removing an address not on the list");

	{
	Ip6::Address updatedAddressList[kMaxChildIp6Addresses];
	uint8_t updatedListIndex = 0;

	for (uint8_t index = 0; index < numAddresses; index++)
	{
	if (index != indexToRemove)
	{
	updatedAddressList[updatedListIndex++] = addresses[index];
	}
	}

	VerifyChildIp6Addresses(child, updatedListIndex, updatedAddressList);
	}
	}

	printf(" -- PASS\n");

	testFreeInstance(sInstance);
	}

	} // namespace ot

	int main(void)
	{
	ot::TestChildIp6Address();
	printf("\nAll tests passed.\n");
	return 0;
	}