test_Variants.cxx

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#include <catch_amalgamated.hpp>
#include "Framework/Variant.h"
#include "Framework/VariantPropertyTreeHelpers.h"
#include "Framework/VariantJSONHelpers.h"
#include <sstream>
#include <cstring>
 
using namespace o2::framework;
 
bool unknown_type(RuntimeErrorRef const& ref)
{
  auto const& err = error_from_ref(ref);
  return strcmp(err.what, "Mismatch between types") == 0;
}
 
TEST_CASE("VariantTest")
{
  std::ostringstream ss{};
  Variant a(10);
  REQUIRE(a.get<int>() == 10);
  ss << a;
  Variant b(10.1f);
  REQUIRE(b.get<float>() == 10.1f);
  ss << b;
  Variant c(10.2);
  REQUIRE(c.get<double>() == 10.2);
  ss << c;
  REQUIRE_THROWS_AS(a.get<char*>(), RuntimeErrorRef);
  Variant d("foo");
  ss << d;
  REQUIRE(std::string(d.get<const char*>()) == "foo");
  REQUIRE(std::string(d.get<std::string_view>()) == "foo");
  REQUIRE(std::string(d.get<std::string>()) == "foo");
 
  Variant e(true);
  REQUIRE(e.get<bool>() == true);
 
  Variant f(false);
  REQUIRE(f.get<bool>() == false);
 
  REQUIRE(ss.str() == "1010.110.2foo");
  // Spotted valgrind error while deleting a vector of variants.
  std::vector<Variant> vector{1, 1.2, 1.1f, "foo"};
  Variant sa("foo");
  Variant sb(sa);            // Copy constructor
  Variant sc(std::move(sa)); // Move constructor
  Variant sd = sc;           // Copy assignment
 
  REQUIRE(std::string(sb.get<const char*>()) == "foo");
  REQUIRE(std::string(sc.get<const char*>()) == "foo");
  REQUIRE(std::string(sd.get<const char*>()) == "foo");
  REQUIRE(sa.get<const char*>() == nullptr);
 
  int iarr[] = {1, 2, 3, 4, 5};
  float farr[] = {0.2, 0.3, 123.123, 123.123, 3.005e-5, 1.1e6};
  std::vector<double> dvec = {0.1, 0.2, 0.4, 0.9, 1.3, 14.5, 123.234, 1.213e-20};
  Variant viarr(iarr, 5);
  Variant vfarr(farr, 6);
  Variant vdvec(dvec);
 
  REQUIRE(viarr.size() == 5);
  REQUIRE(viarr.get<int*>() != iarr);
  for (auto i = 0u; i < viarr.size(); ++i) {
    REQUIRE(iarr[i] == (viarr.get<int*>())[i]);
  }
 
  REQUIRE(vfarr.size() == 6);
  REQUIRE(vfarr.get<float*>() != farr);
  for (auto i = 0u; i < vfarr.size(); ++i) {
    REQUIRE(farr[i] == (vfarr.get<float*>())[i]);
  }
 
  REQUIRE(vdvec.size() == dvec.size());
  REQUIRE(vdvec.get<double*>() != dvec.data());
  for (auto i = 0u; i < dvec.size(); ++i) {
    REQUIRE(dvec[i] == (vdvec.get<double*>())[i]);
  }
 
  Variant fb(vfarr);            // Copy constructor
  Variant fc(std::move(vfarr)); // Move constructor
  Variant fd = fc;              // Copy assignment
 
  REQUIRE(vfarr.get<float*>() == nullptr);
 
  REQUIRE(fb.get<float*>() != farr);
  for (auto i = 0u; i < fb.size(); ++i) {
    REQUIRE(farr[i] == (fb.get<float*>())[i]);
  }
  REQUIRE(fc.get<float*>() != farr);
  for (auto i = 0u; i < fc.size(); ++i) {
    REQUIRE(farr[i] == (fc.get<float*>())[i]);
  }
  REQUIRE(fd.get<float*>() != farr);
  for (auto i = 0u; i < fd.size(); ++i) {
    REQUIRE(farr[i] == (fd.get<float*>())[i]);
  }
 
  std::vector<std::string> vstrings{"s1", "s2", "s3"};
  std::string strings[] = {"l1", "l2", "l3"};
  Variant vstr(strings, 3);
  Variant vvstr(vstrings);
 
  REQUIRE(vstr.size() == 3);
  REQUIRE(vvstr.size() == 3);
  for (auto i = 0u; i < vstr.size(); ++i) {
    REQUIRE(strings[i] == (vstr.get<std::string*>())[i]);
  }
  for (auto i = 0u; i < vvstr.size(); ++i) {
    REQUIRE(vstrings[i] == (vvstr.get<std::string*>())[i]);
  }
 
  Variant vsc(vstr);            // Copy constructor
  Variant vsm(std::move(vstr)); // Move constructor
  Variant vscc = vsm;           // Copy assignment
  for (auto i = 0u; i < vsm.size(); ++i) {
    REQUIRE(strings[i] == (vsm.get<std::string*>())[i]);
  }
  for (auto i = 0u; i < vscc.size(); ++i) {
    REQUIRE(strings[i] == (vscc.get<std::string*>())[i]);
  }
 
  Variant vsca(vvstr);            // Copy constructor
  Variant vsma(std::move(vvstr)); // Move constructor
  Variant vscca = vsma;           // Copy assignment
  for (auto i = 0u; i < vsma.size(); ++i) {
    REQUIRE(vstrings[i] == (vsma.get<std::string*>())[i]);
  }
  for (auto i = 0u; i < vscca.size(); ++i) {
    REQUIRE(vstrings[i] == (vscca.get<std::string*>())[i]);
  }
 
  float m[3][4] = {{0.5, 0.25, 0.125, 0.0625}, {1.0, 2.0, 3.0, 4.0}, {2.0, 0.5, 4.0, 0.25}};
  Array2D mm(&m[0][0], 3, 4);
  Variant vmm(mm);
  auto const& mmc = vmm.get<Array2D<float>>();
  for (auto i = 0u; i < 3; ++i) {
    for (auto j = 0u; j < 4; ++j) {
      REQUIRE(mmc(i, j) == mm(i, j));
    }
  }
 
  Variant vmmc(vmm);            // Copy constructor
  Variant vmmm(std::move(vmm)); // Move constructor
  Variant vmma = vmmm;          // Copy assignment
  auto const& mmc2 = vmmc.get<Array2D<float>>();
  for (auto i = 0u; i < 3; ++i) {
    for (auto j = 0u; j < 4; ++j) {
      REQUIRE(mmc2(i, j) == mm(i, j));
    }
  }
  auto const& mmc3 = vmma.get<Array2D<float>>();
  for (auto i = 0u; i < 3; ++i) {
    for (auto j = 0u; j < 4; ++j) {
      REQUIRE(mmc3(i, j) == mm(i, j));
    }
  }
  std::stringstream ssm;
  ssm << vmma;
  REQUIRE(ssm.str() == "{\"values\":[[0.5,0.25,0.125,0.0625],[1.0,2.0,3.0,4.0],[2.0,0.5,4.0,0.25]]}");
 
  LabeledArray<float> laf{&m[0][0], 3, 4, {"r1", "r2", "r3"}, {"c1", "c2", "c3", "c4"}};
  Variant vlaf(laf);
  auto const& lafc = vlaf.get<LabeledArray<float>>();
  for (auto i = 0u; i < 3; ++i) {
    for (auto j = 0u; j < 4; ++j) {
      REQUIRE(laf.get(i, j) == lafc.get(i, j));
    }
  }
 
  Variant vlafc(vlaf);            // Copy constructor
  Variant vlafm(std::move(vlaf)); // Move constructor
  Variant vlafa = vlafm;          // Copy assignment
  auto const& lafc2 = vlafc.get<LabeledArray<float>>();
  for (auto i = 0U; i < 3; ++i) {
    for (auto j = 0U; j < 4; ++j) {
      REQUIRE(lafc2.get(i, j) == mm(i, j));
    }
  }
  auto const& lafc3 = vlafa.get<LabeledArray<float>>();
  for (auto i = 0U; i < 3; ++i) {
    for (auto j = 0U; j < 4; ++j) {
      REQUIRE(lafc3.get(i, j) == mm(i, j));
    }
  }
 
  std::vector<Variant> collection;
  collection.push_back(vlafc);
  collection.push_back(vlafm);
  collection.push_back(vlafa);
}
 
