From 72fc291d25eb3d6b94c588085b27671395204a7a Mon Sep 17 00:00:00 2001
From: Richard Bailey <rsjtaylor.github@gmail.com>
Date: Tue, 29 Jun 2021 10:49:02 +0100
Subject: [PATCH] Update test helpers to add generic vectorparameter checks and
 comparisor ops

---
 tests/helper/parameter_checks.hpp      | 35 +++++++++++++++++
 tests/helper/parameter_comparators.hpp | 54 +++++++-------------------
 2 files changed, 49 insertions(+), 40 deletions(-)

diff --git a/tests/helper/parameter_checks.hpp b/tests/helper/parameter_checks.hpp
index 7c9b4ce2..25c0b5e5 100644
--- a/tests/helper/parameter_checks.hpp
+++ b/tests/helper/parameter_checks.hpp
@@ -73,6 +73,34 @@ namespace adm_test {
       }
     }
 
+    template <typename ParamT, typename ElementT, typename VectorT>
+    void check_vector_impl(ElementT& element, VectorT parameter_vector) {
+      SECTION("test should be supplied with non-empty vector") {
+        using ValueT = typename VectorT::value_type;
+        // if it's an optional vector, set to empty vector
+        if (!element.template has<VectorT>()) {
+          element.set(VectorT{});
+        }
+      }
+      SECTION("Check add & remove") {
+        auto items = element.template get<ParamT>();
+        REQUIRE(items.empty());
+        for (auto const& i : parameter_vector) {
+          element.add(i);
+        }
+        items = element.template get<ParamT>();
+        REQUIRE(items.size() == parameter_vector.size());
+        for (auto i = 0u; i != items.size(); ++i) {
+          REQUIRE(items[i] == parameter_vector[i]);
+        }
+        for (auto i = 0u; i != items.size(); ++i) {
+          element.remove(items[i]);
+        }
+        items = element.template get<ParamT>();
+        REQUIRE(items.empty());
+      }
+    }
+
     template <typename T>
     class HasDefaultOf {
      public:
@@ -127,6 +155,13 @@ namespace adm_test {
                                         modifiedVal.get());
   }
 
+  template <typename ParamT, typename ElementT, typename VectorT>
+  void check_vector_param(std::shared_ptr<ElementT> element,
+                          detail::CanBeSetTo<VectorT> modifiedVal) {
+    detail::check_vector_impl<ParamT>(detail::get_from_shared(element),
+                                      modifiedVal.get());
+  }
+
   template <typename T>
   detail::HasDefaultOf<T> hasDefaultOf(T value) {
     return detail::HasDefaultOf<T>(value);
diff --git a/tests/helper/parameter_comparators.hpp b/tests/helper/parameter_comparators.hpp
index 212f812c..1b7d8553 100644
--- a/tests/helper/parameter_comparators.hpp
+++ b/tests/helper/parameter_comparators.hpp
@@ -1,59 +1,33 @@
 #pragma once
-
-namespace detail {
-  template <typename ParameterT, typename ElementT>
-  bool compareOptionalParameter(ElementT const& lhs, ElementT const& rhs) {
-    // if one has the parameter and the other doesn't they're not equal
-    if (lhs.template has<ParameterT>() != rhs.template has<ParameterT>()) {
-      return false;
-    }
-    // either both have it or neither does. If neither, they're equal.
-    if (!lhs.template has<ParameterT>()) {
-      return true;
-    }
-    // otherwise both have the parameter, so compare.
-    return lhs.template get<ParameterT>() == rhs.template get<ParameterT>();
-  }
-
-  template <typename FirstParam, typename... Params>
-  struct Comparator {
-    template <typename ElementT>
-    static bool compareAll(ElementT const& lhs, ElementT const& rhs) {
-      return (compareOptionalParameter<FirstParam>(lhs, rhs) &&
-              Comparator<Params...>::compareAll(lhs, rhs));
-    }
-  };
-  template <typename FirstParam>
-  struct Comparator<FirstParam> {
-    template <typename ElementT>
-    static bool compareAll(ElementT const& lhs, ElementT const& rhs) {
-      return compareOptionalParameter<FirstParam>(lhs, rhs);
-    }
-  };
-  template <typename... Params, typename ElementT>
-  bool compareOptionals(ElementT const& lhs, ElementT const& rhs) {
-    return Comparator<Params...>::compareAll(lhs, rhs);
-  }
-}  // namespace detail
+#include <adm/detail/optional_comparison.hpp>
+#include <adm/elements_fwd.hpp>
+#include <adm/elements/loudness_metadata.hpp>
 
 namespace adm {
   bool operator==(ChannelLock const& lhs, ChannelLock const& rhs) {
-    using ::detail::compareOptionals;
+    using detail::compareOptionals;
     return compareOptionals<ChannelLockFlag, MaxDistance>(lhs, rhs);
   }
   bool operator==(ObjectDivergence const& lhs, ObjectDivergence const& rhs) {
-    using ::detail::compareOptionals;
+    using detail::compareOptionals;
     return compareOptionals<Divergence, AzimuthRange, PositionRange>(lhs, rhs);
   }
   bool operator==(JumpPosition const& lhs, JumpPosition const& rhs) {
-    using ::detail::compareOptionals;
+    using detail::compareOptionals;
     return compareOptionals<JumpPositionFlag, InterpolationLength>(lhs, rhs);
   }
   bool operator==(HeadphoneVirtualise const& lhs,
                   HeadphoneVirtualise const& rhs) {
-    using ::detail::compareOptionals;
+    using detail::compareOptionals;
     return compareOptionals<Bypass, DirectToReverberantRatio>(lhs, rhs);
   }
+  bool operator==(LoudnessMetadata const& lhs, LoudnessMetadata const& rhs) {
+    using detail::compareOptionals;
+    return compareOptionals<LoudnessMethod, LoudnessRecType,
+                            LoudnessCorrectionType, IntegratedLoudness,
+                            LoudnessRange, MaxTruePeak, MaxMomentary,
+                            MaxShortTerm, DialogueLoudness>(lhs, rhs);
+  }
   bool operator==(Gain const& lhs, Gain const& rhs) {
     if (lhs.isDb() != rhs.isDb()) {
       return false;