← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to protobuf/files/src/google/protobuf/io/printer_unittest.cc

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
protobuf/files/src/google/protobuf/io/printer_unittest.cc
1
 
// Protocol Buffers - Google's data interchange format
2
 
// Copyright 2008 Google Inc.  All rights reserved.
3
 
// http://code.google.com/p/protobuf/
4
 
//
5
 
// Redistribution and use in source and binary forms, with or without
6
 
// modification, are permitted provided that the following conditions are
7
 
// met:
8
 
//
9
 
//     * Redistributions of source code must retain the above copyright
10
 
// notice, this list of conditions and the following disclaimer.
11
 
//     * Redistributions in binary form must reproduce the above
12
 
// copyright notice, this list of conditions and the following disclaimer
13
 
// in the documentation and/or other materials provided with the
14
 
// distribution.
15
 
//     * Neither the name of Google Inc. nor the names of its
16
 
// contributors may be used to endorse or promote products derived from
17
 
// this software without specific prior written permission.
18
 
//
19
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20
 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21
 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22
 
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23
 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24
 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25
 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26
 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27
 
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28
 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29
 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
 
 
31
 
// Author: kenton@google.com (Kenton Varda)
32
 
//  Based on original Protocol Buffers design by
33
 
//  Sanjay Ghemawat, Jeff Dean, and others.
34
 
 
35
 
#include <vector>
36
 
 
37
 
#include <google/protobuf/io/printer.h>
38
 
#include <google/protobuf/io/zero_copy_stream_impl.h>
39
 
 
40
 
#include <google/protobuf/stubs/common.h>
41
 
#include <google/protobuf/testing/googletest.h>
42
 
#include <gtest/gtest.h>
43
 
 
44
 
