src/stl_logging_unittest.cc

   1 // Copyright 2003 Google, Inc.
   2 // All Rights Reserved.
   3
   4 #include "config.h"
   5
   6 #ifdef HAVE_USING_OPERATOR
   7
   8 #include "glog/stl_logging.h"
   9
  10 #include <iostream>
  11 #include <map>
  12 #include <string>
  13 #include <strstream>
  14 #include <vector>
  15
  16 #ifdef __GNUC__
  17 # include <ext/hash_map>
  18 # include <ext/hash_set>
  19 #endif
  20
  21 #include "glog/logging.h"
  22 #include "googletest.h"
  23
  24 using namespace std;
  25 #ifdef __GNUC__
  26 using namespace __gnu_cxx;
  27 #endif
  28
  29 struct user_hash {
  30   size_t operator()(int x) const { return x; }
  31 };
  32
  33 void TestSTLLogging() {
  34   {
  35     // Test a sequence.
  36     vector<int> v;
  37     v.push_back(10);
  38     v.push_back(20);
  39     v.push_back(30);
  40     char ss_buf[1000];
  41     ostrstream ss(ss_buf, sizeof(ss_buf));
  42     // Just ostrstream s1; leaks heap.
  43     ss << v << ends;
  44     CHECK_STREQ(ss.str(), "10 20 30");
  45     vector<int> copied_v(v);
  46     CHECK_EQ(v, copied_v);  // This must compile.
  47   }
  48
  49   {
  50     // Test a sorted pair associative container.
  51     map< int, string > m;
  52     m[20] = "twenty";
  53     m[10] = "ten";
  54     m[30] = "thirty";
  55     char ss_buf[1000];
  56     ostrstream ss(ss_buf, sizeof(ss_buf));
  57     ss << m << ends;
  58     CHECK_STREQ(ss.str(), "(10, ten) (20, twenty) (30, thirty)");
  59     map< int, string > copied_m(m);
  60     CHECK_EQ(m, copied_m);  // This must compile.
  61   }
  62
  63 #ifdef __GNUC__
  64   {
  65     // Test a hashed simple associative container.
  66     hash_set<int> hs;
  67     hs.insert(10);
  68     hs.insert(20);
  69     hs.insert(30);
  70     char ss_buf[1000];
  71     ostrstream ss(ss_buf, sizeof(ss_buf));
  72     ss << hs << ends;
  73     CHECK_STREQ(ss.str(), "10 20 30");
  74     hash_set<int> copied_hs(hs);
  75     CHECK_EQ(hs, copied_hs);  // This must compile.
  76   }
  77 #endif
  78
  79 #ifdef __GNUC__
  80   {
  81     // Test a hashed pair associative container.
  82     hash_map<int, string> hm;
  83     hm[10] = "ten";
  84     hm[20] = "twenty";
  85     hm[30] = "thirty";
  86     char ss_buf[1000];
  87     ostrstream ss(ss_buf, sizeof(ss_buf));
  88     ss << hm << ends;
  89     CHECK_STREQ(ss.str(), "(10, ten) (20, twenty) (30, thirty)");
  90     hash_map<int, string> copied_hm(hm);
  91     CHECK_EQ(hm, copied_hm);  // this must compile
  92   }
  93 #endif
  94
  95   {
  96     // Test a long sequence.
  97     vector<int> v;
  98     string expected;
  99     for (int i = 0; i < 100; i++) {
 100       v.push_back(i);
 101       if (i > 0) expected += ' ';
 102       char buf[256];
 103       sprintf(buf, "%d", i);
 104       expected += buf;
 105     }
 106     v.push_back(100);
 107     expected += " ...";
 108     char ss_buf[1000];
 109     ostrstream ss(ss_buf, sizeof(ss_buf));
 110     ss << v << ends;
 111     CHECK_STREQ(ss.str(), expected.c_str());
 112   }
 113
 114   {
 115     // Test a sorted pair associative container.
 116     // Use a non-default comparison functor.
 117     map< int, string, greater<int> > m;
 118     m[20] = "twenty";
 119     m[10] = "ten";
 120     m[30] = "thirty";
 121     char ss_buf[1000];
 122     ostrstream ss(ss_buf, sizeof(ss_buf));
 123     ss << m << ends;
 124     CHECK_STREQ(ss.str(), "(30, thirty) (20, twenty) (10, ten)");
 125     map< int, string, greater<int> > copied_m(m);
 126     CHECK_EQ(m, copied_m);  // This must compile.
 127   }
 128
 129 #ifdef __GNUC__
 130   {
 131     // Test a hashed simple associative container.
 132     // Use a user defined hash function.
 133     hash_set<int, user_hash> hs;
 134     hs.insert(10);
 135     hs.insert(20);
 136     hs.insert(30);
 137     char ss_buf[1000];
 138     ostrstream ss(ss_buf, sizeof(ss_buf));
 139     ss << hs << ends;
 140     CHECK_STREQ(ss.str(), "10 20 30");
 141     hash_set<int, user_hash> copied_hs(hs);
 142     CHECK_EQ(hs, copied_hs);  // This must compile.
 143   }
 144 #endif
 145 }
 146
 147 int main(int argc, char** argv) {
 148   TestSTLLogging();
 149   std::cout << "PASS\n";
 150   return 0;
 151 }
 152
 153 #else
 154
 155 #include <iostream>
 156
 157 int main(int argc, char** argv) {
 158   std::cout << "We don't support stl_logging for this compiler.\n"
 159             << "(we need compiler support of 'using ::operator<<' "
 160             << "for this feature.)\n";
 161   return 0;
 162 }
 163
 164 #endif  // HAVE_USING_OPERATOR