TEST_CASE("Array2DTest")
{
  float m[3][4] = {{0.1, 0.2, 0.3, 0.4}, {0.5, 0.6, 0.7, 0.8}, {0.9, 1.0, 1.1, 1.2}};
  Array2D mm(&m[0][0], 3, 4);
  for (auto i = 0U; i < 3; ++i) {
    for (auto j = 0U; j < 4; ++j) {
      REQUIRE(mm(i, j) == m[i][j]);
    }
  }
  std::vector<float> v = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2};
  Array2D mv(v, 3, 4);
  for (auto i = 0U; i < 3; ++i) {
    for (auto j = 0U; j < 4; ++j) {
      REQUIRE(mm(i, j) == v[i * 4 + j]);
    }
  }
  for (auto i = 0U; i < 3; ++i) {
    auto const& vv = mm[i];
    for (auto j = 0u; j < 4; ++j) {
      REQUIRE(vv[j] == mm(i, j));
    }
  }
  std::vector<std::string> s = {"one", "two", "three", "four"};
  Array2D ms(s, 4, 1);
  for (auto i = 0U; i < 4; ++i) {
    REQUIRE(ms(i, 0) == s[i]);
  }
}
 
TEST_CASE("Array2DAssignmentTest")
{
  std::vector<int> v = {1, 2, 3, 4, 5, 6};
  Array2D<int> source(v, 2, 3);
 
  // copy assignment to an array of different shape makes an independent deep copy
  Array2D<int> copied(std::vector<int>{7}, 1, 1);
  copied = source;
  REQUIRE(copied.rows == 2);
  REQUIRE(copied.cols == 3);
  REQUIRE(copied.data != source.data);
  source[0][0] = 42;
  REQUIRE(copied(0, 0) == 1);
  for (auto i = 1U; i < 6; ++i) {
    REQUIRE(copied(i / 3, i % 3) == v[i]);
  }
 
  // self copy assignment keeps the contents
  auto& self = copied;
  copied = self;
  REQUIRE(copied.rows == 2);
  REQUIRE(copied.cols == 3);
  REQUIRE(copied(1, 2) == 6);
 
  // move assignment takes over the buffer and empties the source
  auto* buffer = copied.data;
  Array2D<int> moved(std::vector<int>{7, 8}, 1, 2);
  moved = std::move(copied);
  REQUIRE(moved.data == buffer);
  REQUIRE(moved.rows == 2);
  REQUIRE(moved.cols == 3);
  REQUIRE(moved(1, 2) == 6);
  REQUIRE(copied.data == nullptr);
  REQUIRE(copied.rows == 0);
  REQUIRE(copied.cols == 0);
 
  // self move assignment keeps the contents
  auto& selfMoved = moved;
  moved = std::move(selfMoved);
  REQUIRE(moved.data == buffer);
  REQUIRE(moved(1, 2) == 6);
 
  // assigning an empty array releases the old buffer and leaves an empty array
  moved = Array2D<int>{};
  REQUIRE(moved.data == nullptr);
  REQUIRE(moved.rows == 0);
  REQUIRE(moved.cols == 0);
 
  // strings are copied element by element
  std::vector<std::string> s = {"one", "two"};
  Array2D<std::string> ms(s, 2, 1);
  Array2D<std::string> msc;
  msc = ms;
  ms[0][0] = "changed";
  REQUIRE(msc(0, 0) == "one");
  REQUIRE(msc(1, 0) == "two");
}
 
