ceph/src/test/formatter.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2011 New Dream Network
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15 #include "gtest/gtest.h"
  16 #include "common/Formatter.h"
  17 #include "common/HTMLFormatter.h"
  18
  19 #include <sstream>
  20 #include <string>
  21
  22 using namespace ceph;
  23 using std::ostringstream;
  24
  25 TEST(JsonFormatter, Simple1) {
  26   ostringstream oss;
  27   JSONFormatter fmt(false);
  28   fmt.open_object_section("foo");
  29   fmt.dump_int("a", 1);
  30   fmt.dump_int("b", 2);
  31   fmt.dump_int("c", 3);
  32   fmt.close_section();
  33   fmt.flush(oss);
  34   ASSERT_EQ(oss.str(), "{\"a\":1,\"b\":2,\"c\":3}");
  35 }
  36
  37 TEST(JsonFormatter, Simple2) {
  38   ostringstream oss;
  39   JSONFormatter fmt(false);
  40   fmt.open_object_section("foo");
  41   fmt.open_object_section("bar");
  42   fmt.dump_int("int", 0xf00000000000ll);
  43   fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
  44   fmt.dump_float("float", 1.234);
  45   fmt.close_section();
  46   fmt.dump_string("string", "str");
  47   fmt.close_section();
  48   fmt.flush(oss);
  49   ASSERT_EQ(oss.str(), "{\"bar\":{\"int\":263882790666240,\
  50 \"unsigned\":9223372036854775809,\"float\":1.234000},\
  51 \"string\":\"str\"}");
  52 }
  53
  54 TEST(JsonFormatter, Empty) {
  55   ostringstream oss;
  56   JSONFormatter fmt(false);
  57   fmt.flush(oss);
  58   ASSERT_EQ(oss.str(), "");
  59 }
  60
  61 TEST(XmlFormatter, Simple1) {
  62   ostringstream oss;
  63   XMLFormatter fmt(false);
  64   fmt.open_object_section("foo");
  65   fmt.dump_int("a", 1);
  66   fmt.dump_int("b", 2);
  67   fmt.dump_int("c", 3);
  68   fmt.close_section();
  69   fmt.flush(oss);
  70   ASSERT_EQ(oss.str(), "<foo><a>1</a><b>2</b><c>3</c></foo>");
  71 }
  72
  73 TEST(XmlFormatter, Simple2) {
  74   ostringstream oss;
  75   XMLFormatter fmt(false);
  76   fmt.open_object_section("foo");
  77   fmt.open_object_section("bar");
  78   fmt.dump_int("int", 0xf00000000000ll);
  79   fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
  80   fmt.dump_float("float", 1.234);
  81   fmt.close_section();
  82   fmt.dump_string("string", "str");
  83   fmt.close_section();
  84   fmt.flush(oss);
  85   ASSERT_EQ(oss.str(), "<foo><bar>\
  86 <int>263882790666240</int>\
  87 <unsigned>9223372036854775809</unsigned>\
  88 <float>1.234</float>\
  89 </bar><string>str</string>\
  90 </foo>");
  91 }
  92
  93 TEST(XmlFormatter, Empty) {
  94   ostringstream oss;
  95   XMLFormatter fmt(false);
  96   fmt.flush(oss);
  97   ASSERT_EQ(oss.str(), "");
  98 }
  99
 100 TEST(XmlFormatter, DumpStream1) {
 101   ostringstream oss;
 102   XMLFormatter fmt(false);
 103   fmt.dump_stream("blah") << "hithere";
 104   fmt.flush(oss);
 105   ASSERT_EQ(oss.str(), "<blah>hithere</blah>");
 106 }
 107
 108 TEST(XmlFormatter, DumpStream2) {
 109   ostringstream oss;
 110   XMLFormatter fmt(false);
 111
 112   fmt.open_array_section("foo");
 113   fmt.dump_stream("blah") << "hithere";
 114   fmt.close_section();
 115   fmt.flush(oss);
 116   ASSERT_EQ(oss.str(), "<foo><blah>hithere</blah></foo>");
 117 }
 118
 119 TEST(XmlFormatter, DumpStream3) {
 120   ostringstream oss;
 121   XMLFormatter fmt(false);
 122
 123   fmt.open_array_section("foo");
 124   fmt.dump_stream("blah") << "hithere";
 125   fmt.dump_float("pi", 3.14);
 126   fmt.close_section();
 127   fmt.flush(oss);
 128   ASSERT_EQ(oss.str(), "<foo><blah>hithere</blah><pi>3.14</pi></foo>");
 129 }
 130
 131 TEST(XmlFormatter, DTD) {
 132   ostringstream oss;
 133   XMLFormatter fmt(false);
 134
 135   fmt.output_header();
 136   fmt.open_array_section("foo");
 137   fmt.dump_stream("blah") << "hithere";
 138   fmt.dump_float("pi", 3.14);
 139   fmt.close_section();
 140   fmt.flush(oss);
 141   ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 142     "<foo><blah>hithere</blah><pi>3.14</pi></foo>");
 143 }
 144
 145 TEST(XmlFormatter, Clear) {
 146   ostringstream oss;
 147   XMLFormatter fmt(false);
 148
 149   fmt.output_header();
 150   fmt.open_array_section("foo");
 151   fmt.dump_stream("blah") << "hithere";
 152   fmt.dump_float("pi", 3.14);
 153   fmt.close_section();
 154   fmt.flush(oss);
 155   ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 156     "<foo><blah>hithere</blah><pi>3.14</pi></foo>");
 157
 158   ostringstream oss2;
 159   fmt.flush(oss2);
 160   ASSERT_EQ(oss2.str(), "");
 161
 162   ostringstream oss3;
 163   fmt.reset();
 164   fmt.flush(oss3);
 165   ASSERT_EQ(oss3.str(), "");
 166 }
 167
 168 TEST(XmlFormatter, NamespaceTest) {
 169   ostringstream oss;
 170   XMLFormatter fmt(false);
 171
 172   fmt.output_header();
 173   fmt.open_array_section_in_ns("foo",
 174                            "http://s3.amazonaws.com/doc/2006-03-01/");
 175   fmt.dump_stream("blah") << "hithere";
 176   fmt.dump_float("pi", 3.14);
 177   fmt.close_section();
 178   fmt.flush(oss);
 179   ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 180     "<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
 181     "<blah>hithere</blah><pi>3.14</pi></foo>");
 182 }
 183
 184 TEST(XmlFormatter, DumpFormatNameSpaceTest) {
 185   ostringstream oss1;
 186   XMLFormatter fmt(false);
 187
 188   fmt.dump_format_ns("foo",
 189                      "http://s3.amazonaws.com/doc/2006-03-01/",
 190                      "%s","bar");
 191   fmt.flush(oss1);
 192   ASSERT_EQ(oss1.str(),
 193             "<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">bar</foo>");
 194
 195   // Testing with a null ns..should be same as dump format
 196   ostringstream oss2;
 197   fmt.reset();
 198   fmt.dump_format_ns("foo",NULL,"%s","bar");
 199   fmt.flush(oss2);
 200   ASSERT_EQ(oss2.str(),"<foo>bar</foo>");
 201 }
 202
 203 TEST(HtmlFormatter, Simple1) {
 204   ostringstream oss;
 205   HTMLFormatter fmt(false);
 206   fmt.open_object_section("foo");
 207   fmt.dump_int("a", 1);
 208   fmt.dump_int("b", 2);
 209   fmt.dump_int("c", 3);
 210   fmt.close_section();
 211   fmt.flush(oss);
 212   ASSERT_EQ(oss.str(), "<foo><li>a: 1</li><li>b: 2</li><li>c: 3</li></foo>");
 213 }
 214
 215 TEST(HtmlFormatter, Simple2) {
 216   ostringstream oss;
 217   HTMLFormatter fmt(false);
 218   fmt.open_object_section("foo");
 219   fmt.open_object_section("bar");
 220   fmt.dump_int("int", 0xf00000000000ll);
 221   fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
 222   fmt.dump_float("float", 1.234);
 223   fmt.close_section();
 224   fmt.dump_string("string", "str");
 225   fmt.close_section();
 226   fmt.flush(oss);
 227   ASSERT_EQ(oss.str(), "<foo><bar>\
 228 <li>int: 263882790666240</li>\
 229 <li>unsigned: 9223372036854775809</li>\
 230 <li>float: 1.234</li>\
 231 </bar><li>string: str</li>\
 232 </foo>");
 233 }
 234
 235 TEST(HtmlFormatter, Empty) {
 236   ostringstream oss;
 237   HTMLFormatter fmt(false);
 238   fmt.flush(oss);
 239   ASSERT_EQ(oss.str(), "");
 240 }
 241
 242 TEST(HtmlFormatter, DumpStream1) {
 243   ostringstream oss;
 244   HTMLFormatter fmt(false);
 245   fmt.dump_stream("blah") << "hithere";
 246   fmt.flush(oss);
 247   ASSERT_EQ(oss.str(), "<li>blah: hithere</li>");
 248 }
 249
 250 TEST(HtmlFormatter, DumpStream2) {
 251   ostringstream oss;
 252   HTMLFormatter fmt(false);
 253
 254   fmt.open_array_section("foo");
 255   fmt.dump_stream("blah") << "hithere";
 256   fmt.close_section();
 257   fmt.flush(oss);
 258   ASSERT_EQ(oss.str(), "<foo><li>blah: hithere</li></foo>");
 259 }
 260
 261 TEST(HtmlFormatter, DumpStream3) {
 262   ostringstream oss;
 263   HTMLFormatter fmt(false);
 264
 265   fmt.open_array_section("foo");
 266   fmt.dump_stream("blah") << "hithere";
 267   fmt.dump_float("pi", 3.14);
 268   fmt.close_section();
 269   fmt.flush(oss);
 270   ASSERT_EQ(oss.str(), "<foo><li>blah: hithere</li><li>pi: 3.14</li></foo>");
 271 }
 272
 273 TEST(HtmlFormatter, DTD) {
 274   ostringstream oss;
 275   HTMLFormatter fmt(false);
 276
 277   fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
 278   fmt.open_array_section("foo");
 279   fmt.dump_stream("blah") << "hithere";
 280   fmt.dump_float("pi", 3.14);
 281   fmt.close_section();
 282   fmt.flush(oss);
 283   ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 284     "<foo><li>blah: hithere</li><li>pi: 3.14</li></foo>");
 285 }
 286
 287 TEST(HtmlFormatter, Clear) {
 288   ostringstream oss;
 289   HTMLFormatter fmt(false);
 290
 291   fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
 292   fmt.open_array_section("foo");
 293   fmt.dump_stream("blah") << "hithere";
 294   fmt.dump_float("pi", 3.14);
 295   fmt.close_section();
 296   fmt.flush(oss);
 297   ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 298     "<foo><li>blah: hithere</li><li>pi: 3.14</li></foo>");
 299
 300   ostringstream oss2;
 301   fmt.flush(oss2);
 302   ASSERT_EQ(oss2.str(), "");
 303
 304   ostringstream oss3;
 305   fmt.reset();
 306   fmt.flush(oss3);
 307   ASSERT_EQ(oss3.str(), "");
 308 }
 309
 310 TEST(HtmlFormatter, NamespaceTest) {
 311   ostringstream oss;
 312   HTMLFormatter fmt(false);
 313
 314   fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
 315   fmt.open_array_section_in_ns("foo",
 316                            "http://s3.amazonaws.com/doc/2006-03-01/");
 317   fmt.dump_stream("blah") << "hithere";
 318   fmt.dump_float("pi", 3.14);
 319   fmt.close_section();
 320   fmt.flush(oss);
 321   ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 322     "<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
 323     "<li>blah: hithere</li><li>pi: 3.14</li></foo>");
 324 }
 325
 326 TEST(HtmlFormatter, DumpFormatNameSpaceTest) {
 327   ostringstream oss1;
 328   HTMLFormatter fmt(false);
 329
 330   fmt.dump_format_ns("foo",
 331                      "http://s3.amazonaws.com/doc/2006-03-01/",
 332                      "%s","bar");
 333   fmt.flush(oss1);
 334   ASSERT_EQ(oss1.str(),
 335             "<li xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">foo: bar</li>");
 336
 337   // Testing with a null ns..should be same as dump format
 338   ostringstream oss2;
 339   fmt.reset();
 340   fmt.dump_format_ns("foo",NULL,"%s","bar");
 341   fmt.flush(oss2);
 342   ASSERT_EQ(oss2.str(),"<li>foo: bar</li>");
 343 }