/******************************************************************************
The MIT License(MIT)

Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com

Copyright(c) 2014 John Wellbelove

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/

#include "unit_test_framework.h"

#include "etl/memory.h"
#include "etl/utility.h"

#include <algorithm>
#include <map>
#include <type_traits>
#include <vector>

#include "data.h"

namespace
{
  bool nonConstCalled;
  bool constCalled;

  void TestText(std::string&)
  {
    nonConstCalled = true;
  }

  void TestText(const std::string&)
  {
    constCalled = true;
  }

  int TestGlobal(int i)
  {
    return 2 * i;
  }

  using ItemM1 = TestDataM<int>;
  using ItemM2 = TestDataM<double>;

  //*****************************************************************************
  // The test class to call.
  class TestClass
  {
  public:

    int MemberFunction(int i)
    {
      return 2 * i;
    }

    int operator()(int i)
    {
      return 2 * i;
    }
  };

  static TestClass test;
} // namespace

namespace
{
  SUITE(test_utility)
  {
    //*************************************************************************
    TEST(pair_default_construct)
    {
      etl::pair<int, double> p1;

      CHECK_EQUAL(int(), p1.first);
      CHECK_EQUAL(double(), p1.second);
    }

    //*************************************************************************
    TEST(test_pair_construct)
    {
      etl::pair<int, double> p1(1, 2.3);

      CHECK_EQUAL(1, p1.first);
      CHECK_EQUAL(2.3, p1.second);
    }

#if ETL_USING_CPP17
    //*************************************************************************
    TEST(test_cpp17_deduced_pair_construct)
    {
      etl::pair p1{1, 2.3};

      CHECK((std::is_same_v<decltype(p1.first), int>));
      CHECK((std::is_same_v<decltype(p1.second), double>));

      CHECK_EQUAL(1, p1.first);
      CHECK_EQUAL(2.3, p1.second);
    }
#endif

    //*************************************************************************
    TEST(test_pair_move_parameter_construct)
    {
      etl::pair<ItemM1, ItemM2> p1(1, 2.3);

      CHECK_EQUAL(1, p1.first.value);
      CHECK_EQUAL(2.3, p1.second.value);
    }

    //*************************************************************************
    TEST(test_pair_copy_construct)
    {
      etl::pair<int, double> p1(1, 2.3);
      etl::pair<int, double> p2(p1);

      CHECK_EQUAL(p1.first, p2.first);
      CHECK_EQUAL(p1.second, p2.second);
    }

    //*************************************************************************
    TEST(test_pair_move_construct)
    {
      etl::pair<ItemM1, ItemM2> p1(1, 2.3);
      etl::pair<ItemM1, ItemM2> p2(std::move(p1));

      CHECK(!bool(p1.first));
      CHECK(!bool(p1.second));

      CHECK_EQUAL(1, p2.first.value);
      CHECK_EQUAL(2.3, p2.second.value);
    }

    //*************************************************************************
    TEST(test_pair_copy_construct_alternate)
    {
      etl::pair<char, float> p1(1, 2.3f);
      etl::pair<int, double> p2(p1);

      CHECK_EQUAL(p1.first, p2.first);
      CHECK_EQUAL(p1.second, p2.second);
    }

    //*************************************************************************
    TEST(test_make_pair)
    {
      etl::pair<int, double> p1(1, 2.3);
      etl::pair<int, double> p2;
      p2 = etl::make_pair(1, 2.3);

      CHECK_EQUAL(p1.first, p2.first);
      CHECK_EQUAL(p1.second, p2.second);
    }

    //*************************************************************************
    TEST(test_make_pair_move)
    {
      etl::pair<ItemM1, ItemM2> p1(1, 2.3);
      etl::pair<ItemM1, ItemM2> p2(0, 0);

#include "etl/private/diagnostic_pessimizing_move_push.h"
      p2 = etl::make_pair(std::move(ItemM1(1)), std::move(ItemM2(2.3)));
#include "etl/private/diagnostic_pop.h"

      CHECK_EQUAL(p1.first, p2.first);
      CHECK_EQUAL(p1.second, p2.second);
    }

    //*************************************************************************
    TEST(test_pair_swap_member)
    {
      etl::pair<int, double> p1(1, 2.3);
      etl::pair<int, double> p2(2, 3.4);

      p1.swap(p2);

      CHECK_EQUAL(2, p1.first);
      CHECK_EQUAL(3.4, p1.second);

      CHECK_EQUAL(1, p2.first);
      CHECK_EQUAL(2.3, p2.second);
    }

    //*************************************************************************
    TEST(test_pair_swap_global)
    {
      etl::pair<int, double> p1(1, 2.3);
      etl::pair<int, double> p2(2, 3.4);

      swap(p1, p2);

      CHECK_EQUAL(2, p1.first);
      CHECK_EQUAL(3.4, p1.second);

      CHECK_EQUAL(1, p2.first);
      CHECK_EQUAL(2.3, p2.second);
    }

    //*************************************************************************
    TEST(test_pair_conditional)
    {
      etl::pair<int, double> p1(1, 2.3);
      etl::pair<int, double> p2(1, 2.3);
      etl::pair<int, double> p3(2, 3.4);

      CHECK(p1 == p2);
      CHECK(!(p1 == p3));
      CHECK(p1 != p3);
      CHECK(!(p1 != p2));
      CHECK(p1 <= p2);
      CHECK(p1 <= p3);
      CHECK(!(p1 < p2));
      CHECK(p1 < p3);
      CHECK(!(p3 < p1));
      CHECK(p1 >= p2);
      CHECK(!(p1 >= p3));
      CHECK(!(p1 > p2));
      CHECK(!(p1 > p3));
      CHECK(p3 > p1);
    }

    //*************************************************************************
    TEST(test_pair_conversion)
    {
#if ETL_USING_CPP11
      etl::pair<int, std::string> ep1(1, "Hello");
      std::pair<int, std::string> sp1(2, "World");

      etl::pair<int, std::string> ep2(sp1);
      std::pair<int, std::string> sp2(ep1);

      etl::pair<const int, std::string> ep3(1, "Hello");
      std::pair<const int, std::string> sp3(2, "World");

      etl::pair<int, std::string> ep4(sp3);
      std::pair<int, std::string> sp4(ep3);

      etl::pair<const int, std::string> ep5(sp1);
      std::pair<const int, std::string> sp5(ep1);

      CHECK_EQUAL(2, ep2.first);
      CHECK_EQUAL(std::string("World"), ep2.second);

      CHECK_EQUAL(1, sp2.first);
      CHECK_EQUAL(std::string("Hello"), sp2.second);

      CHECK_EQUAL(2, ep4.first);
      CHECK_EQUAL(std::string("World"), ep4.second);

      CHECK_EQUAL(1, sp4.first);
      CHECK_EQUAL(std::string("Hello"), sp4.second);

      CHECK_EQUAL(2, ep5.first);
      CHECK_EQUAL(std::string("World"), ep5.second);

      CHECK_EQUAL(1, sp5.first);
      CHECK_EQUAL(std::string("Hello"), sp5.second);
#endif
    }

    //*************************************************************************
    TEST(test_pair_move_conversion)
    {
      etl::pair<int, std::string> ep1(1, "Hello");
      std::pair<int, std::string> sp1(2, "World");

      etl::pair<int, std::string> ep2(std::move(sp1));
      std::pair<int, std::string> sp2(std::move(ep1));

      CHECK_EQUAL(2, ep2.first);
      CHECK_EQUAL(std::string("World"), ep2.second);

      CHECK_EQUAL(1, sp2.first);
      CHECK_EQUAL(std::string("Hello"), sp2.second);
    }

    //*************************************************************************
    TEST(test_exchange)
    {
      int a = 1;
      int b = 2;
      int c = etl::exchange(a, b); // c = a, a = b

      CHECK_EQUAL(2, a);
      CHECK_EQUAL(2, b);
      CHECK_EQUAL(1, c);
    }

    //*************************************************************************
    TEST(test_exchange_const)
    {
      int       a = 1;
      const int b = 2;
      int       c = etl::exchange(a, b); // c = a, a = b

      CHECK_EQUAL(2, a);
      CHECK_EQUAL(2, b);
      CHECK_EQUAL(1, c);
    }

    //*************************************************************************
    TEST(test_exchange_unique_ptr)
    {
      etl::unique_ptr<int> p1(new int(1));
      etl::unique_ptr<int> p2 = etl::exchange(p1, nullptr);

      CHECK_FALSE(p1);
      CHECK_TRUE(p2);
      CHECK_EQUAL(*p2, 1);
    }

    //*************************************************************************
    TEST(test_exchange_unique_ptr_move_in)
    {
      etl::unique_ptr<int> a(new int(10));
      etl::unique_ptr<int> b(new int(20));

      etl::unique_ptr<int> old = etl::exchange(a, etl::move(b));

      CHECK_TRUE(old);
      CHECK_EQUAL(*old, 10);
      CHECK_TRUE(a);
      CHECK_EQUAL(*a, 20);
      CHECK_FALSE(b);
    }

    //*************************************************************************
    TEST(test_as_const)
    {
      std::string text = "Hello World!";

      nonConstCalled = false;
      constCalled    = false;

      TestText(text);

      CHECK(nonConstCalled);
      CHECK(!constCalled);

      nonConstCalled = false;
      constCalled    = false;

      TestText(etl::as_const(text));

      CHECK(!nonConstCalled);
      CHECK(constCalled);
    }

    //*************************************************************************
    TEST(test_select1st)
    {
      typedef etl::pair<int, std::string> EtlPair;
      typedef std::pair<int, std::string> StdPair;

      EtlPair ep1(1, "Hello");
      StdPair sp2(2, "World");

      auto selector = etl::select1st<EtlPair>();

      CHECK_EQUAL(1, selector(ep1));
      CHECK_EQUAL(2, selector(sp2));
    }

    //*************************************************************************
    TEST(test_select1st_example)
    {
      //! [test_select1st_example]
      using Map    = std::map<int, double>;
      using Vector = std::vector<int>;

      const Map map = {{1, 0.3}, {47, 0.8}, {33, 0.1}};
      Vector    result{};

      // Extract the map keys into a vector
      std::transform(map.begin(), map.end(), std::back_inserter(result), etl::select1st<Map::value_type>());
      //! [test_select1st_example]

      CHECK_EQUAL(3, result.size());

      const Vector expected{1, 33, 47};
      CHECK_ARRAY_EQUAL(expected, result, 3);
    }

    //*************************************************************************
    TEST(test_select2nd)
    {
      typedef etl::pair<int, std::string> EtlPair;
      typedef std::pair<int, std::string> StdPair;

      EtlPair ep1(1, "Hello");
      StdPair sp2(2, "World");

      auto selector = etl::select2nd<EtlPair>();
      CHECK_EQUAL(std::string("Hello"), selector(ep1));
      CHECK_EQUAL(std::string("World"), selector(sp2));
    }

    //*************************************************************************
    TEST(test_select2nd_example)
    {
      //! [test_select2nd_example]
      using Map    = std::map<int, double>;
      using Vector = std::vector<double>;

      const Map map = {{1, 0.3}, {47, 0.8}, {33, 0.1}};
      Vector    result{};

      // Extract the map values into a vector
      std::transform(map.begin(), map.end(), std::back_inserter(result), etl::select2nd<Map::value_type>());
      //! [test_select2nd_example]

      CHECK_EQUAL(3, result.size());

      const Vector expected{0.1, 0.3, 0.8};
      sort(result.begin(), result.end()); // sort for comparison
      CHECK_ARRAY_CLOSE(expected, result, 3, 0.0001);
    }

    //*************************************************************************
    TEST(test_functor_deprecated)
    {
      constexpr etl::functor<int, int> fw1(TestGlobal);
      CHECK_EQUAL(2, fw1(1));
    }

    //*************************************************************************
    TEST(test_member_function_wrapper_deprecated)
    {
      constexpr int (*pf)(int) = &etl::member_function_wrapper<int(int)>::function<TestClass, test, &TestClass::MemberFunction>;

      CHECK_EQUAL(2, pf(1));
    }

    //*************************************************************************
    TEST(test_functor_wrapper_deprecated)
    {
      constexpr int (*pf)(int) = &etl::functor_wrapper<int(int)>::function<TestClass, test>;

      CHECK_EQUAL(2, pf(1));
    }

    //*************************************************************************
#if ETL_USING_CPP17
    TEST(test_function_as_functor)
    {
      constexpr etl::function_as_functor<TestGlobal> faf;

      CHECK_EQUAL(2, faf(1));
    }
#endif

    //*************************************************************************
    TEST(test_function_ptr_as_functor)
    {
      using function_type = decltype(TestGlobal);

      constexpr function_type* fptr = TestGlobal;

      constexpr etl::function_ptr_as_functor<function_type> fpaf(fptr);

      CHECK_EQUAL(2, fpaf(1));
    }

    //*************************************************************************
#if ETL_USING_CPP17
    TEST(test_functor_as_static)
    {
      using fas_t = etl::functor_as_static<test>;

      CHECK_EQUAL(2, fas_t::call(1));
    }
#endif

    //*************************************************************************
#if ETL_USING_CPP17
    TEST(test_member_function_as_static)
    {
      using mfas_t = etl::member_function_as_static<&TestClass::MemberFunction, test>;

      CHECK_EQUAL(2, mfas_t::call(1));
    }
#endif

#if ETL_USING_CPP17
    //*************************************************************************
    TEST(test_member_function_as_functor)
    {
      constexpr etl::member_function_as_functor<&TestClass::MemberFunction, test> mfaf;

      CHECK_EQUAL(2, mfaf(1));
    }
#endif

    //*************************************************************************
    struct SF
    {
    };

    //*********************************
    enum class forward_call_type
    {
      LValue,
      ConstLValue,
      RValue,
      ConstRValue
    };

    //*********************************
    std::ostream& operator<<(std::ostream& os, forward_call_type type)
    {
      switch (type)
      {
        case forward_call_type::LValue:
          {
            os << "LValue";
            break;
          }

        case forward_call_type::ConstLValue:
          {
            os << "ConstLValue";
            break;
          }

        case forward_call_type::RValue:
          {
            os << "RValue";
            break;
          }

        case forward_call_type::ConstRValue:
          {
            os << "ConstRValue";
            break;
          }

        default:
          {
            os << "Unknown type";
            break;
          }
      }

      return os;
    }

    //*********************************
    forward_call_type function_f(SF&)
    {
      return forward_call_type::LValue;
    }

    //*********************************
    forward_call_type function_f(const SF&)
    {
      return forward_call_type::ConstLValue;
    }

    //*********************************
    forward_call_type function_f(SF&&)
    {
      return forward_call_type::RValue;
    }

    //*********************************
    forward_call_type function_f(const SF&&)
    {
      return forward_call_type::ConstRValue;
    }

    //*********************************
    template <typename T>
    forward_call_type template_function_f(T && t)
    {
      return function_f(etl::forward<T>(t));
    }

    //*********************************
    TEST(test_forward)
    {
      SF       s1;
      const SF s2;

      CHECK_EQUAL(forward_call_type::LValue, template_function_f(s1));
      CHECK_EQUAL(forward_call_type::RValue, template_function_f(etl::move(s1)));
      CHECK_EQUAL(forward_call_type::ConstLValue, template_function_f(s2));
      CHECK_EQUAL(forward_call_type::ConstRValue, template_function_f(etl::move(s2)));
    }

    //*************************************************************************
    struct TFL
    {
    };

    struct UFL
    {
    };

    enum class forward_like_call_type
    {
      LValue,
      ConstLValue,
      RValue,
      ConstRValue
    };

    //*********************************
    std::ostream& operator<<(std::ostream& os, forward_like_call_type type)
    {
      switch (type)
      {
        case forward_like_call_type::LValue:
          {
            os << "LValue";
            break;
          }

        case forward_like_call_type::ConstLValue:
          {
            os << "ConstLValue";
            break;
          }

        case forward_like_call_type::RValue:
          {
            os << "RValue";
            break;
          }

        case forward_like_call_type::ConstRValue:
          {
            os << "ConstRValue";
            break;
          }

        default:
          {
            os << "Unknown type";
            break;
          }
      }

      return os;
    }

    //*********************************
    forward_like_call_type function_fl(UFL&)
    {
      return forward_like_call_type::LValue;
    }

    //*********************************
    forward_like_call_type function_fl(const UFL&)
    {
      return forward_like_call_type::ConstLValue;
    }

    //*********************************
    forward_like_call_type function_fl(UFL&&)
    {
      return forward_like_call_type::RValue;
    }

    //*********************************
    forward_like_call_type function_fl(const UFL&&)
    {
      return forward_like_call_type::ConstRValue;
    }

    //*********************************
    template <typename T, typename U>
    forward_like_call_type template_function_fl(U && u)
    {
      return function_fl(etl::forward_like<T>(u));
    }

    //*********************************
    TEST(test_forward_like)
    {
      UFL        u1;
      const UFL  u2;
      UFL&       u3 = u1;
      const UFL& u4 = u2;

      CHECK_EQUAL(forward_like_call_type::LValue, template_function_fl<TFL&>(u1));
      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<const TFL&>(u1));
      CHECK_EQUAL(forward_like_call_type::RValue, template_function_fl<TFL&&>(u1));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<const TFL&&>(u1));

      CHECK_EQUAL(forward_like_call_type::LValue, template_function_fl<TFL&>(etl::move(u1)));
      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<const TFL&>(etl::move(u1)));
      CHECK_EQUAL(forward_like_call_type::RValue, template_function_fl<TFL&&>(etl::move(u1)));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<const TFL&&>(etl::move(u1)));

      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<TFL&>(u2));
      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<const TFL&>(u2));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<TFL&&>(u2));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<const TFL&&>(u2));

      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<TFL&>(etl::move(u2)));
      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<const TFL&>(etl::move(u2)));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<TFL&&>(etl::move(u2)));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<const TFL&&>(etl::move(u2)));

      CHECK_EQUAL(forward_like_call_type::LValue, template_function_fl<TFL&>(u3));
      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<const TFL&>(u3));
      CHECK_EQUAL(forward_like_call_type::RValue, template_function_fl<TFL&&>(u3));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<const TFL&&>(u3));

      CHECK_EQUAL(forward_like_call_type::LValue, template_function_fl<TFL&>(etl::move(u3)));
      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<const TFL&>(etl::move(u3)));
      CHECK_EQUAL(forward_like_call_type::RValue, template_function_fl<TFL&&>(etl::move(u3)));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<const TFL&&>(etl::move(u3)));

      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<TFL&>(u4));
      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<const TFL&>(u4));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<TFL&&>(u4));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<const TFL&&>(u4));

      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<TFL&>(etl::move(u4)));
      CHECK_EQUAL(forward_like_call_type::ConstLValue, template_function_fl<const TFL&>(etl::move(u4)));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<TFL&&>(etl::move(u4)));
      CHECK_EQUAL(forward_like_call_type::ConstRValue, template_function_fl<const TFL&&>(etl::move(u4)));
    }

#if ETL_USING_BUILTIN_UNDERLYING_TYPE
    //*********************************
    TEST(test_to_underlying)
    {
      enum enum0_t : int8_t
      {
        a0 = 'e',
        a1 = 't',
        a2 = 'l',
        a3 = '3'
      };

      enum class enum1_t : unsigned char
      {
        b0 = 2,
        b1 = 3,
        b2 = 5,
      };

      enum enum2_t : int32_t
      {
        c0 = -2,
        c1 = 100,
      };

      enum0_t e0 = enum0_t::a1;
      enum1_t e1 = enum1_t::b2;
      enum2_t e2 = enum2_t::c0;

      CHECK_TRUE((etl::is_same<int8_t, etl::underlying_type_t<enum0_t>>::value));
      CHECK_TRUE((etl::is_same<unsigned char, etl::underlying_type_t<enum1_t>>::value));
      CHECK_TRUE((etl::is_same<int32_t, etl::underlying_type_t<enum2_t>>::value));

      CHECK_EQUAL(etl::to_underlying(e0), 't');
      CHECK_EQUAL(etl::to_underlying(e1), 5);
      CHECK_EQUAL(etl::to_underlying(e2), -2);
      CHECK_EQUAL(etl::to_underlying(enum0_t::a0), 'e');
      CHECK_EQUAL(etl::to_underlying(enum0_t::a2), 'l');
      CHECK_EQUAL(etl::to_underlying(enum0_t::a3), '3');
      CHECK_EQUAL(etl::to_underlying(enum1_t::b1), 3);
      CHECK_EQUAL(etl::to_underlying(enum2_t::c1), 100);
    }
#endif

#if ETL_HAS_PACKED
    //*********************************
    TEST(test_packed)
    {
      struct Unpacked
      {
        uint32_t a = 0x12345678;
        uint8_t  b = 0x9A;
        uint32_t c = 0x87654321;
      };

      ETL_PACKED_STRUCT(Packed)
      {
        uint32_t a = 0x12345678;
        uint8_t  b = 0x9A;
        uint32_t c = 0x87654321;
      };
      ETL_END_PACKED

      Unpacked unpacked;
      Packed   packed;

      CHECK_TRUE(sizeof(unpacked) > sizeof(packed));
      CHECK_EQUAL(9U, sizeof(packed));
    }
#endif

    //*********************************
    TEST(test_swap)
    {
      uint32_t a = 0x12345678;
      uint32_t b = 0x87654321;

      ETL_OR_STD::swap(a, b);

      CHECK_EQUAL(a, 0x87654321);
      CHECK_EQUAL(b, 0x12345678);

      uint32_t* p_a = &a;
      uint32_t* p_b = &b;

      ETL_OR_STD::swap(p_a, p_b);

      CHECK_EQUAL(a, 0x87654321);
      CHECK_EQUAL(b, 0x12345678);
      CHECK_EQUAL(p_a, &b);
      CHECK_EQUAL(p_b, &a);

      uint32_t a_a[4]{0x12345678, 0x23456789, 0x34567890, 0x09876543};
      uint32_t a_b[4]{0x12abcd78, 0x23abcd89, 0x34abcd90, 0x09abcd43};

      ETL_OR_STD::swap(a_a, a_b);

      CHECK_EQUAL(a_a[0], 0x12abcd78);
      CHECK_EQUAL(a_a[1], 0x23abcd89);
      CHECK_EQUAL(a_a[2], 0x34abcd90);
      CHECK_EQUAL(a_a[3], 0x09abcd43);

      CHECK_EQUAL(a_b[0], 0x12345678);
      CHECK_EQUAL(a_b[1], 0x23456789);
      CHECK_EQUAL(a_b[2], 0x34567890);
      CHECK_EQUAL(a_b[3], 0x09876543);
    }

#if ETL_USING_CPP17 && !defined(ETL_FORCE_CPP11_NONTYPE)
    //*********************************
    TEST(test_nontype_t_cpp17)
    {
      // Test with int
      CHECK_TRUE(42 == etl::nontype_t<42>::value);

      // Test with bool
      CHECK_TRUE(true == etl::nontype_t<true>::value);

      // Test with char
      CHECK_TRUE('A' == etl::nontype_t<'A'>::value);

      // Test with enum
      enum class E : uint8_t
      {
        A = 1,
        B = 2
      };
      CHECK_TRUE(E::A == etl::nontype_t<E::A>::value);
      CHECK_TRUE(E::B == etl::nontype_t<E::B>::value);
    }
#elif ETL_USING_CPP11
    enum class E : uint8_t
    {
      A = 1,
      B = 2
    };

    TEST(test_nontype_t_cpp11)
    {
      // Test with int
      CHECK_TRUE(42 == (etl::nontype_t<int, 42>::value));

      // Test with bool
      CHECK_TRUE(true == (etl::nontype_t<bool, true>::value));

      // Test with char
      CHECK_TRUE('A' == (etl::nontype_t<char, 'A'>::value));

      // Test with enum
      CHECK_TRUE(E::A == (etl::nontype_t<E, E::A>::value));
      CHECK_TRUE(E::B == (etl::nontype_t<E, E::B>::value));
    }
#endif

    //*********************************
    TEST(test_make_index_sequence_matches_expected)
    {
      using seq0    = etl::make_index_sequence<0U>;
      using seq1    = etl::make_index_sequence<1U>;
      using seq4    = etl::make_index_sequence<4U>;
      using expect0 = etl::index_sequence<>;
      using expect1 = etl::index_sequence<0U>;
      using expect4 = etl::index_sequence<0U, 1U, 2U, 3U>;

      CHECK_TRUE((std::is_same<seq0, expect0>::value));
      CHECK_TRUE((std::is_same<seq1, expect1>::value));
      CHECK_TRUE((std::is_same<seq4, expect4>::value));
    }

    //*********************************
    TEST(test_make_index_sequence_for_pack_matches_expected)
    {
      struct T1
      {
      };
      struct T2
      {
      };
      struct T3
      {
      };

      using seq12     = etl::make_index_sequence_for<T1, T2>;
      using seq123    = etl::make_index_sequence_for<T1, T2, T3>;
      using expect12  = etl::index_sequence<0U, 1U>;
      using expect123 = etl::index_sequence<0U, 1U, 2U>;

      CHECK_TRUE((std::is_same<seq12, expect12>::value));
      CHECK_TRUE((std::is_same<seq123, expect123>::value));
    }

    //*********************************
    TEST(test_make_index_sequence_for_type_list_matches_expected)
    {
      struct T1
      {
      };
      struct T2
      {
      };
      struct T3
      {
      };

      using list12    = etl::type_list<T1, T2>;
      using list123   = etl::type_list<T1, T2, T3>;
      using seq12     = etl::make_index_sequence_for<list12>;
      using seq123    = etl::make_index_sequence_for<list123>;
      using expect12  = etl::index_sequence<0U, 1U>;
      using expect123 = etl::index_sequence<0U, 1U, 2U>;

      CHECK_TRUE((std::is_same<seq12, expect12>::value));
      CHECK_TRUE((std::is_same<seq123, expect123>::value));
    }

    //*********************************
    TEST(test_make_index_sequence_with_offset_matches_expected)
    {
      using seq0    = etl::make_index_sequence_with_offset<5U, 0U>;
      using seq2    = etl::make_index_sequence_with_offset<3U, 2U>;
      using seq4    = etl::make_index_sequence_with_offset<7U, 4U>;
      using expect0 = etl::index_sequence<>;
      using expect2 = etl::index_sequence<3U, 4U>;
      using expect4 = etl::index_sequence<7U, 8U, 9U, 10U>;

      CHECK_TRUE((std::is_same<seq0, expect0>::value));
      CHECK_TRUE((std::is_same<seq2, expect2>::value));
      CHECK_TRUE((std::is_same<seq4, expect4>::value));
    }

    //*********************************
    TEST(test_index_sequence_push_front_matches_expected)
    {
      using seq0    = etl::index_sequence<>;
      using seq1    = etl::index_sequence<1U, 2U>;
      using result0 = etl::index_sequence_push_front_t<seq0, 5U>;
      using result1 = etl::index_sequence_push_front_t<seq1, 0U>;
      using expect0 = etl::index_sequence<5U>;
      using expect1 = etl::index_sequence<0U, 1U, 2U>;

      CHECK_TRUE((std::is_same<result0, expect0>::value));
      CHECK_TRUE((std::is_same<result1, expect1>::value));
    }

    //*********************************
    TEST(test_index_sequence_pop_front_matches_expected)
    {
      using seq0    = etl::index_sequence<>;
      using seq1    = etl::index_sequence<1U, 2U>;
      using result0 = etl::index_sequence_pop_front_t<seq0>;
      using result1 = etl::index_sequence_pop_front_t<seq1>;
      using expect0 = etl::index_sequence<>;
      using expect1 = etl::index_sequence<2U>;

      CHECK_TRUE((std::is_same<result0, expect0>::value));
      CHECK_TRUE((std::is_same<result1, expect1>::value));
    }

    //*********************************
    TEST(test_index_sequence_push_back_matches_expected)
    {
      using seq0    = etl::index_sequence<>;
      using seq1    = etl::index_sequence<1U, 2U>;
      using result0 = etl::index_sequence_push_back_t<seq0, 5U>;
      using result1 = etl::index_sequence_push_back_t<seq1, 3U>;
      using expect0 = etl::index_sequence<5U>;
      using expect1 = etl::index_sequence<1U, 2U, 3U>;

      CHECK_TRUE((std::is_same<result0, expect0>::value));
      CHECK_TRUE((std::is_same<result1, expect1>::value));
    }

    //*********************************
    TEST(test_index_sequence_pop_back_matches_expected)
    {
      using seq0    = etl::index_sequence<>;
      using seq1    = etl::index_sequence<1U, 2U>;
      using result0 = etl::index_sequence_pop_back_t<seq0>;
      using result1 = etl::index_sequence_pop_back_t<seq1>;
      using expect0 = etl::index_sequence<>;
      using expect1 = etl::index_sequence<1U>;

      CHECK_TRUE((std::is_same<result0, expect0>::value));
      CHECK_TRUE((std::is_same<result1, expect1>::value));
    }

    //*********************************
    TEST(test_index_sequence_cat_matches_expected)
    {
      using seq0    = etl::index_sequence<>;
      using seq1    = etl::index_sequence<0U, 1U>;
      using seq2    = etl::index_sequence<2U, 3U>;
      using result0 = etl::index_sequence_cat_t<seq0, seq1>;
      using result1 = etl::index_sequence_cat_t<seq1, seq2>;
      using expect0 = etl::index_sequence<0U, 1U>;
      using expect1 = etl::index_sequence<0U, 1U, 2U, 3U>;

      CHECK_TRUE((std::is_same<result0, expect0>::value));
      CHECK_TRUE((std::is_same<result1, expect1>::value));
    }

    //*********************************
    TEST(test_index_sequence_at_matches_expected)
    {
      // using seq0    = etl::index_sequence<>;          // This should fail to
      // compile as seq0 is empty
      using seq1 = etl::index_sequence<1U, 2U, 3U>;
      // using result0 = etl::index_sequence_at<seq0, 0>; // This should fail to
      // compile as seq0 is empty auto  ignore0 = result0; // Uses result0
      size_t result1a = etl::index_sequence_at<seq1, 0>::value;
      size_t result1b = etl::index_sequence_at<seq1, 1>::value;
      size_t result1c = etl::index_sequence_at<seq1, 2>::value;
      // size_t result1d = etl::index_sequence_at<seq1, 3>::value;  // This
      // should fail to compile as seq1 only has 3 elements auto   ignore1d =
      // result1d;                                // Uses result1d
      size_t expect1a = 1U;
      size_t expect1b = 2U;
      size_t expect1c = 3U;

      CHECK_EQUAL(expect1a, result1a);
      CHECK_EQUAL(expect1b, result1b);
      CHECK_EQUAL(expect1c, result1c);

#if ETL_USING_CPP17
      size_t result1e = etl::index_sequence_at_v<seq1, 0>;
      size_t result1f = etl::index_sequence_at_v<seq1, 1>;
      size_t result1g = etl::index_sequence_at_v<seq1, 2>;

      CHECK_EQUAL(expect1a, result1e);
      CHECK_EQUAL(expect1b, result1f);
      CHECK_EQUAL(expect1c, result1g);
#endif
    }

    //*************************************************************************
    TEST(test_pair_equality_uses_equality_operator)
    {
      // Basic equality
      etl::pair<int, int> p1(1, 2);
      etl::pair<int, int> p2(1, 2);
      etl::pair<int, int> p3(1, 3);
      etl::pair<int, int> p4(2, 2);

      CHECK_TRUE(p1 == p2);
      CHECK_FALSE(p1 == p3); // different second
      CHECK_FALSE(p1 == p4); // different first

      // Custom type where operator== and operator< can disagree
      // The old code used !(a<b) && !(a>b), which is NOT equivalent to a==b
      // for types that don't define a total order consistent with equality.
      struct WeirdType
      {
        int  value;
        bool equal_flag;

        bool operator==(const WeirdType& other) const
        {
          return equal_flag && other.equal_flag;
        }
        bool operator<(const WeirdType& other) const
        {
          return value < other.value;
        }
        bool operator>(const WeirdType& other) const
        {
          return value > other.value;
        }
      };

      WeirdType w1{1, false};
      WeirdType w2{1, false}; // same value, but equal_flag is false

      // With proper ==: w1 == w2 should be false (both equal_flags are false)
      // With old !(w1<w2)&&!(w1>w2): would be true (same value)
      etl::pair<int, WeirdType> pw1(0, w1);
      etl::pair<int, WeirdType> pw2(0, w2);

      CHECK_FALSE(pw1 == pw2); // This would FAIL with the old < > based comparison
    }

#if ETL_USING_CPP14
    //*************************************************************************
    TEST(test_pair_constexpr_copy_ctor)
    {
      constexpr etl::pair<int, int> p1(1, 2);
      constexpr etl::pair<int, int> p2(p1);
      static_assert(p2.first == 1, "constexpr pair copy ctor first");
      static_assert(p2.second == 2, "constexpr pair copy ctor second");
      CHECK(true);
    }

    //*************************************************************************
    TEST(test_coordinate_2d_constexpr_ctors)
    {
      constexpr etl::coordinate_2d<int> c1;
      constexpr etl::coordinate_2d<int> c2(3, 4);
      static_assert(c1.x == 0, "constexpr default ctor x");
      static_assert(c1.y == 0, "constexpr default ctor y");
      static_assert(c2.x == 3, "constexpr value ctor x");
      static_assert(c2.y == 4, "constexpr value ctor y");
      CHECK(true);
    }
#endif
  }
} // namespace