TEST_CASE("VariantLifecycleTest")
{
  float m[2][3] = {{1, 2, 3}, {4, 5, 6}};
  LabeledArray<float> laf{&m[0][0], 2, 3, {"r1", "r2"}, {"c1", "c2", "c3"}};
  std::vector<std::string> vs{"s1", "s2", "s3"};
  auto checkLabeled = [&](Variant const& v) {
    REQUIRE(v.type() == VariantType::LabeledArrayFloat);
    auto la = v.get<LabeledArray<float>>();
    REQUIRE(la.rows() == 2);
    REQUIRE(la.cols() == 3);
    REQUIRE(la.get("r2", "c3") == 6);
    REQUIRE(la.getLabelsRows() == std::vector<std::string>{"r1", "r2"});
  };
 
  Variant vl(laf);
  // copies are independent and survive the destruction of the original
  auto* copy = new Variant(vl);
  Variant moved(std::move(*copy));
  delete copy;
  checkLabeled(vl);
  checkLabeled(moved);
 
  // assignment across types releases the previous content
  Variant vstr("a string");
  vstr = vl;
  checkLabeled(vstr);
  vstr = Variant("back to a string");
  REQUIRE(vstr.type() == VariantType::String);
  REQUIRE(std::string(vstr.get<const char*>()) == "back to a string");
  vstr = std::move(moved);
  checkLabeled(vstr);
  Variant vvs(vs);
  vstr = vvs;
  REQUIRE(vstr.get<std::vector<std::string>>() == vs);
 
  // self assignment keeps the content
  auto& self = vl;
  vl = self;
  checkLabeled(vl);
  vl = std::move(self);
  checkLabeled(vl);
 
  // moving a string array leaves a valid moved-from Variant behind
  Variant vvsMoved(std::move(vvs));
  REQUIRE(vvsMoved.get<std::vector<std::string>>() == vs);
  vvs = vvsMoved;
  REQUIRE(vvs.get<std::vector<std::string>>() == vs);
 
  // reallocation of a container moves the Variants around
  std::vector<Variant> collection;
  for (auto i = 0; i < 20; ++i) {
    collection.emplace_back(laf);
    collection.emplace_back(Array2D<float>{&m[0][0], 2, 3});
    collection.emplace_back(vs);
    collection.emplace_back("a string");
  }
  std::vector<Variant> collectionCopy = collection;
  collection.clear();
  for (auto i = 0U; i < collectionCopy.size(); i += 4) {
    checkLabeled(collectionCopy[i]);
    REQUIRE(collectionCopy[i + 1].get<Array2D<float>>()(1, 2) == 6);
    REQUIRE(collectionCopy[i + 2].get<std::vector<std::string>>() == vs);
    REQUIRE(std::string(collectionCopy[i + 3].get<const char*>()) == "a string");
  }
 
  // a Variant created with only a type can be copied and destroyed
  Variant typed(VariantType::LabeledArrayFloat);
  Variant typedCopy(typed);
  REQUIRE(typedCopy.get<LabeledArray<float>>().rows() == 0);
  Variant typedString(VariantType::String);
  Variant typedStringCopy(typedString);
  REQUIRE(typedStringCopy.get<const char*>() == nullptr);
 
  // set replaces the content and the type
  Variant vset(1);
  vset.set(laf);
  checkLabeled(vset);
  vset.set(vs);
  REQUIRE(vset.type() == VariantType::ArrayString);
  REQUIRE(vset.get<std::vector<std::string>>() == vs);
}
 
