TestMerge.cxx File Reference

#include <gtest/gtest.h>
#include <merge.hxx>
#include <functional>
#include <vector>
#include <string>

Include dependency graph for TestMerge.cxx:

Go to the source code of this file.

Functions
	TEST (TestMerge, MergeInPlaces)
	TEST (TestMerge, MergeWithBuffers)
	TEST (TestMerge, MergeSorts)

Function Documentation

TEST	(	TestMerge	,
		MergeInPlaces
	)

Definition at line 50 of file TestMerge.cxx.

{
  // Normal Run - All elements should be sorted in order
  {
    Container vector(ArraySortWithRot);
    MergeInPlace<IT>()(vector.begin(), vector.begin() + 4, vector.end());

    // All elements of the final array are sorted
    for (auto it = vector.begin(); it < vector.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }

  // Already SortArray - Array should not be affected
  {
    Container vector(ArraySortU);
    MergeInPlace<IT>()(vector.begin(), vector.begin() + 5, vector.end());

    // All elements are still sorted
    for (auto it = vector.begin(); it < vector.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }

  // Inverse iterator order - Array should not be affected
  {
    Container vector(ArrayRandU);
    MergeInPlace<IT>()(vector.end(), vector.begin() + 3, vector.begin());

    int i = 0;
    for (auto it = vector.begin(); it < vector.end(); ++it, ++i)
      EXPECT_EQ(ArrayRandU[i], *it);
  }

  // No error empty array
  {
    Container emptyArray;
    MergeInPlace<IT>()(emptyArray.begin(), emptyArray.begin(), emptyArray.end());
  }

  // Unique value array - Array should not be affected
  {
    Container uniqueValueArray(1, 511);
    MergeInPlace<IT>()(uniqueValueArray.begin(), uniqueValueArray.end(), uniqueValueArray.end());
    EXPECT_EQ(511, uniqueValueArray[0]);
  }

  // Double values array - Order should be made
  {
    Container doubleValues(1, 511);
    doubleValues.push_back(66);

    MergeInPlace<IT>()(doubleValues.begin(), doubleValues.begin() + 1, doubleValues.end());

    EXPECT_EQ(66, doubleValues[0]);
    EXPECT_EQ(511, doubleValues[1]);
  }

  // String Collection - All elements should be sorted in order
  {
    std::string str = StrRandPivot;
    MergeInPlace<std::string::iterator>()(str.begin(), str.begin() + 4, str.end());

    // All elements of the final array are sorted
    for (auto it = str.begin(); it < str.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }
}

TEST	(	TestMerge	,
		MergeWithBuffers
	)

Definition at line 119 of file TestMerge.cxx.

{
  // Normal Run - All elements should be sorted in order
  {
    Container vector(ArraySortWithRot);
    MergeWithBuffer<IT>()(vector.begin(), vector.begin() + 4, vector.end());

    // All elements of the final array are sorted
    for (auto it = vector.begin(); it < vector.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }

  // Already SortArray - Array should not be affected
  {
    Container vector(ArraySortU);
    MergeWithBuffer<IT>()(vector.begin(), vector.begin() + 5, vector.end());

    // All elements are still sorted
    for (auto it = vector.begin(); it < vector.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }

  // Inverse iterator order - Array should not be affected
  {
    Container vector(ArrayRandU);
    MergeWithBuffer<IT>()(vector.end(), vector.begin() + 3, vector.begin());

    int i = 0;
    for (auto it = vector.begin(); it < vector.end(); ++it, ++i)
      EXPECT_EQ(ArrayRandU[i], *it);
  }

  // No error empty array
  {
    Container emptyArray;
    MergeWithBuffer<IT>()(emptyArray.begin(), emptyArray.begin(), emptyArray.end());
  }

  // Unique value array - Array should not be affected
  {
    Container uniqueValueArray(1, 511);
    MergeWithBuffer<IT>()(uniqueValueArray.begin(), uniqueValueArray.end(), uniqueValueArray.end());
    EXPECT_EQ(511, uniqueValueArray[0]);
  }

  // Double values array - Order should be made
  {
    Container doubleValuesArray(1, 511);
    doubleValuesArray.push_back(66);

    MergeWithBuffer<IT>()(doubleValuesArray.begin(), doubleValuesArray.begin() + 1, doubleValuesArray.end());

    EXPECT_EQ(66, doubleValuesArray[0]);
    EXPECT_EQ(511, doubleValuesArray[1]);
  }

  // String Collection - All elements should be sorted in order
  {
    std::string stringToMerge = "eknxasuw"; // Left sorted part [e,k,n,x] - Right sorted part [a,s,u,w]
    MergeWithBuffer<std::string::iterator>()
      (stringToMerge.begin(), stringToMerge.begin() + 4, stringToMerge.end());

    // All elements of the final array are sorted
    for (std::string::iterator it = stringToMerge.begin(); it < stringToMerge.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }
}

TEST	(	TestMerge	,
		MergeSorts
	)

Definition at line 188 of file TestMerge.cxx.

{
  // Normal Run - all elements should be sorter in order
  {
    Container vector(ArrayRand);
    MergeSort<IT>(vector.begin(), vector.end());

    // All elements are sorted
    for (auto it = vector.begin(); it < vector.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }

  // Already SortArray - Array should not be affected
  {
    Container vector(ArraySort);
    MergeSort<IT>(vector.begin(), vector.end());

    // All elements are still sorted
    for (auto it = vector.begin(); it < vector.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }

  // Inverse iterator order - Array should not be affected
  {
    Container vector(ArrayRand);
    MergeSort<IT>(vector.end(), vector.begin());

    int i = 0;
    for (auto it = vector.begin(); it < vector.end(); ++it, ++i)
      EXPECT_EQ(ArrayRand[i], *it);
  }

  // No error empty array
  {
    Container emptyArray;
    MergeSort<IT>(emptyArray.begin(), emptyArray.end());
  }

  // Unique value array - Array should not be affected
  {
    Container uniqueValueArray(1, 511);
    MergeSort<IT>(uniqueValueArray.begin(), uniqueValueArray.end());
    EXPECT_EQ(511, uniqueValueArray[0]);
  }

  // String collection - all elements should be sorter in order
  {
    std::string str = StrRand;
    MergeSort<std::string::iterator, Aggregator_Str>(str.begin(), str.end());

    // All elements are sorted
    for (auto it = str.begin(); it < str.end() - 1; ++it)
      EXPECT_LE(*it, *(it + 1));
  }
}