namespace google {
45
 
namespace protobuf {
46
 
namespace io {
47
 
namespace {
48
 
 
49
 
// Each test repeats over several block sizes in order to test both cases
50
 
// where particular writes cross a buffer boundary and cases where they do
51
 
// not.
52
 
 
53
 
TEST(Printer, EmptyPrinter) {
54
 
  char buffer[8192];
55
 
  const int block_size = 100;
56
 
  ArrayOutputStream output(buffer, GOOGLE_ARRAYSIZE(buffer), block_size);
57
 
  Printer printer(&output, '\0');
58
 
  EXPECT_TRUE(!printer.failed());
59
 
}
60
 
 
61
 
TEST(Printer, BasicPrinting) {
62
 
  char buffer[8192];
63
 
 
64
 
  for (int block_size = 1; block_size < 512; block_size *= 2) {
65
 
    ArrayOutputStream output(buffer, sizeof(buffer), block_size);
66
 
 
67
 
    {
68
 
      Printer printer(&output, '\0');
69
 
 
70
 
      printer.Print("Hello World!");
71
 
      printer.Print("  This is the same line.\n");
72
 
      printer.Print("But this is a new one.\nAnd this is another one.");
73
 
 
74
 
      EXPECT_FALSE(printer.failed());
75
 
    }
76
 
 
77
 
    buffer[output.ByteCount()] = '\0';
78
 
 
79
 
    EXPECT_STREQ("Hello World!  This is the same line.\n"
80
 
                 "But this is a new one.\n"
81
 
                 "And this is another one.",
82
 
                 buffer);
83
 
  }
84
 
}
85
 
 
86
 
TEST(Printer, WriteRaw) {
87
 
  char buffer[8192];
88
 
 
89
 
  for (int block_size = 1; block_size < 512; block_size *= 2) {
90
 
    ArrayOutputStream output(buffer, sizeof(buffer), block_size);
91
 
 
92
 
    {
93
 
      string string_obj = "From an object\n";
94
 
      Printer printer(&output, '$');
95
 
      printer.WriteRaw("Hello World!", 12);
96
 
      printer.PrintRaw("  This is the same line.\n");
97
 
      printer.PrintRaw("But this is a new one.\nAnd this is another one.");
98
 
      printer.WriteRaw("\n", 1);
99
 
      printer.PrintRaw(string_obj);
100
 
      EXPECT_FALSE(printer.failed());
101
 
    }
102
 
 
103
 
    buffer[output.ByteCount()] = '\0';
104
 
 
105
 
    EXPECT_STREQ("Hello World!  This is the same line.\n"
106
 
                 "But this is a new one.\n"
107
 
                 "And this is another one."
108
 
                 "\n"
109
 
                 "From an object\n",
110
 
                 buffer);
111
 
  }
112
 
}
113
 
 
114
 
TEST(Printer, VariableSubstitution) {
115
 
  char buffer[8192];
116
 
 
117
 
  for (int block_size = 1; block_size < 512; block_size *= 2) {
118
 
    ArrayOutputStream output(buffer, sizeof(buffer), block_size);
119
 
 
120
 
    {
121
 
      Printer printer(&output, '$');
122
 
      map<string, string> vars;
123
 
 
124
 
      vars["foo"] = "World";
125
 
      vars["bar"] = "$foo$";
126
 
      vars["abcdefg"] = "1234";
127
 
 
128
 
      printer.Print(vars, "Hello $foo$!\nbar = $bar$\n");
129
 
      printer.PrintRaw("RawBit\n");
130
 
      printer.Print(vars, "$abcdefg$\nA literal dollar sign:  $$");
131
 
 
132
 
      vars["foo"] = "blah";
133
 
      printer.Print(vars, "\nNow foo = $foo$.");
134
 
 
135
 
      EXPECT_FALSE(printer.failed());
136
 
    }
137
 
 
138
 
    buffer[output.ByteCount()] = '\0';
139
 
 
140
 
    EXPECT_STREQ("Hello World!\n"
141
 
                 "bar = $foo$\n"
142
 
                 "RawBit\n"
143
 
                 "1234\n"
144
 
                 "A literal dollar sign:  $\n"
145
 
                 "Now foo = blah.",
146
 
                 buffer);
147
 
  }
148
 
}
149
 
 
150
 
TEST(Printer, InlineVariableSubstitution) {
151
 
  char buffer[8192];
152
 
 
153
 
  ArrayOutputStream output(buffer, sizeof(buffer));
154
 
 
155
 
  {
156
 
    Printer printer(&output, '$');
157
 
    printer.Print("Hello $foo$!\n", "foo", "World");
158
 
    printer.PrintRaw("RawBit\n");
159
 
    printer.Print("$foo$ $bar$\n", "foo", "one", "bar", "two");
160
 
    EXPECT_FALSE(printer.failed());
161
 
  }
162
 
 
163
 
  buffer[output.ByteCount()] = '\0';
164
 
 
165
 
  EXPECT_STREQ("Hello World!\n"
166
 
               "RawBit\n"
167
 
               "one two\n",
168
 
               buffer);
169
 
}
170
 
 
171
 
TEST(Printer, Indenting) {
172
 
  char buffer[8192];
173
 
 
174
 
  for (int block_size = 1; block_size < 512; block_size *= 2) {
175
 
    ArrayOutputStream output(buffer, sizeof(buffer), block_size);
176
 
 
177
 
    {
178
 
      Printer printer(&output, '$');
179
 
      map<string, string> vars;
180
 
 
181
 
      vars["newline"] = "\n";
182
 
 
183
 
      printer.Print("This is not indented.\n");
184
 
      printer.Indent();
185
 
      printer.Print("This is indented\nAnd so is this\n");
186
 
      printer.Outdent();
187
 
      printer.Print("But this is not.");
188
 
      printer.Indent();
189
 
      printer.Print("  And this is still the same line.\n"
190
 
                    "But this is indented.\n");
191
 
      printer.PrintRaw("RawBit has indent at start\n");
192
 
      printer.PrintRaw("but not after a raw newline\n");
193
 
      printer.Print(vars, "Note that a newline in a variable will break "
194
 
                    "indenting, as we see$newline$here.\n");
195
 
      printer.Indent();
196
 
      printer.Print("And this");
197
 
      printer.Outdent();
198
 
      printer.Outdent();
199
 
      printer.Print(" is double-indented\nBack to normal.");
200
 
 
201
 
      EXPECT_FALSE(printer.failed());
202
 
    }
203
 
 
204
 
    buffer[output.ByteCount()] = '\0';
205
 
 
206
 
    EXPECT_STREQ(
207
 
      "This is not indented.\n"
208
 
      "  This is indented\n"
209
 
      "  And so is this\n"
210
 
      "But this is not.  And this is still the same line.\n"
211
 
      "  But this is indented.\n"
212
 
      "  RawBit has indent at start\n"
213
 
      "but not after a raw newline\n"
214
 
      "Note that a newline in a variable will break indenting, as we see\n"
215
 
      "here.\n"
216
 
      "    And this is double-indented\n"
217
 
      "Back to normal.",
218
 
      buffer);
219
 
  }
220
 
}
221
 
 
222
 
// Death tests do not work on Windows as of yet.
223
 
#ifdef GTEST_HAS_DEATH_TEST
224
 
TEST(Printer, Death) {
225
 
  char buffer[8192];
226
 
 
227
 
  ArrayOutputStream output(buffer, sizeof(buffer));
228
 
  Printer printer(&output, '$');
229
 
 
230
 
  EXPECT_DEBUG_DEATH(printer.Print("$nosuchvar$"), "Undefined variable");
231
 
  EXPECT_DEBUG_DEATH(printer.Print("$unclosed"), "Unclosed variable name");
232
 
  EXPECT_DEBUG_DEATH(printer.Outdent(), "without matching Indent");
233
 
}
234
 
#endif  // GTEST_HAS_DEATH_TEST
235
 
 
236
 
TEST(Printer, WriteFailure) {
237
 
  char buffer[16];
238
 
 
239
 
  ArrayOutputStream output(buffer, sizeof(buffer));
240
 
  Printer printer(&output, '$');
241
 
 
242
 
  // Print 16 bytes to fill the buffer exactly (should not fail).
243
 
  printer.Print("0123456789abcdef");
244
 
  EXPECT_FALSE(printer.failed());
245
 
 
246
 
  // Try to print one more byte (should fail).
247
 
  printer.Print(" ");
248
 
  EXPECT_TRUE(printer.failed());
249
 
 
250
 
  // Should not crash
251
 
  printer.Print("blah");
252
 
  EXPECT_TRUE(printer.failed());
253
 
 
254
 
  // Buffer should contain the first 16 bytes written.
255
 
  EXPECT_EQ("0123456789abcdef", string(buffer, sizeof(buffer)));
256
 
}
257
 
 
258
 
}  // namespace
259
 
}  // namespace io
260
 
}  // namespace protobuf
261
 
}  // namespace google