code/trunk/pcre_stringpiece_unittest.cc

// Copyright 2003 and onwards Google Inc.
// Author: Sanjay Ghemawat

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <map>
#include <algorithm>    // for make_pair

#include <pcrecpp.h>
#include <pcre_stringpiece.h>

// CHECK dies with a fatal error if condition is not true.  It is *not*
// controlled by NDEBUG, so the check will be executed regardless of
// compilation mode.  Therefore, it is safe to do things like:
//    CHECK(fp->Write(x) == 4)
#define CHECK(condition) do {                           \
  if (!(condition)) {                                   \
    fprintf(stderr, "%s:%d: Check failed: %s\n",        \
            __FILE__, __LINE__, #condition);            \
    exit(1);                                            \
  }                                                     \
} while (0)

using std::map;
using std::make_pair;
using pcrecpp::StringPiece;

static void CheckSTLComparator() {
  string s1("foo");
  string s2("bar");
  string s3("baz");

  StringPiece p1(s1);
  StringPiece p2(s2);
  StringPiece p3(s3);

  typedef map<StringPiece, int> TestMap;
  TestMap map;

  map.insert(make_pair(p1, 0));
  map.insert(make_pair(p2, 1));
  map.insert(make_pair(p3, 2));
  CHECK(map.size() == 3);

  TestMap::const_iterator iter = map.begin();
  CHECK(iter->second == 1);
  ++iter;
  CHECK(iter->second == 2);
  ++iter;
  CHECK(iter->second == 0);
  ++iter;
  CHECK(iter == map.end());

  TestMap::iterator new_iter = map.find("zot");
  CHECK(new_iter == map.end());

  new_iter = map.find("bar");
  CHECK(new_iter != map.end());

  map.erase(new_iter);
  CHECK(map.size() == 2);

  iter = map.begin();
  CHECK(iter->second == 2);
  ++iter;
  CHECK(iter->second == 0);
  ++iter;
  CHECK(iter == map.end());
}

static void CheckComparisonOperators() {
#define CMP_Y(op, x, y)                                         \
  CHECK( (StringPiece((x)) op StringPiece((y))));               \
  CHECK( (StringPiece((x)).compare(StringPiece((y))) op 0))

#define CMP_N(op, x, y)                                         \
  CHECK(!(StringPiece((x)) op StringPiece((y))));               \
  CHECK(!(StringPiece((x)).compare(StringPiece((y))) op 0))

  CMP_Y(==, "",   "");
  CMP_Y(==, "a",  "a");
  CMP_Y(==, "aa", "aa");
  CMP_N(==, "a",  "");
  CMP_N(==, "",   "a");
  CMP_N(==, "a",  "b");
  CMP_N(==, "a",  "aa");
  CMP_N(==, "aa", "a");

  CMP_N(!=, "",   "");
  CMP_N(!=, "a",  "a");
  CMP_N(!=, "aa", "aa");
  CMP_Y(!=, "a",  "");
  CMP_Y(!=, "",   "a");
  CMP_Y(!=, "a",  "b");
  CMP_Y(!=, "a",  "aa");
  CMP_Y(!=, "aa", "a");

  CMP_Y(<, "a",  "b");
  CMP_Y(<, "a",  "aa");
  CMP_Y(<, "aa", "b");
  CMP_Y(<, "aa", "bb");
  CMP_N(<, "a",  "a");
  CMP_N(<, "b",  "a");
  CMP_N(<, "aa", "a");
  CMP_N(<, "b",  "aa");
  CMP_N(<, "bb", "aa");

  CMP_Y(<=, "a",  "a");
  CMP_Y(<=, "a",  "b");
  CMP_Y(<=, "a",  "aa");
  CMP_Y(<=, "aa", "b");
  CMP_Y(<=, "aa", "bb");
  CMP_N(<=, "b",  "a");
  CMP_N(<=, "aa", "a");
  CMP_N(<=, "b",  "aa");
  CMP_N(<=, "bb", "aa");

  CMP_N(>=, "a",  "b");
  CMP_N(>=, "a",  "aa");
  CMP_N(>=, "aa", "b");
  CMP_N(>=, "aa", "bb");
  CMP_Y(>=, "a",  "a");
  CMP_Y(>=, "b",  "a");
  CMP_Y(>=, "aa", "a");
  CMP_Y(>=, "b",  "aa");
  CMP_Y(>=, "bb", "aa");

  CMP_N(>, "a",  "a");
  CMP_N(>, "a",  "b");
  CMP_N(>, "a",  "aa");
  CMP_N(>, "aa", "b");
  CMP_N(>, "aa", "bb");
  CMP_Y(>, "b",  "a");
  CMP_Y(>, "aa", "a");
  CMP_Y(>, "b",  "aa");
  CMP_Y(>, "bb", "aa");

#undef CMP_Y
#undef CMP_N
}