TEST_CASE("LabeledArrayTest")
{
  float m[3][4] = {{0.1, 0.2, 0.3, 0.4}, {0.5, 0.6, 0.7, 0.8}, {0.9, 1.0, 1.1, 1.2}};
  std::string mS[3][4] = {{"a", "b", "c", "d"}, {"e", "f", "g", "h"}, {"i", "l", "m", "n"}};
  std::string xl[] = {"c1", "c2", "c3", "c4"};
  std::string yl[] = {"r1", "r2", "r3"};
  LabeledArray<float> laf{&m[0][0], 3, 4, {"r1", "r2", "r3"}, {"c1", "c2", "c3", "c4"}};
  LabeledArray<std::string> las{&mS[0][0], 3, 4, {"r1", "r2", "r3"}, {"c1", "c2", "c3", "c4"}};
  for (auto i = 0u; i < 3; ++i) {
    for (auto j = 0u; j < 4; ++j) {
      REQUIRE(laf.get(yl[i].c_str(), xl[j].c_str()) == laf.get(i, j));
      REQUIRE(laf.get(i, xl[j].c_str()) == laf.get(i, j));
      REQUIRE(laf.get(yl[i].c_str(), j) == laf.get(i, j));
 
      REQUIRE(las.get(yl[i].c_str(), xl[j].c_str()) == las.get(i, j));
      REQUIRE(las.get(i, xl[j].c_str()) == las.get(i, j));
      REQUIRE(las.get(yl[i].c_str(), j) == las.get(i, j));
    }
  }
}
 
