1 #include <vector>

     2 #include <algorithm>

     3 #include <functional>

     4 #include "cppunit/cppunit_proxy.h"

     5 

     6 #if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)

     7 using namespace std;

     8 #endif

     9 

    10 //

    11 // TestCase class

    12 //

    13 class EqualTest : public CPPUNIT_NS::TestCase

    14 {

    15   CPPUNIT_TEST_SUITE(EqualTest);

    16   CPPUNIT_TEST(equal_range0);

    17   CPPUNIT_TEST(equal_range1);

    18   CPPUNIT_TEST(equal_range2);

    19   CPPUNIT_TEST(equal0);

    20   CPPUNIT_TEST(equal1);

    21   CPPUNIT_TEST(equal2);

    22   CPPUNIT_TEST(equalto);

    23   CPPUNIT_TEST_SUITE_END();

    24 

    25 protected:

    26   void equal_range0();

    27   void equal_range1();

    28   void equal_range2();

    29   void equal0();

    30   void equal1();

    31   void equal2();

    32   void equalto();

    33   static bool values_squared(int a_, int b_);

    34 };

    35 

    36 CPPUNIT_TEST_SUITE_REGISTRATION(EqualTest);

    37 

    38 //

    39 // tests implementation

    40 //

    41 void EqualTest::equal_range0()

    42 {

    43   int numbers[10] = { 0, 0, 1, 1, 2, 2, 2, 2, 3, 3 };

    44   pair<int*, int*> range = equal_range((int*)numbers, (int*)numbers + 10, 2);

    45   CPPUNIT_ASSERT( (range.first - numbers) == 4 );

    46   CPPUNIT_ASSERT( (range.second - numbers) == 8 );

    47 }

    48 

    49 void EqualTest::equal_range1()

    50 {

    51   typedef vector <int> IntVec;

    52   IntVec v(10);

    53   for (int i = 0; (size_t)i < v.size(); ++i)

    54     v[i] = i / 3;

    55 

    56   pair<IntVec::iterator, IntVec::iterator> range = equal_range(v.begin(), v.end(), 2);

    57   CPPUNIT_ASSERT( (range.first - v.begin()) == 6 );

    58   CPPUNIT_ASSERT( (range.second - v.begin()) == 9 );

    59   for (; range.first != range.second; ++range.first)

    60     CPPUNIT_ASSERT( *range.first == 2 );

    61 

    62   range = equal_range(v.begin(), v.end(), 4);

    63   CPPUNIT_ASSERT( range.first == range.second );

    64   CPPUNIT_ASSERT( range.first == v.end() );

    65 }

    66 

    67 struct Test {

    68   Test(int val) : value(val) {}

    69   int value;

    70 

    71   bool operator == (int i) const

    72   { return value == i; }

    73 };

    74 

    75 bool operator < (const Test& v1, int v2)

    76 { return v1.value < v2; }

    77 

    78 bool operator < (int v1, const Test& v2)

    79 { return v1 < v2.value; }

    80 

    81 void EqualTest::equal_range2()

    82 {

    83   char chars[] = "aabbccddggghhklllmqqqqssyyzz";

    84 

    85   const unsigned count = sizeof(chars) - 1;

    86   pair<char*, char*> range = equal_range((char*)chars, (char*)chars + count, 'q', less<char>());

    87   CPPUNIT_ASSERT( (range.first - chars) == 18 );

    88   CPPUNIT_ASSERT( (range.second - chars) == 22 );

    89   for (; range.first != range.second; ++range.first)

    90     CPPUNIT_ASSERT( *range.first == 'q' );

    91 

    92   range = equal_range((char*)chars, (char*)chars + count, 'm', less<char>());

    93   CPPUNIT_ASSERT( (range.second - range.first) == 1 );

    94   CPPUNIT_ASSERT( *range.first == 'm' );

    95 

    96   vector<Test> tv;

    97   vector<Test>::iterator it;

    98   pair<vector<Test>::iterator, vector<Test>::iterator> p;

    99 

   100   for (int i = 0; i < 10; ++i) {

   101     tv.push_back(i);

   102   }

   103 

   104   it = upper_bound(tv.begin(), tv.end(), 5);

   105   CPPUNIT_ASSERT( it != tv.end() );

   106   CPPUNIT_ASSERT( *it == 6 );

   107 

   108   it = lower_bound(tv.begin(), tv.end(), 5);

   109   CPPUNIT_ASSERT( it != tv.end() );

   110   CPPUNIT_ASSERT( *it == 5 );

   111 

   112   p = equal_range(tv.begin(), tv.end(), 5);

   113   CPPUNIT_ASSERT( p.first != p.second );

   114   CPPUNIT_ASSERT( p.first != tv.end() );

   115   CPPUNIT_ASSERT( p.second != tv.end() );

   116   CPPUNIT_ASSERT( *p.first == 5 );

   117   CPPUNIT_ASSERT( *p.second == 6 );

   118 }

   119 

   120 void EqualTest::equal0()

   121 {

   122   int numbers1[5] = { 1, 2, 3, 4, 5 };

   123   int numbers2[5] = { 1, 2, 4, 8, 16 };

   124   int numbers3[2] = { 1, 2 };

   125 

   126   CPPUNIT_ASSERT( !equal(numbers1, numbers1 + 5, numbers2) );

   127   CPPUNIT_ASSERT( equal(numbers3, numbers3 + 2, numbers1) );

   128 }

   129 

   130 void EqualTest::equal1()

   131 {

   132   vector <int> v1(10);

   133   for (int i = 0; (size_t)i < v1.size(); ++i)

   134     v1[i] = i;

   135   vector <int> v2(10);

   136   CPPUNIT_ASSERT( !equal(v1.begin(), v1.end(), v2.begin()) );

   137 

   138   copy(v1.begin(), v1.end(), v2.begin());

   139   CPPUNIT_ASSERT( equal(v1.begin(), v1.end(), v2.begin()) )

   140 }

   141 

   142 void EqualTest::equal2()

   143 {

   144   vector <int> v1(10);

   145   vector <int> v2(10);

   146   for (int i = 0; (size_t)i < v1.size(); ++i) {

   147     v1[i] = i;

   148     v2[i] = i * i;

   149   }

   150   CPPUNIT_ASSERT( equal(v1.begin(), v1.end(), v2.begin(), values_squared) );

   151 }

   152 

   153 void EqualTest::equalto()

   154 {

   155   int input1 [4] = { 1, 7, 2, 2 };

   156   int input2 [4] = { 1, 6, 2, 3 };

   157 

   158   int output [4];

   159   transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, equal_to<int>());

   160   CPPUNIT_ASSERT( output[0] == 1 );

   161   CPPUNIT_ASSERT( output[1] == 0 );

   162   CPPUNIT_ASSERT( output[2] == 1 );

   163   CPPUNIT_ASSERT( output[3] == 0 );

   164 }

   165 

   166 bool EqualTest::values_squared(int a_, int b_)

   167 {

   168   return (a_ * a_ == b_);

   169 }