[ceph.git] / ceph / src / test / formatter.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
 * Ceph - scalable distributed file system
 *
 * Copyright (C) 2011 New Dream Network
 *
 * This is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1, as published by the Free Software
 * Foundation.  See file COPYING.
 *
 */

#include "gtest/gtest.h"
#include "common/Formatter.h"
#include "common/HTMLFormatter.h"

#include <sstream>
#include <string>

using namespace ceph;
using std::ostringstream;

TEST(JsonFormatter, Simple1) {
  ostringstream oss;
  JSONFormatter fmt(false);
  fmt.open_object_section("foo");
  fmt.dump_int("a", 1);
  fmt.dump_int("b", 2);
  fmt.dump_int("c", 3);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "{\"a\":1,\"b\":2,\"c\":3}");
}

TEST(JsonFormatter, Simple2) {
  ostringstream oss;
  JSONFormatter fmt(false);
  fmt.open_object_section("foo");
  fmt.open_object_section("bar");
  fmt.dump_int("int", 0xf00000000000ll);
  fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
  fmt.dump_float("float", 1.234);
  fmt.close_section();
  fmt.dump_string("string", "str");
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "{\"bar\":{\"int\":263882790666240,\
\"unsigned\":9223372036854775809,\"float\":1.234000},\
\"string\":\"str\"}");
}

TEST(JsonFormatter, Empty) {
  ostringstream oss;
  JSONFormatter fmt(false);
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "");
}

TEST(XmlFormatter, Simple1) {
  ostringstream oss;
  XMLFormatter fmt(false);
  fmt.open_object_section("foo");
  fmt.dump_int("a", 1);
  fmt.dump_int("b", 2);
  fmt.dump_int("c", 3);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<foo><a>1</a><b>2</b><c>3</c></foo>");
}

TEST(XmlFormatter, Simple2) {
  ostringstream oss;
  XMLFormatter fmt(false);
  fmt.open_object_section("foo");
  fmt.open_object_section("bar");
  fmt.dump_int("int", 0xf00000000000ll);
  fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
  fmt.dump_float("float", 1.234);
  fmt.close_section();
  fmt.dump_string("string", "str");
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<foo><bar>\
<int>263882790666240</int>\
<unsigned>9223372036854775809</unsigned>\
<float>1.234</float>\
</bar><string>str</string>\
</foo>");
}

TEST(XmlFormatter, Empty) {
  ostringstream oss;
  XMLFormatter fmt(false);
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "");
}

TEST(XmlFormatter, DumpStream1) {
  ostringstream oss;
  XMLFormatter fmt(false);
  fmt.dump_stream("blah") << "hithere";
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<blah>hithere</blah>");
}

TEST(XmlFormatter, DumpStream2) {
  ostringstream oss;
  XMLFormatter fmt(false);

  fmt.open_array_section("foo");
  fmt.dump_stream("blah") << "hithere";
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<foo><blah>hithere</blah></foo>");
}

TEST(XmlFormatter, DumpStream3) {
  ostringstream oss;
  XMLFormatter fmt(false);

  fmt.open_array_section("foo");
  fmt.dump_stream("blah") << "hithere";
  fmt.dump_float("pi", 3.14);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<foo><blah>hithere</blah><pi>3.14</pi></foo>");
}

TEST(XmlFormatter, DTD) {
  ostringstream oss;
  XMLFormatter fmt(false);

  fmt.output_header();
  fmt.open_array_section("foo");
  fmt.dump_stream("blah") << "hithere";
  fmt.dump_float("pi", 3.14);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<foo><blah>hithere</blah><pi>3.14</pi></foo>");
}

TEST(XmlFormatter, Clear) {
  ostringstream oss;
  XMLFormatter fmt(false);

  fmt.output_header();
  fmt.open_array_section("foo");
  fmt.dump_stream("blah") << "hithere";
  fmt.dump_float("pi", 3.14);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<foo><blah>hithere</blah><pi>3.14</pi></foo>");

  ostringstream oss2;
  fmt.flush(oss2);
  ASSERT_EQ(oss2.str(), "");

  ostringstream oss3;
  fmt.reset();
  fmt.flush(oss3);
  ASSERT_EQ(oss3.str(), "");
}

TEST(XmlFormatter, NamespaceTest) {
  ostringstream oss;
  XMLFormatter fmt(false);

  fmt.output_header();
  fmt.open_array_section_in_ns("foo",
			   "http://s3.amazonaws.com/doc/2006-03-01/");
  fmt.dump_stream("blah") << "hithere";
  fmt.dump_float("pi", 3.14);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
    "<blah>hithere</blah><pi>3.14</pi></foo>");
}

