cpp-engine/test/universe_test.cxx

//
//  universe_test.cxx
//  pokemon_test_xc
//
//  Created by Sam Jaffe on 1/12/19.
//  Copyright © 2019 Sam Jaffe. All rights reserved.
//

#include <engine/universe.h>

#include <map>

#include <engine/universe.tpp>
#include <serializer/jsonizer.tpp>
#include <serializer/shared_cache.h>

#include "stub_config.h"
#include "xcode_gtest_helper.h"

using testing::Eq;
using testing::NotNull;
using testing::TestWithParam;
using testing::Values;

struct Object {
  std::string name;
  std::map<std::string, int> data;
};

template <>
void serializer::Jsonizer::from_json(Object & value,
                                     Json::Value const & json) const {
  from_json(value.name, json["name"]);
  from_json(value.data, json["data"]);
}

struct SharedCache : serializer::SharedCache {
  struct Impl : serializer::SharedCache::Impl {
    std::map<SharedCache::Key, SharedCache::Record<Object>> objects_;
  };

  SharedCache() : serializer::SharedCache(std::make_unique<Impl>()) {}
};

#define IMPL() dynamic_cast<::SharedCache::Impl &>(*p_impl)

template <>
SharedCache::Record<Object>
serializer::SharedCache::store<Object>(Key const & key, Object const & value) {
  auto & ptr = IMPL().objects_[key];
  if (!ptr) { ptr = std::make_shared<Object>(value); }
  return ptr;
}

template <>
SharedCache::Record<Object>
serializer::SharedCache::fetch<Object>(Key const & key) const {
  return IMPL().objects_[key];
}

struct Universe : engine::Universe {
  Universe(std::filesystem::path const & cfg)
      : engine::Universe(nullptr, Config::from_dir(cfg),
                         std::make_shared<SharedCache>(), nullptr) {
    load<Object>("object");
  }

  auto read(std::string const & name) const {
    return jsonizer().from_json<SharedCache::Record<Object>>(name);
  }
};

TEST(UniverseTest, CanLoadFromFile) {
  Universe const univ("universe_test/1");
  auto const ptr = univ.read("A");

  EXPECT_THAT(ptr, NotNull());
}

class PreloadTest : public TestWithParam<std::string> {};

TEST_P(PreloadTest, CanLoadFromDirectory) {
  Universe const univ("universe_test/2");
  auto const ptr = univ.read(GetParam());

  EXPECT_THAT(ptr, NotNull());
  EXPECT_THAT(ptr->name, GetParam());
}

TEST_P(PreloadTest, CanLoadFromArrayFile) {
  Universe const univ("universe_test/3");
  auto const ptr = univ.read(GetParam());

  EXPECT_THAT(ptr, NotNull());
  EXPECT_THAT(ptr->name, GetParam());
}

INSTANTIATE_TEST_SUITE_P(Universe, PreloadTest, Values("A", "B"));