← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/unittests/Support/raw_ostream_test.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/unittests/Support/raw_ostream_test.cpp
 
1
//===- llvm/unittest/Support/raw_ostream_test.cpp - raw_ostream tests -----===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
 
 
10
#include "gtest/gtest.h"
 
11
#include "llvm/ADT/SmallString.h"
 
12
#include "llvm/Support/Format.h"
 
13
#include "llvm/Support/raw_ostream.h"
 
14
 
 
15
using namespace llvm;
 
16
 
 
17
namespace {
 
18
 
 
19
template<typename T> std::string printToString(const T &Value) {
 
20
  std::string res;
 
21
  llvm::raw_string_ostream(res) << Value;
 
22
  return res;    
 
23
}
 
24
 
 
25
/// printToString - Print the given value to a stream which only has \arg
 
26
/// BytesLeftInBuffer bytes left in the buffer. This is useful for testing edge
 
27
/// cases in the buffer handling logic.
 
28
template<typename T> std::string printToString(const T &Value,
 
29
                                               unsigned BytesLeftInBuffer) {
 
30
  // FIXME: This is relying on internal knowledge of how raw_ostream works to
 
31
  // get the buffer position right.
 
32
  SmallString<256> SVec;
 
33
  assert(BytesLeftInBuffer < 256 && "Invalid buffer count!");
 
34
  llvm::raw_svector_ostream OS(SVec);
 
35
  unsigned StartIndex = 256 - BytesLeftInBuffer;
 
36
  for (unsigned i = 0; i != StartIndex; ++i)
 
37
    OS << '?';
 
38
  OS << Value;
 
39
  return OS.str().substr(StartIndex);
 
40
}
 
41
 
 
42
template<typename T> std::string printToStringUnbuffered(const T &Value) {
 
43
  std::string res;
 
44
  llvm::raw_string_ostream OS(res);
 
45
  OS.SetUnbuffered();
 
46
  OS << Value;
 
47
  return res;
 
48
}
 
49
 
 
50
TEST(raw_ostreamTest, Types_Buffered) {
 
51
  // Char
 
52
  EXPECT_EQ("c", printToString('c'));
 
53
 
 
54
  // String
 
55
  EXPECT_EQ("hello", printToString("hello"));
 
56
  EXPECT_EQ("hello", printToString(std::string("hello")));
 
57
 
 
58
  // Int
 
59
  EXPECT_EQ("0", printToString(0));
 
60
  EXPECT_EQ("2425", printToString(2425));
 
61
  EXPECT_EQ("-2425", printToString(-2425));
 
62
 
 
63
  // Long long
 
64
  EXPECT_EQ("0", printToString(0LL));
 
65
  EXPECT_EQ("257257257235709", printToString(257257257235709LL));
 
66
  EXPECT_EQ("-257257257235709", printToString(-257257257235709LL));
 
67
 
 
68
  // Double
 
69
  EXPECT_EQ("1.100000e+00", printToString(1.1));
 
70
 
 
71
  // void*
 
72
  EXPECT_EQ("0x0", printToString((void*) 0));
 
73
  EXPECT_EQ("0xbeef", printToString((void*) 0xbeef));
 
74
  EXPECT_EQ("0xdeadbeef", printToString((void*) 0xdeadbeef));
 
75
 
 
76
  // Min and max.
 
77
  EXPECT_EQ("18446744073709551615", printToString(UINT64_MAX));
 
78
  EXPECT_EQ("-9223372036854775808", printToString(INT64_MIN));
 
79
}
 
80
 
 
81
TEST(raw_ostreamTest, Types_Unbuffered) {  
 
82
  // Char
 
83
  EXPECT_EQ("c", printToStringUnbuffered('c'));
 
84
 
 
85
  // String
 
86
  EXPECT_EQ("hello", printToStringUnbuffered("hello"));
 
87
  EXPECT_EQ("hello", printToStringUnbuffered(std::string("hello")));
 
88
 
 
89
  // Int
 
90
  EXPECT_EQ("0", printToStringUnbuffered(0));
 
91
  EXPECT_EQ("2425", printToStringUnbuffered(2425));
 
92
  EXPECT_EQ("-2425", printToStringUnbuffered(-2425));
 
93
 
 
94
  // Long long
 
95
  EXPECT_EQ("0", printToStringUnbuffered(0LL));
 
96
  EXPECT_EQ("257257257235709", printToStringUnbuffered(257257257235709LL));
 
97
  EXPECT_EQ("-257257257235709", printToStringUnbuffered(-257257257235709LL));
 
98
 
 
99
  // Double
 
100
  EXPECT_EQ("1.100000e+00", printToStringUnbuffered(1.1));
 
101
 
 
102
  // void*
 
103
  EXPECT_EQ("0x0", printToStringUnbuffered((void*) 0));
 
104
  EXPECT_EQ("0xbeef", printToStringUnbuffered((void*) 0xbeef));
 
105
  EXPECT_EQ("0xdeadbeef", printToStringUnbuffered((void*) 0xdeadbeef));
 
106
 
 
107
  // Min and max.
 
108
  EXPECT_EQ("18446744073709551615", printToStringUnbuffered(UINT64_MAX));
 
109
  EXPECT_EQ("-9223372036854775808", printToStringUnbuffered(INT64_MIN));
 
110
}
 
111
 
 
112
TEST(raw_ostreamTest, BufferEdge) {  
 
113
  EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 1));
 
114
  EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 2));
 
115
  EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 3));
 
116
  EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 4));
 
117
  EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 10));
 
118
}
 
119
 
 
120
TEST(raw_ostreamTest, TinyBuffer) {
 
121
  std::string Str;
 
122
  raw_string_ostream OS(Str);
 
123
  OS.SetBufferSize(1);
 
124
  OS << "hello";
 
125
  OS << 1;
 
126
  OS << 'w' << 'o' << 'r' << 'l' << 'd';
 
127
  EXPECT_EQ("hello1world", OS.str());
 
128
}
 
129
 
 
130
TEST(raw_ostreamTest, WriteEscaped) {
 
131
  std::string Str;
 
132
 
 
133
  Str = "";
 
134
  raw_string_ostream(Str).write_escaped("hi");
 
135
  EXPECT_EQ("hi", Str);
 
136
 
 
137
  Str = "";
 
138
  raw_string_ostream(Str).write_escaped("\\\t\n\"");
 
139
  EXPECT_EQ("\\\\\\t\\n\\\"", Str);
 
140
 
 
141
  Str = "";
 
142
  raw_string_ostream(Str).write_escaped("\1\10\200");
 
143
  EXPECT_EQ("\\001\\010\\200", Str);
 
144
}
 
145
 
 
146
}