int main(int argc, char** argv) {
  CheckComparisonOperators();
  CheckSTLComparator();

  printf("OK\n");
  return 0;
}
1	nigel	77	// Copyright 2003 and onwards Google Inc.
2			// Author: Sanjay Ghemawat
3
4	ph10	200	#ifdef HAVE_CONFIG_H
5	ph10	199	#include <config.h>
6	ph10	200	#endif
7	ph10	199
8	nigel	77	#include <stdio.h>
9			#include <map>
10			#include <algorithm> // for make_pair
11	ph10	199
12			#include <pcrecpp.h>
13	nigel	77	#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 std::map;
28			using std::make_pair;
29			using pcrecpp::StringPiece;
30
31			static void CheckSTLComparator() {
32			string s1("foo");
33			string s2("bar");
34			string s3("baz");
35
36			StringPiece p1(s1);
37			StringPiece p2(s2);
38			StringPiece p3(s3);
39
40			typedef map<StringPiece, int> TestMap;
41			TestMap map;
42
43			map.insert(make_pair(p1, 0));
44			map.insert(make_pair(p2, 1));
45			map.insert(make_pair(p3, 2));
46			CHECK(map.size() == 3);
47
48			TestMap::const_iterator iter = map.begin();
49			CHECK(iter->second == 1);
50			++iter;
51			CHECK(iter->second == 2);
52			++iter;
53			CHECK(iter->second == 0);
54			++iter;
55			CHECK(iter == map.end());
56
57			TestMap::iterator new_iter = map.find("zot");
58			CHECK(new_iter == map.end());
59
60			new_iter = map.find("bar");
61			CHECK(new_iter != map.end());
62
63			map.erase(new_iter);
64			CHECK(map.size() == 2);
65
66			iter = map.begin();
67			CHECK(iter->second == 2);
68			++iter;
69			CHECK(iter->second == 0);
70			++iter;
71			CHECK(iter == map.end());
72			}
73
74			static void CheckComparisonOperators() {
75			#define CMP_Y(op, x, y) \
76			CHECK( (StringPiece((x)) op StringPiece((y)))); \
77			CHECK( (StringPiece((x)).compare(StringPiece((y))) op 0))
78
79			#define CMP_N(op, x, y) \
80			CHECK(!(StringPiece((x)) op StringPiece((y)))); \
81			CHECK(!(StringPiece((x)).compare(StringPiece((y))) op 0))
82
83			CMP_Y(==, "", "");
84			CMP_Y(==, "a", "a");
85			CMP_Y(==, "aa", "aa");
86			CMP_N(==, "a", "");
87			CMP_N(==, "", "a");
88			CMP_N(==, "a", "b");
89			CMP_N(==, "a", "aa");
90			CMP_N(==, "aa", "a");
91
92			CMP_N(!=, "", "");
93			CMP_N(!=, "a", "a");
94			CMP_N(!=, "aa", "aa");
95			CMP_Y(!=, "a", "");
96			CMP_Y(!=, "", "a");
97			CMP_Y(!=, "a", "b");
98			CMP_Y(!=, "a", "aa");
99			CMP_Y(!=, "aa", "a");
100
101			CMP_Y(<, "a", "b");
102			CMP_Y(<, "a", "aa");
103			CMP_Y(<, "aa", "b");
104			CMP_Y(<, "aa", "bb");
105			CMP_N(<, "a", "a");
106			CMP_N(<, "b", "a");
107			CMP_N(<, "aa", "a");
108			CMP_N(<, "b", "aa");
109			CMP_N(<, "bb", "aa");
110
111			CMP_Y(<=, "a", "a");
112			CMP_Y(<=, "a", "b");
113			CMP_Y(<=, "a", "aa");
114			CMP_Y(<=, "aa", "b");
115			CMP_Y(<=, "aa", "bb");
116			CMP_N(<=, "b", "a");
117			CMP_N(<=, "aa", "a");
118			CMP_N(<=, "b", "aa");
119			CMP_N(<=, "bb", "aa");
120
121			CMP_N(>=, "a", "b");
122			CMP_N(>=, "a", "aa");
123			CMP_N(>=, "aa", "b");
124			CMP_N(>=, "aa", "bb");
125			CMP_Y(>=, "a", "a");
126			CMP_Y(>=, "b", "a");
127			CMP_Y(>=, "aa", "a");
128			CMP_Y(>=, "b", "aa");
129			CMP_Y(>=, "bb", "aa");
130
131			CMP_N(>, "a", "a");
132			CMP_N(>, "a", "b");
133			CMP_N(>, "a", "aa");
134			CMP_N(>, "aa", "b");
135			CMP_N(>, "aa", "bb");
136			CMP_Y(>, "b", "a");
137			CMP_Y(>, "aa", "a");
138			CMP_Y(>, "b", "aa");
139			CMP_Y(>, "bb", "aa");
140
141			#undef CMP_Y
142			#undef CMP_N
143			}
144
145			int main(int argc, char** argv) {
146			CheckComparisonOperators();
147			CheckSTLComparator();
148
149			printf("OK\n");
150			return 0;
151			}
Name	Value
svn:eol-style	native
svn:keywords	"Author Date Id Revision Url"