TestSerialize.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
#include <gtest/gtest.h>
 
#include "arccore/serialize/BasicSerializer.h"
 
#include "arccore/base/Ref.h"
#include "arccore/base/FatalErrorException.h"
#include "arccore/base/ValueFiller.h"
#include "arccore/base/BasicDataType.h"
#include "arccore/base/Float128.h"
#include "arccore/base/Int128.h"
#include "arccore/common/NumArray.h"
#include "arccore/collections/Array2.h"
#include "arccore/serialize/SerializerExtension.h"
 
using namespace Arccore;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ISerializeValue
{
 public:
 
  virtual ~ISerializeValue() = default;
 
  virtual void serialize(ISerializer* s) = 0;
  virtual void checkValid() = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
namespace
{
using Float64 = Real;
template <typename T> class ValueTraits;
#define VALUE_TRAITS(type_name,basic_type_name) \
  template <> class ValueTraits<type_name> \
  { \
   public: \
\
    static eBasicDataType dataType() { return eBasicDataType::basic_type_name; } \
    static void getValue(ISerializer* s, type_name& v) { v = s->get##type_name(); } \
  };
 
#define VALUE_TRAITS2(type_name) VALUE_TRAITS(type_name,type_name)
 
VALUE_TRAITS2(Byte);
VALUE_TRAITS2(Int8);
VALUE_TRAITS2(Int16);
VALUE_TRAITS2(Int32)
VALUE_TRAITS2(Int64);
VALUE_TRAITS2(Float16);
VALUE_TRAITS2(Float32);
VALUE_TRAITS2(BFloat16);
VALUE_TRAITS(Real,Float64);
VALUE_TRAITS2(Float128);
VALUE_TRAITS2(Int128);
 
} // namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType>
class SerializeValue
: public ISerializeValue
{
  using ValueTraitsType = ValueTraits<DataType>;
 
 public:
 
  SerializeValue()
  : m_data_type(ValueTraitsType::dataType())
  {}
 
 public:
 
  void serialize(ISerializer* s) override
  {
    Int64 size = m_array_values.size();
    switch (s->mode()) {
    case ISerializer::ModeReserve:
      std::cout << "ReserveArray type=" << m_data_type << " size=" << m_array_values.size() << "\n";
      s->reserveArray(m_array_values);
      if (size > 0)
        s->reserve(m_data_type, 1);
      break;
    case ISerializer::ModePut:
      std::cout << "PutArray type=" << m_data_type << " size=" << m_array_values.size() << "\n";
      s->putArray(m_array_values);
      if (size > 0)
        s->put(m_array_values[0]);
      break;
    case ISerializer::ModeGet:
      s->getArray(m_result_array_values);
      if (size > 0)
        ValueTraitsType::getValue(s, m_unique_value);
    }
  }
 
  void checkValid() override
  {
    std::cout << "ref_size=" << m_array_values.size()
              << " result_size=" << m_result_array_values.size() << "\n";
    ASSERT_EQ(m_array_values, m_result_array_values);
    ASSERT_EQ(m_array_values[0], m_unique_value);
  }
 
  void resizeAndFill(Int32 size)
  {
    m_array_values.resize(size);
    ValueFiller::fillRandom(542, m_array_values.span());
  }
 
 public:
 
  UniqueArray<DataType> m_array_values;
  UniqueArray<DataType> m_result_array_values;
  DataType m_unique_value = {};
  eBasicDataType m_data_type = eBasicDataType::Unknown;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class StringSerializeValue
: public ISerializeValue
{
 public:
 
  explicit StringSerializeValue(const String& v)
  {
    m_ref_string.add(v);
  }
  explicit StringSerializeValue(Span<String> v)
  {
    m_ref_string.addRange(v);
  }
 
 public:
 
  void serialize(ISerializer* s) override
  {
    const Arcane::SerializerExtension se(s);
    Int64 size = m_ref_string.size();
    switch (s->mode()) {
    case ISerializer::ModeReserve:
      std::cout << "ReserveArray type=String size=" << m_ref_string.size() << "\n";
      se.reserveArray(m_ref_string);
      if (size > 0)
        s->reserve(m_ref_string[0]);
      break;
    case ISerializer::ModePut:
      std::cout << "PutArray type=String size=" << m_ref_string.size() << "\n";
      se.putArray(m_ref_string);
      if (size > 0)
        s->put(m_ref_string[0]);
      break;
    case ISerializer::ModeGet:
      se.getArray(m_result_string);
      if (size > 0)
        s->get(m_unique_value);
    }
  }
 
  void checkValid() override
  {
    std::cout << "ref_size=" << m_ref_string.size()
              << " result_size=" << m_result_string.size() << "\n";
    for (Integer i = 0; i < m_ref_string.size(); ++i) {
      // std::cout << m_ref_string[i] << " == " << m_result_string[i] << std::endl;
      ASSERT_EQ(m_ref_string[i], m_result_string[i]);
    }
    if (!m_ref_string.empty()) {
      // std::cout << m_ref_string[0] << " == " << m_unique_value << std::endl;
      ASSERT_EQ(m_ref_string[0], m_unique_value);
    }
  }
 
 public:
 
  UniqueArray<String> m_ref_string;
  UniqueArray<String> m_result_string;
  String m_unique_value;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType>
class Serialize2DValue
: public ISerializeValue
{
  using ValueTraitsType = ValueTraits<DataType>;
 
public:
 
  Serialize2DValue()
  : m_data_type(ValueTraitsType::dataType())
  {}
 
public:
 
  void serialize(ISerializer* s) override
  {
    const Arcane::SerializerExtension se(s);
    switch (s->mode()) {
    case ISerializer::ModeReserve:
      std::cout << "ReserveArray type=" << m_data_type << " size1=" << m_array_values.dim1Size() << " size2=" << m_array_values.dim2Size() << "\n";
      se.reserveArray(m_array_values.constSpan());
      break;
    case ISerializer::ModePut:
      std::cout << "PutArray type=" << m_data_type << " size1=" << m_array_values.dim1Size() << " size2=" << m_array_values.dim2Size() << "\n";
      se.putArray(m_array_values.constSpan());
      break;
    case ISerializer::ModeGet:
      se.getArray(m_result_array_values);
    }
  }
 
  void checkValid() override
  {
    std::cout << "ref_size1=" << m_array_values.dim1Size()
              << " ref_size2=" << m_array_values.dim2Size()
              << " result_size1=" << m_result_array_values.dim1Size()
              << " result_size2=" << m_result_array_values.dim2Size() << "\n";
    for (Int32 i = 0; i < m_array_values.dim1Size(); ++i) {
      ASSERT_EQ(m_array_values[i], m_result_array_values[i]);
    }
  }
 
  void resizeAndFill(Int32 size1, Int32 size2)
  {
    m_array_values.resize(size1, size2);
    ValueFiller::fillRandom(542, m_array_values.to1DSpan());
  }
 
public:
 
  UniqueArray2<DataType> m_array_values;
  UniqueArray2<DataType> m_result_array_values;
  eBasicDataType m_data_type = eBasicDataType::Unknown;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType, typename Extents>
class MDSerializeValue
: public ISerializeValue
{
  using ValueTraitsType = ValueTraits<DataType>;
 
 public:
 
  MDSerializeValue()
  : m_data_type(ValueTraitsType::dataType())
  {}
 
 public:
 
  void serialize(ISerializer* s) override
  {
    const Arcane::SerializerExtension se(s);
    switch (s->mode()) {
    case ISerializer::ModeReserve:
      std::cout << "ReserveArray type=" << m_data_type << " dim=" << Extents::rank() << " total_size=" << m_array_values.totalNbElement() << "\n";
      se.reserveArray(m_array_values.constSpan());
      break;
    case ISerializer::ModePut:
      std::cout << "PutArray type=" << m_data_type << " dim=" << Extents::rank() << " total_size=" << m_array_values.totalNbElement() << "\n";
      se.putArray(m_array_values.constSpan());
      break;
    case ISerializer::ModeGet:
      se.getArray(m_result_array_values);
    }
  }
 
  void checkValid() override
  {
    std::cout << "ref_size=" << m_array_values.totalNbElement()
          << " result_size=" << m_result_array_values.totalNbElement() << "\n";
    //TODO : Vérifier les dimensions.
    ASSERT_EQ(m_array_values.to1DSpan(), m_result_array_values.to1DSpan());
  }
 
  void resizeAndFill(Arcane::MDIndex<Extents::rank(), typename Extents::ExtentIndexType> size)
  {
    m_array_values.resize(size);
    ValueFiller::fillRandom(542, m_array_values.to1DSpan());
  }
 
 public:
 
  Arcane::NumArray<DataType, Extents> m_array_values;
  Arcane::NumArray<DataType, Extents> m_result_array_values;
  eBasicDataType m_data_type = eBasicDataType::Unknown;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class SerializeValueList
{
 public:
 
  ~SerializeValueList()
  {
    for (ISerializeValue* v : m_values)
      delete v;
  }
  void doSerialize(ISerializer* s)
  {
    for (ISerializeValue* v : m_values)
      v->serialize(s);
  }
  void checkValid()
  {
    for (ISerializeValue* v : m_values)
      v->checkValid();
  }
 
  template <typename DataType>
  void add(Int32 size)
  {
    auto* sval = new SerializeValue<DataType>();
    sval->resizeAndFill(size);
    m_values.add(sval);
  }
  void addString(const String& v)
  {
    m_values.add(new StringSerializeValue(v));
  }
 
  void addString(Span<String> v)
  {
    m_values.add(new StringSerializeValue(v));
  }
 
  template <typename DataType>
  void add(Int32 size1, Int32 size2)
  {
    auto* sval = new Serialize2DValue<DataType>();
    sval->resizeAndFill(size1, size2);
    m_values.add(sval);
  }
 
  template <typename DataType, typename Extents>
  void add(Arcane::MDIndex<Extents::rank(), typename Extents::ExtentIndexType> size)
  {
    auto* sval = new MDSerializeValue<DataType, Extents>();
    sval->resizeAndFill(size);
    m_values.add(sval);
  }
 
 public:
 
  UniqueArray<ISerializeValue*> m_values;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void _doMisc()
{
  Ref<ISerializer> serializer_ref = createSerializer();
  ISerializer* serializer = serializer_ref.get();
 
  SerializeValueList values;
 
  values.add<Float16>(12679);
  values.add<BFloat16>(3212);
  values.add<Int8>(6357);
  values.add<Float32>(983);
  values.add<Int16>(16353);
  values.add<Real>(29123);
  values.add<Int32>(16);
  values.add<Byte>(3289);
  values.add<Int64>(12932);
  values.add<Float128>(19328);
  values.add<Int128>(32422);
 
  values.addString("Ceci est un test de chaîne de caractères");
  values.addString(UniqueArray<String>({ "Ceci", "est", "un", "test", "de", "chaîne", "de", "caractères" }));
 
  values.add<Real>(29, 123);
  values.add<Int32>(16, 23);
 
  values.add<Float16, Arcane::MDDim1>(125);
  values.add<BFloat16, Arcane::MDDim2>({ 51, 21 });
  values.add<Int8, Arcane::MDDim3>({ 12, 9, 45 });
  values.add<Float32, Arcane::MDDim4>({ 14, 45, 1, 4 });
  values.add<Int16, Arcane::MDDim1>(15);
  values.add<Real, Arcane::MDDim2>({ 84, 31 });
  values.add<Int32, Arcane::MDDim3>({ 25, 19, 41 });
  values.add<Byte, Arcane::MDDim4>({ 12, 17, 26, 4 });
  values.add<Int64, Arcane::MDDim1>(18);
  values.add<Float128, Arcane::MDDim2>({ 41, 48 });
 
  serializer->setMode(ISerializer::ModeReserve);
  values.doSerialize(serializer);
  serializer->allocateBuffer();
  serializer->setMode(ISerializer::ModePut);
  values.doSerialize(serializer);
  serializer->setMode(ISerializer::ModeGet);
  values.doSerialize(serializer);
 
  values.checkValid();
}
 
TEST(Serialize, Misc)
{
  try {
    _doMisc();
  }
  catch (const Exception& e) {
    e.write(std::cerr);
    throw;
  }
}