TestPartition.cxx File Reference

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

Include dependency graph for TestPartition.cxx:

Go to the source code of this file.

Functions
	TEST (TestPartition, Partitions)
	TEST (TestPartition, PartitionString)
	TEST (TestPartition, PartitionBoudaryPivots)
	TEST (TestPartition, PartitionGreaterComparator)

Function Documentation

TEST	(	TestPartition	,
		Partitions
	)

Definition at line 73 of file TestPartition.cxx.

{
  // Normal Run - Random Array
  {
    Container randomdArray(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(int));
    auto pivot = randomdArray.begin() + 5;
    auto pivotVal = *pivot;

    // Run partition - Should result in: max[begin, pivot[ <= pivot <= min]pivot, end]
    auto newPivot = Partition<IT>(randomdArray.begin(), pivot, randomdArray.end());
    CheckPartition<IT>(randomdArray.begin(), randomdArray.end(), newPivot, pivotVal);
  }

  // Already sortedArray - Array should not be affected
  {
    Container sortedArray(SortedArrayInt, SortedArrayInt + sizeof(SortedArrayInt) / sizeof(int));
    auto pivot = sortedArray.begin() + 5;

    Partition<IT>(sortedArray.begin(), pivot, sortedArray.end());

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

  // Begin and End inversed - Array should not be affected
  {
    Container randomdArray(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(int));
    auto pivot = randomdArray.begin() + 5;

    Partition<IT>(randomdArray.end(), pivot, randomdArray.begin());

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

TEST	(	TestPartition	,
		PartitionString
	)

Definition at line 112 of file TestPartition.cxx.

{
  std::string randomStr = RandomStr;
  auto pivot = randomStr.begin() + 5;
  auto pivotVal = *pivot;

  auto newPivot = Partition<std::string::iterator>(randomStr.begin(), pivot, randomStr.end());
  CheckPartition<std::string::iterator>(randomStr.begin(), randomStr.end(), newPivot, pivotVal);
}

TEST	(	TestPartition	,
		PartitionBoudaryPivots
	)

Definition at line 123 of file TestPartition.cxx.

{
  // Pivot choose as begin
  {
    Container randomdArray(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(int));
    auto pivot = randomdArray.begin();
    const int pivotVal = *pivot;

    // Run partition
    auto newPivot = Partition<IT>(randomdArray.begin(), pivot, randomdArray.end());
    CheckPartition<IT>(randomdArray.begin(), randomdArray.end(), newPivot, pivotVal);

  }

  // Pivot choose as last element
  {
    Container randomdArray(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(int));
    auto pivot = randomdArray.end() - 1;
    const int pivotVal = *pivot;

    // Run partition
    auto newPivot = Partition<IT>(randomdArray.begin(), pivot, randomdArray.end());
    CheckPartition<IT>(randomdArray.begin(), randomdArray.end(), newPivot, pivotVal);
  }

  // Pivot choose as end - cannot process
  {
    Container randomdArray(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(int));
    auto pivot = randomdArray.end();

    // Run partition
    Partition<IT>(randomdArray.begin(), pivot, randomdArray.end());

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

TEST	(	TestPartition	,
		PartitionGreaterComparator
	)

Definition at line 163 of file TestPartition.cxx.

{
  // Normal Run - Should result in: min[begin, pivot[ >= pivot >= max]pivot, end]
  {
    Container randomdArray(RandomArrayInt, RandomArrayInt + sizeof(RandomArrayInt) / sizeof(int));
    auto pivot = randomdArray.begin() + 5;
    const auto pivotVal = *pivot;

    // Run partition
    auto newPivot = Partition<IT, GE_Compare>(randomdArray.begin(), pivot, randomdArray.end());
    CheckPartition<IT>(randomdArray.begin(), randomdArray.end(), newPivot, pivotVal, false);
  }

  // Already InverseSortedArray - Array should not be affected
  {
    Container invSortedArray(InvSortedArrayInt, InvSortedArrayInt + sizeof(InvSortedArrayInt) / sizeof(int));
    auto pivot = invSortedArray.begin() + 5;

    Partition<IT, GE_Compare>(invSortedArray.begin(), pivot, invSortedArray.end());

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

  // String collection - Should result in: min[begin, pivot[ >= pivot >= max]pivot, end]
  {
    std::string randomStr = RandomStr;
    auto pivot = randomStr.begin() + 5;
    const auto pivotVal = *pivot;

    // Run partition
    auto newPivot = Partition<std::string::iterator, std::greater_equal<char>>(randomStr.begin(), pivot, randomStr.end());
    CheckPartition<std::string::iterator>(randomStr.begin(), randomStr.end(), newPivot, pivotVal, false);
  }
}