TEST(XmlFormatter, DumpFormatNameSpaceTest) {
  ostringstream oss1;
  XMLFormatter fmt(false);

  fmt.dump_format_ns("foo",
		     "http://s3.amazonaws.com/doc/2006-03-01/",
		     "%s","bar");
  fmt.flush(oss1);
  ASSERT_EQ(oss1.str(),
	    "<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">bar</foo>");

  // Testing with a null ns..should be same as dump format
  ostringstream oss2;
  fmt.reset();
  fmt.dump_format_ns("foo",NULL,"%s","bar");
  fmt.flush(oss2);
  ASSERT_EQ(oss2.str(),"<foo>bar</foo>");
}

TEST(HtmlFormatter, Simple1) {
  ostringstream oss;
  HTMLFormatter fmt(false);
  fmt.open_object_section("foo");
  fmt.dump_int("a", 1);
  fmt.dump_int("b", 2);
  fmt.dump_int("c", 3);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<foo><li>a: 1</li><li>b: 2</li><li>c: 3</li></foo>");
}

TEST(HtmlFormatter, Simple2) {
  ostringstream oss;
  HTMLFormatter fmt(false);
  fmt.open_object_section("foo");
  fmt.open_object_section("bar");
  fmt.dump_int("int", 0xf00000000000ll);
  fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
  fmt.dump_float("float", 1.234);
  fmt.close_section();
  fmt.dump_string("string", "str");
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<foo><bar>\
<li>int: 263882790666240</li>\
<li>unsigned: 9223372036854775809</li>\
<li>float: 1.234</li>\
</bar><li>string: str</li>\
</foo>");
}

TEST(HtmlFormatter, Empty) {
  ostringstream oss;
  HTMLFormatter fmt(false);
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "");
}

TEST(HtmlFormatter, DumpStream1) {
  ostringstream oss;
  HTMLFormatter fmt(false);
  fmt.dump_stream("blah") << "hithere";
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<li>blah: hithere</li>");
}

TEST(HtmlFormatter, DumpStream2) {
  ostringstream oss;
  HTMLFormatter fmt(false);

  fmt.open_array_section("foo");
  fmt.dump_stream("blah") << "hithere";
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<foo><li>blah: hithere</li></foo>");
}

TEST(HtmlFormatter, DumpStream3) {
  ostringstream oss;
  HTMLFormatter fmt(false);

  fmt.open_array_section("foo");
  fmt.dump_stream("blah") << "hithere";
  fmt.dump_float("pi", 3.14);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<foo><li>blah: hithere</li><li>pi: 3.14</li></foo>");
}

TEST(HtmlFormatter, DTD) {
  ostringstream oss;
  HTMLFormatter fmt(false);

  fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
  fmt.open_array_section("foo");
  fmt.dump_stream("blah") << "hithere";
  fmt.dump_float("pi", 3.14);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<foo><li>blah: hithere</li><li>pi: 3.14</li></foo>");
}

TEST(HtmlFormatter, Clear) {
  ostringstream oss;
  HTMLFormatter fmt(false);

  fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
  fmt.open_array_section("foo");
  fmt.dump_stream("blah") << "hithere";
  fmt.dump_float("pi", 3.14);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<foo><li>blah: hithere</li><li>pi: 3.14</li></foo>");

  ostringstream oss2;
  fmt.flush(oss2);
  ASSERT_EQ(oss2.str(), "");

  ostringstream oss3;
  fmt.reset();
  fmt.flush(oss3);
  ASSERT_EQ(oss3.str(), "");
}

TEST(HtmlFormatter, NamespaceTest) {
  ostringstream oss;
  HTMLFormatter fmt(false);

  fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
  fmt.open_array_section_in_ns("foo",
			   "http://s3.amazonaws.com/doc/2006-03-01/");
  fmt.dump_stream("blah") << "hithere";
  fmt.dump_float("pi", 3.14);
  fmt.close_section();
  fmt.flush(oss);
  ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
    "<li>blah: hithere</li><li>pi: 3.14</li></foo>");
}

TEST(HtmlFormatter, DumpFormatNameSpaceTest) {
  ostringstream oss1;
  HTMLFormatter fmt(false);

  fmt.dump_format_ns("foo",
		     "http://s3.amazonaws.com/doc/2006-03-01/",
		     "%s","bar");
  fmt.flush(oss1);
  ASSERT_EQ(oss1.str(),
	    "<li xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">foo: bar</li>");

  // Testing with a null ns..should be same as dump format
  ostringstream oss2;
  fmt.reset();
  fmt.dump_format_ns("foo",NULL,"%s","bar");
  fmt.flush(oss2);
  ASSERT_EQ(oss2.str(),"<li>foo: bar</li>");
}
Commit	Line	Data
7c673cae FG	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	}