archivist_unittests.cc

Go to the documentation of this file.

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#include <cstdio>
#include <thread>
 
#include "flutter/fml/macros.h"
#include "flutter/testing/testing.h"
#include "impeller/archivist/archive.h"
#include "impeller/archivist/archive_location.h"
#include "impeller/archivist/archivist_fixture.h"
 
// TODO(zanderso): https://github.com/flutter/flutter/issues/127701
// NOLINTBEGIN(bugprone-unchecked-optional-access)
 
namespace impeller {
namespace testing {
 
static int64_t LastSample = 0;
 
class Sample : public Archivable {
 public:
  explicit Sample(uint64_t count = 42) : some_data_(count) {}
 
  Sample(Sample&&) = default;
 
  uint64_t GetSomeData() const { return some_data_; }
 
  // |Archivable|
  PrimaryKey GetPrimaryKey() const override { return name_; }
 
  // |Archivable|
  bool Write(ArchiveLocation& item) const override {
    return item.Write("some_data", some_data_);
  };
 
  // |Archivable|
  bool Read(ArchiveLocation& item) override {
    name_ = item.GetPrimaryKey();
    return item.Read("some_data", some_data_);
  };
 
  static const ArchiveDef kArchiveDefinition;
 
 private:
  uint64_t some_data_;
  PrimaryKey name_ = ++LastSample;
 
  Sample(const Sample&) = delete;
 
  Sample& operator=(const Sample&) = delete;
};
 
const ArchiveDef Sample::kArchiveDefinition = {
    .table_name = "Sample",
    .members = {"some_data"},
};
 
class SampleWithVector : public Archivable {
 public:
  SampleWithVector() = default;
 
  // |Archivable|
  PrimaryKey GetPrimaryKey() const override { return std::nullopt; }
 
  // |Archivable|
  bool Write(ArchiveLocation& item) const override {
    std::vector<Sample> samples;
    for (size_t i = 0; i < 50u; i++) {
      samples.emplace_back(Sample{1988 + i});
    }
    return item.Write("hello", "world") && item.Write("samples", samples);
  };
 
  // |Archivable|
  bool Read(ArchiveLocation& item) override {
    std::string str;
    auto str_result = item.Read("hello", str);
    std::vector<Sample> samples;
    auto vec_result = item.Read("samples", samples);
 
    if (!str_result || str != "world" || !vec_result || samples.size() != 50) {
      return false;
    }
 
    size_t current = 1988;
    for (const auto& sample : samples) {
      if (sample.GetSomeData() != current++) {
        return false;
      }
    }
    return true;
  };
 
  static const ArchiveDef kArchiveDefinition;
 
 private:
  std::vector<Sample> samples_;
  SampleWithVector(const SampleWithVector&) = delete;
 
  SampleWithVector& operator=(const SampleWithVector&) = delete;
};
 
const ArchiveDef SampleWithVector::kArchiveDefinition = {
    .table_name = "SampleWithVector",
    .members = {"hello", "samples"},
};
 
using ArchiveTest = ArchivistFixture;
 
TEST_F(ArchiveTest, SimpleInitialization) {
  Archive archive(GetArchiveFileName().c_str());
  ASSERT_TRUE(archive.IsValid());
}
 
TEST_F(ArchiveTest, AddStorageClass) {
  Archive archive(GetArchiveFileName().c_str());
  ASSERT_TRUE(archive.IsValid());
}
 
TEST_F(ArchiveTest, AddData) {
  Archive archive(GetArchiveFileName().c_str());
  ASSERT_TRUE(archive.IsValid());
  Sample sample;
  ASSERT_TRUE(archive.Write(sample));
}
 
TEST_F(ArchiveTest, AddDataMultiple) {
  Archive archive(GetArchiveFileName().c_str());
  ASSERT_TRUE(archive.IsValid());
 
  for (size_t i = 0; i < 100; i++) {
    Sample sample(i + 1);
    ASSERT_TRUE(archive.Write(sample));
  }
}
 
TEST_F(ArchiveTest, ReadData) {
  Archive archive(GetArchiveFileName().c_str());
  ASSERT_TRUE(archive.IsValid());
 
  size_t count = 50;
 
  std::vector<PrimaryKey::value_type> keys;
  std::vector<uint64_t> values;
 
  for (size_t i = 0; i < count; i++) {
    Sample sample(i + 1);
    keys.push_back(sample.GetPrimaryKey().value());
    values.push_back(sample.GetSomeData());
    ASSERT_TRUE(archive.Write(sample));
  }
 
  for (size_t i = 0; i < count; i++) {
    Sample sample;
    ASSERT_TRUE(archive.Read(keys[i], sample));
    ASSERT_EQ(values[i], sample.GetSomeData());
  }
}
 
TEST_F(ArchiveTest, ReadDataWithNames) {
  Archive archive(GetArchiveFileName().c_str());
  ASSERT_TRUE(archive.IsValid());
 
  size_t count = 8;
 
  std::vector<PrimaryKey::value_type> keys;
  std::vector<uint64_t> values;
 
  keys.reserve(count);
  values.reserve(count);
 
  for (size_t i = 0; i < count; i++) {
    Sample sample(i + 1);
    keys.push_back(sample.GetPrimaryKey().value());
    values.push_back(sample.GetSomeData());
    ASSERT_TRUE(archive.Write(sample));
  }
 
  for (size_t i = 0; i < count; i++) {
    Sample sample;
    ASSERT_TRUE(archive.Read(keys[i], sample));
    ASSERT_EQ(values[i], sample.GetSomeData());
    ASSERT_EQ(keys[i], sample.GetPrimaryKey());
  }
}
 
TEST_F(ArchiveTest, CanReadWriteVectorOfArchivables) {
  Archive archive(GetArchiveFileName().c_str());
  ASSERT_TRUE(archive.IsValid());
 
  SampleWithVector sample_with_vector;
  ASSERT_TRUE(archive.Write(sample_with_vector));
  bool read_success = false;
  ASSERT_EQ(
      archive.Read<SampleWithVector>([&](ArchiveLocation& location) -> bool {
        SampleWithVector other_sample_with_vector;
        read_success = other_sample_with_vector.Read(location);
        return true;  // Always keep continuing but assert that we only get one.
      }),
      1u);
  ASSERT_TRUE(read_success);
}
 
}  // namespace testing
}  // namespace impeller
 
// NOLINTEND(bugprone-unchecked-optional-access)