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 71 of file TestPartition.cxx.

{
  // Normal Run - Random Array
  {
    Container vector(ArrayRand);
    auto pivot = vector.begin() + 5;
    auto pivotVal = *pivot;

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

  // Already sortedArray - Array should not be affected
  {
    Container vector(ArraySort);
    auto pivot = vector.begin() + 5;

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

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

  // Begin and End inversed - Array should not be affected
  {
    Container vector(ArrayRand);
    auto pivot = vector.begin() + 5;

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

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

TEST	(	TestPartition	,
		PartitionString
	)

Definition at line 110 of file TestPartition.cxx.

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

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

TEST	(	TestPartition	,
		PartitionBoudaryPivots
	)

Definition at line 121 of file TestPartition.cxx.

{
  // Pivot choose as begin
  {
    Container vector(ArrayRand);
    auto pivot = vector.begin();
    const int pivotVal = *pivot;

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

  }

  // Pivot choose as last element
  {
    Container vector(ArrayRand);
    auto pivot = vector.end() - 1;
    const int pivotVal = *pivot;

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

  // Pivot choose as end - cannot process
  {
    Container vector(ArrayRand);
    auto pivot = vector.end();

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

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

TEST	(	TestPartition	,
		PartitionGreaterComparator
	)

Definition at line 161 of file TestPartition.cxx.

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

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

  // Already InverseSortedArray - Array should not be affected
  {
    Container invSortedArray(ArrayInvSort);
    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 str = StrRand;
    auto pivot = str.begin() + 5;
    const auto pivotVal = *pivot;

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