TEST_CASE("VariantTreeConversionsTest")
{
  std::vector<std::string> vstrings{"0 1", "0 2", "0 3"};
  Variant vvstr(vstrings);
 
  auto tree = vectorToBranch(vvstr.get<std::string*>(), vvstr.size());
  auto fromTree = vectorFromBranch<std::string>(tree);
  auto v = Variant(fromTree);
 
  REQUIRE(vvstr.size() == vstrings.size());
  REQUIRE(v.size() == vstrings.size());
  for (auto i = 0U; i < vvstr.size(); ++i) {
    REQUIRE(vvstr.get<std::string*>()[i] == v.get<std::string*>()[i]);
  }
}
 
TEST_CASE("VariantJSONConversionsTest")
{
  int iarr[] = {1, 2, 3, 4, 5};
  Variant viarr(iarr, 5);
  std::stringstream os;
  VariantJSONHelpers::write(os, viarr);
 
  std::stringstream is;
  is.str(os.str());
  auto v = VariantJSONHelpers::read<VariantType::ArrayInt>(is);
  for (auto i = 0u; i < viarr.size(); ++i) {
    REQUIRE(v.get<int*>()[i] == viarr.get<int*>()[i]);
  }
  os.str("");
 
  float m[3][4] = {{0.1, 0.2, 0.3, 0.4}, {0.5, 0.6, 0.7, 0.8}, {0.9, 1.0, 1.1, 1.2}};
  Array2D mm(&m[0][0], 3, 4);
  Variant vmm(mm);
  std::stringstream osm;
  VariantJSONHelpers::write(osm, vmm);
 
  std::stringstream ism;
  ism.str(osm.str());
  auto vm = VariantJSONHelpers::read<VariantType::Array2DFloat>(ism);
 
  for (auto i = 0u; i < mm.rows; ++i) {
    for (auto j = 0u; j < mm.cols; ++j) {
      REQUIRE(vmm.get<Array2D<float>>()(i, j) == vm.get<Array2D<float>>()(i, j));
    }
  }
 
  LabeledArray<float> laf{&m[0][0], 3, 4, {"r1", "r2", "r3"}, {"c1", "c2", "c3", "c4"}};
  Variant vlaf(laf);
  std::stringstream osl;
  VariantJSONHelpers::write(osl, vlaf);
 
  std::stringstream isl;
  isl.str(osl.str());
  auto vlafc = VariantJSONHelpers::read<VariantType::LabeledArrayFloat>(isl);
 
  for (auto i = 0u; i < vlafc.get<LabeledArray<float>>().rows(); ++i) {
    for (auto j = 0u; j < vlafc.get<LabeledArray<float>>().cols(); ++j) {
      REQUIRE(vlaf.get<LabeledArray<float>>().get(i, j) == vlafc.get<LabeledArray<float>>().get(i, j));
    }
  }
 
  std::string mS[3][4] = {{"a", "b", "c", "d"}, {"e", "f", "g", "h"}, {"i", "l", "m", "n"}};
  LabeledArray<std::string> las{&mS[0][0], 3, 4, {"r1", "r2", "r3"}, {"c1", "c2", "c3", "c4"}};
  Variant vms(las);
  std::stringstream ossl;
  VariantJSONHelpers::write(ossl, vms);
 
  std::stringstream issl;
  issl.str(ossl.str());
  auto vmsa = VariantJSONHelpers::read<VariantType::LabeledArrayString>(issl);
 
  for (auto i = 0U; i < vmsa.get<LabeledArray<std::string>>().rows(); ++i) {
    for (auto j = 0U; j < vmsa.get<LabeledArray<std::string>>().cols(); ++j) {
      REQUIRE(vmsa.get<LabeledArray<std::string>>().get(i, j) == vms.get<LabeledArray<std::string>>().get(i, j));
    }
  }
 
  std::vector<std::string> vstrings{"myoption_one", "myoption_two"};
  Variant vvstr(vstrings);
  REQUIRE(vvstr.size() == 2);
  std::stringstream osal;
  osal << vvstr;
 
  std::stringstream isal;
  isal.str(osal.str());
  auto vvstra = VariantJSONHelpers::read<VariantType::ArrayString>(isal);
 
  REQUIRE(vvstr.size() == vvstra.size());
  for (auto i = 0U; i < vstrings.size(); ++i) {
    REQUIRE(vstrings[i] == vvstra.get<std::string*>()[i]);
  }
}
 
