overeloadされたoperator->をテストする方法

Question

イテレータのようなクラスを作るときにoperator->(arrow operator)をoverloadすると思うのですが、この挙動をunit testするとしたらどのようにすればいいのでしょうか？

一般的なテストの書き方があれは教えてください。

    template<typename Container>
    class contiguous_iterator {
    private:
        using container_type = std::remove_reference_t<Container>;
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = typename container_type::value_type;
        using difference_type = typename container_type::difference_type;
        using pointer = std::conditional_t<std::is_const<container_type>::value, typename container_type::const_pointer, typename container_type::pointer>;
        using reference = std::conditional_t<std::is_const<container_type>::value, typename container_type::const_reference, typename container_type::reference>;
    private:
        pointer pointer_;
    public:
        contiguous_iterator() = delete;
        contiguous_iterator(const contiguous_iterator&) = default;
        contiguous_iterator(contiguous_iterator&&) = default;
        contiguous_iterator& operator=(const contiguous_iterator&) = default;
        contiguous_iterator& operator=(contiguous_iterator&&) = default;

        constexpr contiguous_iterator(pointer p) noexcept;

        constexpr pointer ptr() const noexcept;
        constexpr contiguous_iterator next() const noexcept;
        constexpr contiguous_iterator prev() const noexcept;
        constexpr reference operator*() const noexcept;
        constexpr pointer operator->() const noexcept;
        //以下省略
    };

Comments

[yohhoy]

何か operator-> 固有の懸念事項があるのでしょうか？

[yumetodo]

ええっと、value_typeがクラス型でメンバーを呼び出すのに使う演算子なので、テストのときにどんなクラス型を用いてどんなことを確認するべきか、ベストプラクティスのようなものはないかというのが質問の意図です

Answer 1

（自分だったらこうするかもという程度の回答です）

身も蓋もない回答ですが、いわゆる成功テストであれば operator-> を直接呼び出せば良いと思います。同オーバーロードが itr->mf() 構文から呼び出されることはC++言語仕様が保証する話ですから、テスト対象の戻り値つまりポインタ値を確認すれば十分という考え方です。

#include <cassert>
#include <array>

template <typename C>
class fake_iterator {
public:
  using pointer = typename C::pointer;
  using reference = typename C::reference;

  fake_iterator(pointer p) : p_(p) {}
  reference operator*() const { return *p_; }
  pointer operator->() const { return p_; }
private:
  pointer p_;
};


int main()
{
  std::array<int, 1> a = { 42 };
  fake_iterator<decltype(a)> itr(a.begin());
  
  assert(&(itr.operator*()) == itr.operator->());
  assert(&a[0] == itr.operator->());
}

Comments

[yumetodo]

>身も蓋もない回答ですが

やっぱりそうなりますか・・・。ありがとうございます。

Answer 2

こんにちは。

回答依頼を頂いたので来てみたのですが、ごめんなさい。よく分からんです。
テンプレートの単体テストって対応するクラスを限定しないときりが無さそうな気もします。
実使用状況を想定して、クラスを限定するしかないかも。
「このくらいやっておけば結構カバーできる」というようなセットがあるとよいのですが。