TestIntersection.cxx File Reference

#include <gtest/gtest.h>
#include <intersection.hxx>
#include <list>

Include dependency graph for TestIntersection.cxx:

Go to the source code of this file.

Functions
	TEST (TestIntersection, Intersections)

Function Documentation

TEST	(	TestIntersection	,
		Intersections
	)

Definition at line 48 of file TestIntersection.cxx.

{
  // Null intersection on empty vectors - empty intersection expected
  {
    const Container kEmptyEl = Container();
    auto intersection = Intersection<Container, Const_IT>
      (kEmptyEl.begin(), kEmptyEl.end(), kEmptyEl.begin(), kEmptyEl.end());
    EXPECT_EQ(0, intersection.size());
  }

  // Null intersection with one empty vector - empty intersection expected
  {
    const Container kEmptyEl = Container();
    const Container kCollection = Container(10,1);
    Container intersection = Intersection<Container, Const_IT>
      (kEmptyEl.begin(), kEmptyEl.end(), kCollection.begin(), kCollection.end());
    EXPECT_EQ(0, intersection.size());
  }

  // Basic run with same collection - intersection as the collection itself expected
  {
    const Container kSortedArray(SortedArrayInt, SortedArrayInt + sizeof(SortedArrayInt) / sizeof(Value));
    Container intersection = Intersection<Container, Const_IT>
      (kSortedArray.begin(), kSortedArray.end(), kSortedArray.begin(), kSortedArray.end());

    // The intersection of the same vector should return the same vector
    Const_IT kIntersectIt = intersection.begin();
    for (Const_IT it = kSortedArray.begin(); it != kSortedArray.end(); ++it, ++kIntersectIt)
      EXPECT_EQ(*it, *kIntersectIt);
  }

  // Basic run with same collection containing duplicates- intersection as the collection itself expected
  {
    const Container kFirstRandom(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(Value));
    const Container kSecondRandom(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(Value));

    Container intersection = Intersection<Container, Const_IT>
      (kFirstRandom.begin(), kFirstRandom.end(), kSecondRandom.begin(), kSecondRandom.end());

    // The intersection with the copy vector should return the same vector
    Const_IT kIntersectIt = intersection.begin();
    for (Const_IT it = kFirstRandom.begin(); it != kFirstRandom.end(); ++it, ++kIntersectIt)
      EXPECT_EQ(*it, *kIntersectIt);
  }

  // Basic run with normal values
  {
    const Container kFirstRandom(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(Value));
    const Container kSecondRandom
      (RandomArrayInterInt, RandomArrayInterInt + sizeof(RandomArrayInterInt) / sizeof(Value));

    Container intersection = Intersection<Container, Const_IT>
      (kFirstRandom.begin(), kFirstRandom.end(), kSecondRandom.begin(), kSecondRandom.end());

    // Should return [-18, -5, 3, 5, 5] after sorting
    std::sort(intersection.begin(), intersection.end());
    EXPECT_EQ(-18, intersection[0]);
    EXPECT_EQ(-5, intersection[1]);
    EXPECT_EQ(3, intersection[2]);
    EXPECT_EQ(5, intersection[3]);
    EXPECT_EQ(5, intersection[4]);
  }

  // String run
  {
    std::string intersection = Intersection<std::string, std::string::const_iterator>
      (OrderedStr.begin(), OrderedStr.end(), RandomStr.begin(), RandomStr.end());

    // Should return ['a', 'c', 'e', 'g'] after sorting
    std::sort(intersection.begin(), intersection.end());
    EXPECT_EQ('a', intersection[0]);
    EXPECT_EQ('c', intersection[1]);
    EXPECT_EQ('e', intersection[2]);
    EXPECT_EQ('g', intersection[3]);
  }
}