cpp-bucket-hash/bucket_hash_set.t.h

//
//  bucket_hash_set.t.h
//  bucket_hash_map
//
//  Created by Sam Jaffe on 2/17/17.
//

#pragma once
#include <cxxtest/TestSuite.h>

#include "bucket_hash_set.hpp"

class bucket_hash_set_TestSuite : public CxxTest::TestSuite {
public:
  using hashset = bucket_hash_set<int>;
public:
  // Construction Postconditions
  void test_default_is_empty() {
    TS_ASSERT( hashset{}.empty() );
  }
  
  void test_construct_from_initializer_list() {
    hashset hm{0, 1, 2};
    TS_ASSERT_EQUALS(hm.size(), 3);
  }
  
  void test_swap_hashsets() {
    hashset hm1{};
    hashset hm2{0, 1, 2};
    swap(hm1, hm2);
    TS_ASSERT(hm2.empty());
    TS_ASSERT_EQUALS(hm1.size(), 3);
  }
  
  // Insertion Behaviors
  void test_insert_elements_effects_size() {
    hashset hm{};
    TS_ASSERT_THROWS_NOTHING( hm.insert(0) );
    TS_ASSERT_EQUALS(hm.size(), 1);
  }
  
  void test_insert_element_return_true() {
    hashset hm{};
    TS_ASSERT( hm.insert(0).second );
  }
  
  void test_insert_element_return_iterator_to_elements() {
    hashset hm{};
    auto it = hm.insert(0).first;
    TS_ASSERT_EQUALS( *it, 0 );
  }
  
  void test_insert_same_element_does_not_create_duplicate() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_THROWS_NOTHING( hm.insert(0) );
    TS_ASSERT_EQUALS(hm.size(), 1);
  }
  
  void test_insert_same_element_returns_false() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT( !hm.insert(0).second );
  }
  
  void test_insert_same_element_return_same_iterator() {
    hashset hm{};
    auto it = hm.insert(0).first;
    TS_ASSERT_EQUALS(hm.insert(0).first, it);
  }
  
  void test_can_insert_range() {
    hashset hm{};
    TS_ASSERT_THROWS_NOTHING(hm.insert({0, 0, 1}));
  }
  
  // Find/Access Behaviors
  void test_can_find_element_in_map() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_DIFFERS(hm.find(0), hm.end());
  }
  
  void test_count_element_in_map() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_EQUALS(hm.count(0), 1);
  }
  
  void test_count_element_not_in_map() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_EQUALS(hm.count(1), 0);
  }
  
  void test_equal_range_contains_element_if_present() {
    hashset hm{};
    hm.insert(0);
    auto p = hm.equal_range(0);
    TS_ASSERT_DIFFERS(p.first, p.second);
    TS_ASSERT_EQUALS(std::distance(p.first, p.second), 1);
  }
  
  void test_equal_range_contains_end_if_absent() {
    hashset hm{};
    hm.insert(0);
    auto p = hm.equal_range(1);
    TS_ASSERT_EQUALS(p.first, p.second);
    TS_ASSERT_EQUALS(p.first, hm.end());
  }
  
  void test_found_element_is_as_expected() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_EQUALS(*hm.find(0), 0);
  }
  
  void test_cannot_find_fake_element() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_EQUALS(hm.find(1), hm.end());
  }
    
  // Iteration Behaviors
  void test_iterator_advance_different() {
    hashset hm{};
    hm.insert(0);
    hm.insert(1);
    auto it = hm.begin();
    auto it2 = ++hm.begin();
    TS_ASSERT_DIFFERS(*it, *it2);
  }
  
  void test_iterator_begin_is_end_if_empty() { // Test case in join iterator for empty first element
    hashset hm{};
    TS_ASSERT_EQUALS(hm.begin(), hm.end());
  }
  
  void test_iterator_reaches_end() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_EQUALS(++hm.begin(), hm.end());
  }
  
  // Erase Behaviors
  void test_erasing_element_reduces_size() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_THROWS_NOTHING( hm.erase(hm.find(0)) );
    TS_ASSERT_EQUALS(hm.size(), 0);
  }
  
  void test_erase_end_is_fine() {
    hashset hm{};
    TS_ASSERT_THROWS_NOTHING(hm.erase(hm.end()));
    hm.insert(0);
    TS_ASSERT_THROWS_NOTHING(hm.erase(hm.end()));
  }
  
  void test_erase_end_does_not_effect_size() {
    hashset hm{};
    hm.insert(0);
    hm.erase(hm.end());
    TS_ASSERT_EQUALS(hm.size(), 1);
  }
  
  void test_erase_end_returns_end() {
    hashset hm{};
    TS_ASSERT_EQUALS(hm.erase(hm.end()), hm.end());
  }
  
  void test_erase_key_missing_key_no_result() {
    hashset hm{};
    TS_ASSERT_EQUALS(hm.erase(0), 0);
  }
  
  void test_erase_key_incorrect_key_no_result() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_EQUALS(hm.erase(1), 0);
  }
  
  void test_erase_key_correct_key_one() {
    hashset hm{};
    hm.insert(0);
    TS_ASSERT_EQUALS(hm.erase(0), 1);
  }
  
  void test_erase_range() {
    hashset hm{0, 1, 2};
    auto it = hm.begin();
    auto it2 = it;
    std::advance(it2, 2);
    TS_ASSERT_THROWS_NOTHING(hm.erase(it, it2));
    TS_ASSERT_EQUALS(hm.size(), 1);
  }
  
  void test_clear() {
    hashset hm{0, 1, 2};
    TS_ASSERT_THROWS_NOTHING(hm.clear());
    TS_ASSERT(hm.empty());
  }
  
  void test_resize_not_destructive() {
    hashset hm{0, 1, 2, 3, 4, 5};
    hashset const copy{hm};
    hm.reserve(6);
    TS_ASSERT_EQUALS(hm, copy);
  }
};