tests/fill.test.cpp

• View this file on GitHub
• Last update: 2025-01-25 08:45:50+09:00

Depends on

• Assertion macro (tools/assert_that.hpp)
• Fill a multi-dimensional vector (tools/fill.hpp)
• Check whether T is a range type (tools/is_range.hpp)

Code

// competitive-verifier: STANDALONE

#include <cstdlib>
#include <iostream>
#include <vector>
#include <array>
#include "tools/assert_that.hpp"
#include "tools/fill.hpp"

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);

  {
    auto v = std::vector(3, std::vector(4, std::vector<int>(5)));
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    auto v = std::vector(3, std::vector(4, std::vector<int>(0)));
    tools::fill(v, 6);
  }

  {
    auto v = std::vector<int>(3);
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      assert_that(v[i] == 6);
    }
  }

  {
    auto v = std::vector<int>(0);
    tools::fill(v, 6);
  }

  {
    std::array<std::vector<std::vector<int>>, 3> v;
    for (int i = 0; i < 3; ++i) {
      v[i].resize(4);
      for (int j = 0; j < 4; ++j) {
        v[i][j].resize(5);
      }
    }
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    std::vector<std::array<std::vector<int>, 4>> v;
    v.resize(3);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        v[i][j].resize(5);
      }
    }
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    std::vector<std::vector<std::array<int, 5>>> v;
    v.resize(3);
    for (int i = 0; i < 3; ++i) {
      v[i].resize(4);
    }
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    std::array<std::array<std::array<int, 5>, 4>, 3> v;
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    std::array<int, 3> v;
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      assert_that(v[i] == 6);
    }
  }

  return 0;
}

#line 1 "tests/fill.test.cpp"
// competitive-verifier: STANDALONE

#include <cstdlib>
#include <iostream>
#include <vector>
#include <array>
#line 1 "tools/assert_that.hpp"



#line 6 "tools/assert_that.hpp"

#define assert_that_impl(cond, file, line, func) do {\
  if (!cond) {\
    ::std::cerr << file << ':' << line << ": " << func << ": Assertion `" << #cond << "' failed." << '\n';\
    ::std::exit(EXIT_FAILURE);\
  }\
} while (false)
#define assert_that(...) assert_that_impl((__VA_ARGS__), __FILE__, __LINE__, __func__)


#line 1 "tools/fill.hpp"



#include <type_traits>
#line 6 "tools/fill.hpp"
#include <algorithm>
#include <iterator>
#include <cstddef>
#line 1 "tools/is_range.hpp"



#line 6 "tools/is_range.hpp"
#include <utility>

namespace tools {
  template <typename T, typename = ::std::void_t<>>
  struct is_range : ::std::false_type {};

  template <typename T>
  struct is_range<T, ::std::void_t<decltype(::std::begin(::std::declval<T>()), ::std::end(::std::declval<T>()))>> : ::std::true_type {};

  template <typename T>
  inline constexpr bool is_range_v = ::tools::is_range<T>::value;
}


#line 11 "tools/fill.hpp"

namespace tools {
  template <class T, class Allocator, typename V>
  ::std::enable_if_t<!::tools::is_range_v<T>, void> fill(::std::vector<T, Allocator>& vector, const V& value) {
    ::std::fill(::std::begin(vector), ::std::end(vector), value);
  }
  template <class T, ::std::size_t N, typename V>
  ::std::enable_if_t<!::tools::is_range_v<T>, void> fill(::std::array<T, N>& array, const V& value) {
    ::std::fill(::std::begin(array), ::std::end(array), value);
  }

  template <class T, class Allocator, typename V>
  ::std::enable_if_t<::tools::is_range_v<T>, void> fill(::std::vector<T, Allocator>& vector, const V& value);
  template <class T, ::std::size_t N, typename V>
  ::std::enable_if_t<::tools::is_range_v<T>, void> fill(::std::array<T, N>& array, const V& value);

  template <class T, class Allocator, typename V>
  ::std::enable_if_t<::tools::is_range_v<T>, void> fill(::std::vector<T, Allocator>& vector, const V& value) {
    for (auto& child : vector) {
      ::tools::fill(child, value);
    }
  }
  template <class T, ::std::size_t N, typename V>
  ::std::enable_if_t<::tools::is_range_v<T>, void> fill(::std::array<T, N>& array, const V& value) {
    for (auto& child : array) {
      ::tools::fill(child, value);
    }
  }
}


#line 9 "tests/fill.test.cpp"

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);

  {
    auto v = std::vector(3, std::vector(4, std::vector<int>(5)));
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    auto v = std::vector(3, std::vector(4, std::vector<int>(0)));
    tools::fill(v, 6);
  }

  {
    auto v = std::vector<int>(3);
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      assert_that(v[i] == 6);
    }
  }

  {
    auto v = std::vector<int>(0);
    tools::fill(v, 6);
  }

  {
    std::array<std::vector<std::vector<int>>, 3> v;
    for (int i = 0; i < 3; ++i) {
      v[i].resize(4);
      for (int j = 0; j < 4; ++j) {
        v[i][j].resize(5);
      }
    }
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    std::vector<std::array<std::vector<int>, 4>> v;
    v.resize(3);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        v[i][j].resize(5);
      }
    }
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    std::vector<std::vector<std::array<int, 5>>> v;
    v.resize(3);
    for (int i = 0; i < 3; ++i) {
      v[i].resize(4);
    }
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    std::array<std::array<std::array<int, 5>, 4>, 3> v;
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 5; ++k) {
          assert_that(v[i][j][k] == 6);
        }
      }
    }
  }

  {
    std::array<int, 3> v;
    tools::fill(v, 6);
    for (int i = 0; i < 3; ++i) {
      assert_that(v[i] == 6);
    }
  }

  return 0;
}

Back to top page