TEST_CASE("VariantThrowing")
{
  Variant a("true");
  REQUIRE_THROWS_AS(a.get<int>(), o2::framework::RuntimeErrorRef);
  try {
    a.get<int>();
  } catch (RuntimeErrorRef& ref) {
    RuntimeError& error = error_from_ref(ref);
    REQUIRE(error.what == std::string("Variant::get: Mismatch between types 4 0."));
  }
}
 
// A Variant can be created from a vector only by copying its content
static_assert(!std::is_constructible_v<Variant, std::vector<int>>);
static_assert(!std::is_constructible_v<Variant, std::vector<float>>);
static_assert(!std::is_constructible_v<Variant, std::vector<double>>);
static_assert(!std::is_constructible_v<Variant, std::vector<bool>>);
static_assert(!std::is_constructible_v<Variant, std::vector<std::string>>);
// assignment from a temporary vector copies it
static_assert(std::is_assignable_v<Variant&, std::vector<int>>);
static_assert(std::is_assignable_v<Variant&, std::vector<std::string>>);
static_assert(std::is_constructible_v<Variant, std::vector<int>&>);
static_assert(std::is_constructible_v<Variant, std::vector<int> const&>);
static_assert(std::is_constructible_v<Variant, std::vector<std::string> const&>);
static_assert(std::is_assignable_v<Variant&, std::vector<int> const&>);
 
namespace
{
template <typename T>
void checkVectorCopy(VariantType type, std::vector<T> source)
{
  auto check = [&](Variant const& v, std::vector<T> const& from) {
    REQUIRE(v.type() == type);
    REQUIRE(v.size() == from.size());
    auto const* stored = v.get<T*>();
    REQUIRE(stored != from.data());
    for (auto i = 0U; i < from.size(); ++i) {
      REQUIRE(stored[i] == from[i]);
    }
  };
  std::vector<T> const constSource = source;
  Variant fromConst(constSource);
  check(fromConst, constSource);
 
  Variant fromMutable(source);
  check(fromMutable, source);
  // the Variant owns a copy, unaffected by later changes of the source
  auto const original = source;
  source[0] = source.back();
  source.push_back(source[0]);
  check(fromMutable, original);
}
} // namespace
 
