Return to pcre_stringpiece_unittest.cc CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre

Annotation of embedaddon/pcre/pcre_stringpiece_unittest.cc, revision 1.1.1.1

1.1       misho       1: // Copyright 2003 and onwards Google Inc.
                      2: // Author: Sanjay Ghemawat
                      3: 
                      4: #ifdef HAVE_CONFIG_H
                      5: #include "config.h"
                      6: #endif
                      7: 
                      8: #include <stdio.h>
                      9: #include <map>
                     10: #include <algorithm>    // for make_pair
                     11: 
                     12: #include "pcrecpp.h"
                     13: #include "pcre_stringpiece.h"
                     14: 
                     15: // CHECK dies with a fatal error if condition is not true.  It is *not*
                     16: // controlled by NDEBUG, so the check will be executed regardless of
                     17: // compilation mode.  Therefore, it is safe to do things like:
                     18: //    CHECK(fp->Write(x) == 4)
                     19: #define CHECK(condition) do {                           \
                     20:   if (!(condition)) {                                   \
                     21:     fprintf(stderr, "%s:%d: Check failed: %s\n",        \
                     22:             __FILE__, __LINE__, #condition);            \
                     23:     exit(1);                                            \
                     24:   }                                                     \
                     25: } while (0)
                     26: 
                     27: using pcrecpp::StringPiece;
                     28: 
                     29: static void CheckSTLComparator() {
                     30:   string s1("foo");
                     31:   string s2("bar");
                     32:   string s3("baz");
                     33: 
                     34:   StringPiece p1(s1);
                     35:   StringPiece p2(s2);
                     36:   StringPiece p3(s3);
                     37: 
                     38:   typedef std::map<StringPiece, int> TestMap;
                     39:   TestMap map;
                     40: 
                     41:   map.insert(std::make_pair(p1, 0));
                     42:   map.insert(std::make_pair(p2, 1));
                     43:   map.insert(std::make_pair(p3, 2));
                     44: 
                     45:   CHECK(map.size() == 3);
                     46: 
                     47:   TestMap::const_iterator iter = map.begin();
                     48:   CHECK(iter->second == 1);
                     49:   ++iter;
                     50:   CHECK(iter->second == 2);
                     51:   ++iter;
                     52:   CHECK(iter->second == 0);
                     53:   ++iter;
                     54:   CHECK(iter == map.end());
                     55: 
                     56:   TestMap::iterator new_iter = map.find("zot");
                     57:   CHECK(new_iter == map.end());
                     58: 
                     59:   new_iter = map.find("bar");
                     60:   CHECK(new_iter != map.end());
                     61: 
                     62:   map.erase(new_iter);
                     63:   CHECK(map.size() == 2);
                     64: 
                     65:   iter = map.begin();
                     66:   CHECK(iter->second == 2);
                     67:   ++iter;
                     68:   CHECK(iter->second == 0);
                     69:   ++iter;
                     70:   CHECK(iter == map.end());
                     71: }
                     72: 
                     73: static void CheckComparisonOperators() {
                     74: #define CMP_Y(op, x, y)                                         \
                     75:   CHECK( (StringPiece((x)) op StringPiece((y))));               \
                     76:   CHECK( (StringPiece((x)).compare(StringPiece((y))) op 0))
                     77: 
                     78: #define CMP_N(op, x, y)                                         \
                     79:   CHECK(!(StringPiece((x)) op StringPiece((y))));               \
                     80:   CHECK(!(StringPiece((x)).compare(StringPiece((y))) op 0))
                     81: 
                     82:   CMP_Y(==, "",   "");
                     83:   CMP_Y(==, "a",  "a");
                     84:   CMP_Y(==, "aa", "aa");
                     85:   CMP_N(==, "a",  "");
                     86:   CMP_N(==, "",   "a");
                     87:   CMP_N(==, "a",  "b");
                     88:   CMP_N(==, "a",  "aa");
                     89:   CMP_N(==, "aa", "a");
                     90: 
                     91:   CMP_N(!=, "",   "");
                     92:   CMP_N(!=, "a",  "a");
                     93:   CMP_N(!=, "aa", "aa");
                     94:   CMP_Y(!=, "a",  "");
                     95:   CMP_Y(!=, "",   "a");
                     96:   CMP_Y(!=, "a",  "b");
                     97:   CMP_Y(!=, "a",  "aa");
                     98:   CMP_Y(!=, "aa", "a");
                     99: 
                    100:   CMP_Y(<, "a",  "b");
                    101:   CMP_Y(<, "a",  "aa");
                    102:   CMP_Y(<, "aa", "b");
                    103:   CMP_Y(<, "aa", "bb");
                    104:   CMP_N(<, "a",  "a");
                    105:   CMP_N(<, "b",  "a");
                    106:   CMP_N(<, "aa", "a");
                    107:   CMP_N(<, "b",  "aa");
                    108:   CMP_N(<, "bb", "aa");
                    109: 
                    110:   CMP_Y(<=, "a",  "a");
                    111:   CMP_Y(<=, "a",  "b");
                    112:   CMP_Y(<=, "a",  "aa");
                    113:   CMP_Y(<=, "aa", "b");
                    114:   CMP_Y(<=, "aa", "bb");
                    115:   CMP_N(<=, "b",  "a");
                    116:   CMP_N(<=, "aa", "a");
                    117:   CMP_N(<=, "b",  "aa");
                    118:   CMP_N(<=, "bb", "aa");
                    119: 
                    120:   CMP_N(>=, "a",  "b");
                    121:   CMP_N(>=, "a",  "aa");
                    122:   CMP_N(>=, "aa", "b");
                    123:   CMP_N(>=, "aa", "bb");
                    124:   CMP_Y(>=, "a",  "a");
                    125:   CMP_Y(>=, "b",  "a");
                    126:   CMP_Y(>=, "aa", "a");
                    127:   CMP_Y(>=, "b",  "aa");
                    128:   CMP_Y(>=, "bb", "aa");
                    129: 
                    130:   CMP_N(>, "a",  "a");
                    131:   CMP_N(>, "a",  "b");
                    132:   CMP_N(>, "a",  "aa");
                    133:   CMP_N(>, "aa", "b");
                    134:   CMP_N(>, "aa", "bb");
                    135:   CMP_Y(>, "b",  "a");
                    136:   CMP_Y(>, "aa", "a");
                    137:   CMP_Y(>, "b",  "aa");
                    138:   CMP_Y(>, "bb", "aa");
                    139: 
                    140: #undef CMP_Y
                    141: #undef CMP_N
                    142: }
                    143: 
                    144: int main(int argc, char** argv) {
                    145:   CheckComparisonOperators();
                    146:   CheckSTLComparator();
                    147: 
                    148:   printf("OK\n");
                    149:   return 0;
                    150: }