#ifndef TEMPLATE_VECTOR_STATIC_TESTS_HPP
#define TEMPLATE_VECTOR_STATIC_TESTS_HPP

#include "natch.hpp"
#include <cstddef>

NATCH_CREATE_CHECK(can_assign_element, val<Target> () [val_strict<std::size_t> ()] = {},
  "missing/invalid `Vector<T>::operator[] (size_t)`"
);

NATCH_CREATE_CHECK(can_access_element, const_val<Target> ()[val_strict<std::size_t> ()],
  "missing/invalid `Vector<T>::operator[] (size_t) const`"
);

NATCH_CREATE_CHECK(can_begin, *(val<Target> ().begin ()) = val<Target> ()[val<std::size_t> ()],
  "missing/invalid `Vector<T>::begin ()"
);

NATCH_CREATE_CHECK(can_begin_const, const_val<Target> ().begin (),
  "missing/invalid `Vector<T>::begin () const"
);

NATCH_CREATE_CHECK(can_end, *(val<Target> ().end ()) = val<Target> ()[val<std::size_t> ()],
  "missing/invalid `Vector<T>::end () "
);

NATCH_CREATE_CHECK(can_end_const, const_val<Target> ().end (),
  "missing/invalid `Vector<T>::end () const"
);

NATCH_CREATE_CHECK(can_find, const_val<Target> ().find ({}),
  "missing/invalid `Vector<T>::find () const"
);

NATCH_CREATE_CHECK(can_iterator, const_val<Target> ().find({}) == const_val<Target> ().begin () && const_val<Target> ().begin () == const_val<Target> ().end (),
  "iterators returned by `find`, `begin`, and `end` cannot be compared"
);

NATCH_CREATE_CHECK(can_clear, val<Target> ().clear (),
  "missing/invalid `Vector<T>::clear ()`"
);

NATCH_CREATE_CHECK(can_push_back, val<Target> ().push_back ({}),
  "missing/invalid `Vector<T>::push_back (T)`"
);

NATCH_CREATE_CHECK(can_insert, val<Target> ().insert (val_strict<std::size_t> (), {}),
  "missing/invalid `Vector<T>::insert (size_t, T)`"
);

NATCH_CREATE_CHECK(can_reset, val<Target> ().reset (),
  "missing/invalid `Vector<T>::reset ()`"
);

NATCH_CREATE_CHECK(can_size, const_val<Target> ().size (),
  "missing/invalid `Vector<T>::size () const`"
);

NATCH_CREATE_CHECK(can_capacity, const_val<Target> ().capacity (),
  "missing/invalid `Vector<T>::capacity () const`"
);

NATCH_CREATE_CHECK(can_copy_assign, val<Target> () = const_val<Target> (),
  "missing/invalid copy-assignment operator"
);

NATCH_CREATE_CHECK(can_move_assign, val<Target> () = std::move(val<Target> ()),
  "missing/invalid move-assignment operator"
);

NATCH_CREATE_CHECK(can_move_construct, Target (std::move (val<Target> ())),
  "missing/invalid move-constructor"
);

NATCH_CREATE_CHECK(can_copy_construct, Target (const_val<Target> ()),
  "missing/invalid copy-constructor"
);

NATCH_CREATE_CHECK(can_list_construct, Target ({{},{},{}}),
  "missing/invalid `Vector<T>::Vector (std::initializer_list<T>)`"
);

NATCH_CREATE_CHECK(can_size_construct, Target (val<std::size_t> ()),
  "missing/invalid `Vector<T>::Vector (std::size_t)`"
);

NATCH_CREATE_CHECK(can_size_value_construct, Target (val_strict<std::size_t> (), const_val<decltype (val<Target>()[val<std::size_t>()])> ()),
  "missing/invalid `Vector<T>`::Vector (std::size_t, T)`"
);

NATCH_CREATE_CHECK(can_default_construct, Target {},
  "missing/invalid default-constructor"
);

NATCH_CREATE_REVERSE_CHECK(not_possible_to_assign_to_const, const_val<Target> ()[val<std::size_t> ()] = const_val<Target> ()[val<std::size_t> ()],
  "const operator[] doesn't return reference to const"
);

NATCH_CREATE_REVERSE_CHECK(no_implicit_conversion_from_size_t, implicit_conversion (val<std::size_t, Target> ()),
  "`std:size_t` can implicitly be converted to `Vector<T>`"
);

NATCH_CREATE_REVERSE_CHECK(does_const_begin_return_const, *(const_val<Target> ().begin ()) = *(const_val<Target> ().begin ()),
  "`const_vec.begin ()` returns a type that refers to a non-const element"
);

NATCH_CREATE_REVERSE_CHECK(does_const_end_return_const, *(const_val<Target> ().end ()) = *(const_val<Target> ().end ()),
  "`const_vec.end ()` returns a type that refers to a non-const element"
);