TEST_CASE("VariantFromVectorTest")
{
  checkVectorCopy<int>(VariantType::ArrayInt, {1, 2, 3, 4});
  checkVectorCopy<float>(VariantType::ArrayFloat, {0.5f, 1.5f, 2.5f});
  checkVectorCopy<double>(VariantType::ArrayDouble, {1e-3, 1e3});
  checkVectorCopy<std::string>(VariantType::ArrayString, {"a", "bb", "ccc"});
 
  // assignment from a vector copies as well
  std::vector<int> vi{7, 8, 9};
  Variant v(1);
  v = vi;
  REQUIRE(v.type() == VariantType::ArrayInt);
  REQUIRE(v.size() == 3);
  REQUIRE(v.get<int*>() != vi.data());
  REQUIRE(v.get<int*>()[2] == 9);
  // also from a temporary
  auto makeStrings = []() { return std::vector<std::string>{"x", "y"}; };
  v = makeStrings();
  REQUIRE(v.type() == VariantType::ArrayString);
  REQUIRE(v.size() == 2);
  REQUIRE(v.get<std::string*>()[1] == "y");
  v = std::vector<double>{1.5, 2.5, 3.5};
  REQUIRE(v.type() == VariantType::ArrayDouble);
  REQUIRE(v.size() == 3);
  REQUIRE(v.get<double*>()[2] == 3.5);
 
  // a Variant created from a const vector round-trips through JSON
  std::vector<double> const vd{0.25, 0.5, 0.75};
  Variant vdv(vd);
  std::stringstream is(vdv.asString());
  auto read = VariantJSONHelpers::read<VariantType::ArrayDouble>(is);
  REQUIRE(read.size() == vd.size());
  for (auto i = 0U; i < vd.size(); ++i) {
    REQUIRE(read.get<double*>()[i] == vd[i]);
  }
}
 
namespace
{
template <VariantType V, typename T>
void checkLabeledArrayStringRoundTrip(LabeledArray<T> const& la)
{
  Variant v(la);
  auto str = v.asString();
  REQUIRE(str.find("undefined") == std::string::npos);
  std::stringstream is(str);
  auto vr = VariantJSONHelpers::read<V>(is);
  REQUIRE(vr.type() == V);
  auto lar = vr.template get<LabeledArray<T>>();
  REQUIRE(lar.rows() == la.rows());
  REQUIRE(lar.cols() == la.cols());
  REQUIRE(lar.getLabelsRows() == la.getLabelsRows());
  REQUIRE(lar.getLabelsCols() == la.getLabelsCols());
  for (auto i = 0U; i < la.rows(); ++i) {
    for (auto j = 0U; j < la.cols(); ++j) {
      REQUIRE(lar.get(i, j) == la.get(i, j));
    }
  }
}
} // namespace
 
TEST_CASE("LabeledArrayAsStringTest")
{
  int mi[2][2] = {{1, 2}, {3, 4}};
  float mf[2][3] = {{0.5, 0.25, 0.125}, {1, 2, 3}};
  double md[1][2] = {{1e-3, 1e10}};
  std::string ms[2][1] = {{"a"}, {"b c"}};
 
  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayInt>(LabeledArray<int>{&mi[0][0], 2, 2, {"r1", "r2"}, {"c1", "c2"}});
  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayFloat>(LabeledArray<float>{&mf[0][0], 2, 3, {"r1", "r2"}, {"c1", "c2", "c3"}});
  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayDouble>(LabeledArray<double>{&md[0][0], 1, 2, {"r1"}, {"c1", "c2"}});
  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayString>(LabeledArray<std::string>{&ms[0][0], 2, 1, {"r1", "r2"}, {"c1"}});
  // without labels
  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayInt>(LabeledArray<int>{&mi[0][0], 2, 2});
  // labels which need escaping in JSON
  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayFloat>(LabeledArray<float>{&mf[0][0], 2, 3, {"row \"one\"", "row\\two"}, {"c 1", "c,2", "c:3"}});
 
  Variant v(LabeledArray<int>{&mi[0][0], 2, 2, {"r1", "r2"}, {"c1", "c2"}});
  REQUIRE(v.asString() == R"({"labels_rows":["r1","r2"],"labels_cols":["c1","c2"],"values":[[1,2],[3,4]]})");
}