~ubuntu-branches/debian/wheezy/protobuf/wheezy
» Revision
14
: .pc/fix-ftbfs-gcc4.7-kfreebsd.patch/gtest/include/gtest/internal/gtest-port.h
« back to all changes in this revision
Viewing changes to .pc/fix-ftbfs-gcc4.7-kfreebsd.patch/gtest/include/gtest/internal/gtest-port.h
- browse files at revision 14
- compare with another revision
- compare with revision 14
- download diff
- download tarball
- view history from revision 14
- Committer: Package Import Robot
- Author(s): Iustin Pop
- Date: 2012-06-17 18:29:37 UTC
- Revision ID: package-import@ubuntu.com-20120617182937-vpmm3dpmh00pvthy
Tags: 2.4.1-3
Add patch from Steven Chamberlain fixing build failures of the
embedded gtest copy on kFreeBSD (Closes: #675837)
embedded gtest copy on kFreeBSD (Closes: #675837)
- files added:
- .pc/fix-ftbfs-gcc4.7-kfreebsd.patch
- .pc/fix-ftbfs-gcc4.7-kfreebsd.patch/gtest
- .pc/fix-ftbfs-gcc4.7-kfreebsd.patch/gtest/include
- .pc/fix-ftbfs-gcc4.7-kfreebsd.patch/gtest/include/gtest
- .pc/fix-ftbfs-gcc4.7-kfreebsd.patch/gtest/include/gtest/internal
- files modified:
- .pc/applied-patches
added
removed
.pc/fix-ftbfs-gcc4.7-kfreebsd.patch/gtest/include/gtest/internal/gtest-port.h
1
// Copyright 2005, Google Inc.
2
// All rights reserved.
3
//
4
// Redistribution and use in source and binary forms, with or without
5
// modification, are permitted provided that the following conditions are
6
// met:
7
//
8
// * Redistributions of source code must retain the above copyright
9
// notice, this list of conditions and the following disclaimer.
10
// * Redistributions in binary form must reproduce the above
11
// copyright notice, this list of conditions and the following disclaimer
12
// in the documentation and/or other materials provided with the
13
// distribution.
14
// * Neither the name of Google Inc. nor the names of its
15
// contributors may be used to endorse or promote products derived from
16
// this software without specific prior written permission.
17
//
18
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
//
30
// Authors: wan@google.com (Zhanyong Wan)
31
//
32
// Low-level types and utilities for porting Google Test to various
33
// platforms. They are subject to change without notice. DO NOT USE
34
// THEM IN USER CODE.
35
36
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
37
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
38
39
// The user can define the following macros in the build script to
40
// control Google Test's behavior. If the user doesn't define a macro
41
// in this list, Google Test will define it.
42
//
43
// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2)
44
// is/isn't available.
45
// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string
46
// is/isn't available (some systems define
47
// ::string, which is different to std::string).
48
// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
49
// is/isn't available (some systems define
50
// ::wstring, which is different to std::wstring).
51
// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h>
52
// is/isn't available.
53
// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't
54
// enabled.
55
// GTEST_HAS_STD_STRING - Define it to 1/0 to indicate that
56
// std::string does/doesn't work (Google Test can
57
// be used where std::string is unavailable).
58
// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that
59
// std::wstring does/doesn't work (Google Test can
60
// be used where std::wstring is unavailable).
61
// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple
62
// is/isn't available.
63
// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the
64
// compiler supports Microsoft's "Structured
65
// Exception Handling".
66
// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google
67
// Test's own tr1 tuple implementation should be
68
// used. Unused when the user sets
69
// GTEST_HAS_TR1_TUPLE to 0.
70
71
// This header defines the following utilities:
72
//
73
// Macros indicating the current platform (defined to 1 if compiled on
74
// the given platform; otherwise undefined):
75
// GTEST_OS_CYGWIN - Cygwin
76
// GTEST_OS_LINUX - Linux
77
// GTEST_OS_MAC - Mac OS X
78
// GTEST_OS_SOLARIS - Sun Solaris
79
// GTEST_OS_SYMBIAN - Symbian
80
// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile)
81
// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop
82
// GTEST_OS_WINDOWS_MINGW - MinGW
83
// GTEST_OS_WINODWS_MOBILE - Windows Mobile
84
// GTEST_OS_ZOS - z/OS
85
//
86
// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
87
// most stable support. Since core members of the Google Test project
88
// don't have access to other platforms, support for them may be less
89
// stable. If you notice any problems on your platform, please notify
90
// googletestframework@googlegroups.com (patches for fixing them are
91
// even more welcome!).
92
//
93
// Note that it is possible that none of the GTEST_OS_* macros are defined.
94
//
95
// Macros indicating available Google Test features (defined to 1 if
96
// the corresponding feature is supported; otherwise undefined):
97
// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized
98
// tests)
99
// GTEST_HAS_DEATH_TEST - death tests
100
// GTEST_HAS_PARAM_TEST - value-parameterized tests
101
// GTEST_HAS_TYPED_TEST - typed tests
102
// GTEST_HAS_TYPED_TEST_P - type-parameterized tests
103
// GTEST_USES_POSIX_RE - enhanced POSIX regex is used.
104
// GTEST_USES_SIMPLE_RE - our own simple regex is used;
105
// the above two are mutually exclusive.
106
//
107
// Macros for basic C++ coding:
108
// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
109
// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a
110
// variable don't have to be used.
111
// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
112
// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used.
113
//
114
// Synchronization:
115
// Mutex, MutexLock, ThreadLocal, GetThreadCount()
116
// - synchronization primitives.
117
// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above
118
// synchronization primitives have real implementations
119
// and Google Test is thread-safe; or 0 otherwise.
120
//
121
// Template meta programming:
122
// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only.
123
//
124
// Smart pointers:
125
// scoped_ptr - as in TR2.
126
//
127
// Regular expressions:
128
// RE - a simple regular expression class using the POSIX
129
// Extended Regular Expression syntax. Not available on
130
// Windows.
131
//
132
// Logging:
133
// GTEST_LOG_() - logs messages at the specified severity level.
134
// LogToStderr() - directs all log messages to stderr.
135
// FlushInfoLog() - flushes informational log messages.
136
//
137
// Stderr capturing:
138
// CaptureStderr() - starts capturing stderr.
139
// GetCapturedStderr() - stops capturing stderr and returns the captured
140
// string.
141
//
142
// Integer types:
143
// TypeWithSize - maps an integer to a int type.
144
// Int32, UInt32, Int64, UInt64, TimeInMillis
145
// - integers of known sizes.
146
// BiggestInt - the biggest signed integer type.
147
//
148
// Command-line utilities:
149
// GTEST_FLAG() - references a flag.
150
// GTEST_DECLARE_*() - declares a flag.
151
// GTEST_DEFINE_*() - defines a flag.
152
// GetArgvs() - returns the command line as a vector of strings.
153
//
154
// Environment variable utilities:
155
// GetEnv() - gets the value of an environment variable.
156
// BoolFromGTestEnv() - parses a bool environment variable.
157
// Int32FromGTestEnv() - parses an Int32 environment variable.
158
// StringFromGTestEnv() - parses a string environment variable.
159
160
#include <stddef.h> // For ptrdiff_t
161
#include <stdlib.h>
162
#include <stdio.h>
163
#include <string.h>
164
#ifndef _WIN32_WCE
165
#include <sys/stat.h>
166
#endif // !_WIN32_WCE
167
168
#include <iostream> // NOLINT
169
170
#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
171
#define GTEST_FLAG_PREFIX_ "gtest_"
172
#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
173
#define GTEST_NAME_ "Google Test"
174
#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
175
176
// Determines the version of gcc that is used to compile this.
177
#ifdef __GNUC__
178
// 40302 means version 4.3.2.
179
#define GTEST_GCC_VER_ \
180
(__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
181
#endif // __GNUC__
182
183
// Determines the platform on which Google Test is compiled.
184
#ifdef __CYGWIN__
185
#define GTEST_OS_CYGWIN 1
186
#elif defined __SYMBIAN32__
187
#define GTEST_OS_SYMBIAN 1
188
#elif defined _WIN32
189
#define GTEST_OS_WINDOWS 1
190
#ifdef _WIN32_WCE
191
#define GTEST_OS_WINDOWS_MOBILE 1
192
#elif defined(__MINGW__) || defined(__MINGW32__)
193
#define GTEST_OS_WINDOWS_MINGW 1
194
#else
195
#define GTEST_OS_WINDOWS_DESKTOP 1
196
#endif // _WIN32_WCE
197
#elif defined __APPLE__
198
#define GTEST_OS_MAC 1
199
#elif defined __linux__
200
#define GTEST_OS_LINUX 1
201
#elif defined __MVS__
202
#define GTEST_OS_ZOS 1
203
#elif defined(__sun) && defined(__SVR4)
204
#define GTEST_OS_SOLARIS 1
205
#endif // __CYGWIN__
206
207
#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \
208
GTEST_OS_SOLARIS
209
210
// On some platforms, <regex.h> needs someone to define size_t, and
211
// won't compile otherwise. We can #include it here as we already
212
// included <stdlib.h>, which is guaranteed to define size_t through
213
// <stddef.h>.
214
#include <regex.h> // NOLINT
215
#include <strings.h> // NOLINT
216
#include <sys/types.h> // NOLINT
217
#include <unistd.h> // NOLINT
218
219
#define GTEST_USES_POSIX_RE 1
220
221
#elif GTEST_OS_WINDOWS
222
223
#if !GTEST_OS_WINDOWS_MOBILE
224
#include <direct.h> // NOLINT
225
#include <io.h> // NOLINT
226
#endif
227
228
// <regex.h> is not available on Windows. Use our own simple regex
229
// implementation instead.
230
#define GTEST_USES_SIMPLE_RE 1
231
232
#else
233
234
// <regex.h> may not be available on this platform. Use our own
235
// simple regex implementation instead.
236
#define GTEST_USES_SIMPLE_RE 1
237
238
#endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC ||
239
// GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS
240
241
// Defines GTEST_HAS_EXCEPTIONS to 1 if exceptions are enabled, or 0
242
// otherwise.
243
244
#if defined(_MSC_VER) || defined(__BORLANDC__)
245
// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
246
// macro to enable exceptions, so we'll do the same.
247
// Assumes that exceptions are enabled by default.
248
#ifndef _HAS_EXCEPTIONS
249
#define _HAS_EXCEPTIONS 1
250
#endif // _HAS_EXCEPTIONS
251
#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
252
#else // The compiler is not MSVC or C++Builder.
253
// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. For
254
// other compilers, we assume exceptions are disabled to be
255
// conservative.
256
#if defined(__GNUC__) && __EXCEPTIONS
257
#define GTEST_HAS_EXCEPTIONS 1
258
#else
259
#define GTEST_HAS_EXCEPTIONS 0
260
#endif // defined(__GNUC__) && __EXCEPTIONS
261
#endif // defined(_MSC_VER) || defined(__BORLANDC__)
262
263
// Determines whether ::std::string and ::string are available.
264
265
#ifndef GTEST_HAS_STD_STRING
266
// The user didn't tell us whether ::std::string is available, so we
267
// need to figure it out. The only environment that we know
268
// ::std::string is not available is MSVC 7.1 or lower with exceptions
269
// disabled.
270
#if defined(_MSC_VER) && (_MSC_VER < 1400) && !GTEST_HAS_EXCEPTIONS
271
#define GTEST_HAS_STD_STRING 0
272
#else
273
#define GTEST_HAS_STD_STRING 1
274
#endif
275
#endif // GTEST_HAS_STD_STRING
276
277
#ifndef GTEST_HAS_GLOBAL_STRING
278
// The user didn't tell us whether ::string is available, so we need
279
// to figure it out.
280
281
#define GTEST_HAS_GLOBAL_STRING 0
282
283
#endif // GTEST_HAS_GLOBAL_STRING
284
285
#ifndef GTEST_HAS_STD_WSTRING
286
// The user didn't tell us whether ::std::wstring is available, so we need
287
// to figure it out.
288
// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
289
// is available.
290
291
#if GTEST_OS_CYGWIN || GTEST_OS_SOLARIS
292
// Cygwin 1.5 and below doesn't support ::std::wstring.
293
// Cygwin 1.7 might add wstring support; this should be updated when clear.
294
// Solaris' libc++ doesn't support it either.
295
#define GTEST_HAS_STD_WSTRING 0
296
#else
297
#define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_STRING
298
#endif // GTEST_OS_CYGWIN || GTEST_OS_SOLARIS
299
300
#endif // GTEST_HAS_STD_WSTRING
301
302
#ifndef GTEST_HAS_GLOBAL_WSTRING
303
// The user didn't tell us whether ::wstring is available, so we need
304
// to figure it out.
305
#define GTEST_HAS_GLOBAL_WSTRING \
306
(GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
307
#endif // GTEST_HAS_GLOBAL_WSTRING
308
309
#if GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || \
310
GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
311
#include <string> // NOLINT
312
#endif // GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING ||
313
// GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
314
315
#if GTEST_HAS_STD_STRING
316
#include <sstream> // NOLINT
317
#else
318
#include <strstream> // NOLINT
319
#endif // GTEST_HAS_STD_STRING
320
321
// Determines whether RTTI is available.
322
#ifndef GTEST_HAS_RTTI
323
// The user didn't tell us whether RTTI is enabled, so we need to
324
// figure it out.
325
326
#ifdef _MSC_VER
327
328
#ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled.
329
#define GTEST_HAS_RTTI 1
330
#else
331
#define GTEST_HAS_RTTI 0
332
#endif // _CPPRTTI
333
334
#elif defined(__GNUC__)
335
336
// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
337
#if GTEST_GCC_VER_ >= 40302
338
#ifdef __GXX_RTTI
339
#define GTEST_HAS_RTTI 1
340
#else
341
#define GTEST_HAS_RTTI 0
342
#endif // __GXX_RTTI
343
#else
344
// For gcc versions smaller than 4.3.2, we assume RTTI is enabled.
345
#define GTEST_HAS_RTTI 1
346
#endif // GTEST_GCC_VER >= 40302
347
348
#else
349
350
// Unknown compiler - assume RTTI is enabled.
351
#define GTEST_HAS_RTTI 1
352
353
#endif // _MSC_VER
354
355
#endif // GTEST_HAS_RTTI
356
357
// Determines whether <pthread.h> is available.
358
#ifndef GTEST_HAS_PTHREAD
359
// The user didn't tell us, so we need to figure it out.
360
#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC)
361
#endif // GTEST_HAS_PTHREAD
362
363
// Determines whether Google Test can use tr1/tuple. You can define
364
// this macro to 0 to prevent Google Test from using tuple (any
365
// feature depending on tuple with be disabled in this mode).
366
#ifndef GTEST_HAS_TR1_TUPLE
367
// The user didn't tell us not to do it, so we assume it's OK.
368
#define GTEST_HAS_TR1_TUPLE 1
369
#endif // GTEST_HAS_TR1_TUPLE
370
371
// Determines whether Google Test's own tr1 tuple implementation
372
// should be used.
373
#ifndef GTEST_USE_OWN_TR1_TUPLE
374
// The user didn't tell us, so we need to figure it out.
375
376
// We use our own tr1 tuple if we aren't sure the user has an
377
// implementation of it already. At this time, GCC 4.0.0+ is the only
378
// mainstream compiler that comes with a TR1 tuple implementation.
379
// MSVC 2008 (9.0) provides TR1 tuple in a 323 MB Feature Pack
380
// download, which we cannot assume the user has. MSVC 2010 isn't
381
// released yet.
382
#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
383
#define GTEST_USE_OWN_TR1_TUPLE 0
384
#else
385
#define GTEST_USE_OWN_TR1_TUPLE 1
386
#endif // defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
387
388
#endif // GTEST_USE_OWN_TR1_TUPLE
389
390
// To avoid conditional compilation everywhere, we make it
391
// gtest-port.h's responsibility to #include the header implementing
392
// tr1/tuple.
393
#if GTEST_HAS_TR1_TUPLE
394
395
#if GTEST_USE_OWN_TR1_TUPLE
396
#include <gtest/internal/gtest-tuple.h>
397
#elif GTEST_OS_SYMBIAN
398
399
// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
400
// use STLport's tuple implementation, which unfortunately doesn't
401
// work as the copy of STLport distributed with Symbian is incomplete.
402
// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
403
// use its own tuple implementation.
404
#ifdef BOOST_HAS_TR1_TUPLE
405
#undef BOOST_HAS_TR1_TUPLE
406
#endif // BOOST_HAS_TR1_TUPLE
407
408
// This prevents <boost/tr1/detail/config.hpp>, which defines
409
// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
410
#define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
411
#include <tuple>
412
413
#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
414
// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does
415
// not conform to the TR1 spec, which requires the header to be <tuple>.
416
417
#if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
418
// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
419
// which is #included by <tr1/tuple>, to not compile when RTTI is
420
// disabled. _TR1_FUNCTIONAL is the header guard for
421
// <tr1/functional>. Hence the following #define is a hack to prevent
422
// <tr1/functional> from being included.
423
#define _TR1_FUNCTIONAL 1
424
#include <tr1/tuple>
425
#undef _TR1_FUNCTIONAL // Allows the user to #include
426
// <tr1/functional> if he chooses to.
427
#else
428
#include <tr1/tuple>
429
#endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
430
431
#else
432
// If the compiler is not GCC 4.0+, we assume the user is using a
433
// spec-conforming TR1 implementation.
434
#include <tuple>
435
#endif // GTEST_USE_OWN_TR1_TUPLE
436
437
#endif // GTEST_HAS_TR1_TUPLE
438
439
// Determines whether clone(2) is supported.
440
// Usually it will only be available on Linux, excluding
441
// Linux on the Itanium architecture.
442
// Also see http://linux.die.net/man/2/clone.
443
#ifndef GTEST_HAS_CLONE
444
// The user didn't tell us, so we need to figure it out.
445
446
#if GTEST_OS_LINUX && !defined(__ia64__)
447
#define GTEST_HAS_CLONE 1
448
#else
449
#define GTEST_HAS_CLONE 0
450
#endif // GTEST_OS_LINUX && !defined(__ia64__)
451
452
#endif // GTEST_HAS_CLONE
453
454
// Determines whether to support death tests.
455
// Google Test does not support death tests for VC 7.1 and earlier for
456
// these reasons:
457
// 1. std::vector does not build in VC 7.1 when exceptions are disabled.
458
// 2. std::string does not build in VC 7.1 when exceptions are disabled
459
// (this is covered by GTEST_HAS_STD_STRING guard).
460
// 3. abort() in a VC 7.1 application compiled as GUI in debug config
461
// pops up a dialog window that cannot be suppressed programmatically.
462
#if GTEST_HAS_STD_STRING && \
463
(GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || \
464
(GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW)
465
#define GTEST_HAS_DEATH_TEST 1
466
#include <vector> // NOLINT
467
#endif
468
469
// Determines whether to support value-parameterized tests.
470
471
#if defined(__GNUC__) || (_MSC_VER >= 1400)
472
// TODO(vladl@google.com): get the implementation rid of vector and list
473
// to compile on MSVC 7.1.
474
#define GTEST_HAS_PARAM_TEST 1
475
#endif // defined(__GNUC__) || (_MSC_VER >= 1400)
476
477
// Determines whether to support type-driven tests.
478
479
// Typed tests need <typeinfo> and variadic macros, which gcc and VC
480
// 8.0+ support.
481
#if defined(__GNUC__) || (_MSC_VER >= 1400)
482
#define GTEST_HAS_TYPED_TEST 1
483
#define GTEST_HAS_TYPED_TEST_P 1
484
#endif // defined(__GNUC__) || (_MSC_VER >= 1400)
485
486
// Determines whether to support Combine(). This only makes sense when
487
// value-parameterized tests are enabled.
488
#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
489
#define GTEST_HAS_COMBINE 1
490
#endif // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
491
492
// Determines whether the system compiler uses UTF-16 for encoding wide strings.
493
#define GTEST_WIDE_STRING_USES_UTF16_ \
494
(GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN)
495
496
// Defines some utility macros.
497
498
// The GNU compiler emits a warning if nested "if" statements are followed by
499
// an "else" statement and braces are not used to explicitly disambiguate the
500
// "else" binding. This leads to problems with code like:
501
//
502
// if (gate)
503
// ASSERT_*(condition) << "Some message";
504
//
505
// The "switch (0) case 0:" idiom is used to suppress this.
506
#ifdef __INTEL_COMPILER
507
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_
508
#else
509
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: // NOLINT
510
#endif
511
512
// Use this annotation at the end of a struct/class definition to
513
// prevent the compiler from optimizing away instances that are never
514
// used. This is useful when all interesting logic happens inside the
515
// c'tor and / or d'tor. Example:
516
//
517
// struct Foo {
518
// Foo() { ... }
519
// } GTEST_ATTRIBUTE_UNUSED_;
520
//
521
// Also use it after a variable or parameter declaration to tell the
522
// compiler the variable/parameter does not have to be used.
523
#if defined(__GNUC__) && !defined(COMPILER_ICC)
524
#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
525
#else
526
#define GTEST_ATTRIBUTE_UNUSED_
527
#endif
528
529
// A macro to disallow the evil copy constructor and operator= functions
530
// This should be used in the private: declarations for a class.
531
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
532
type(const type &);\
533
void operator=(const type &)
534
535
// Tell the compiler to warn about unused return values for functions declared
536
// with this macro. The macro should be used on function declarations
537
// following the argument list:
538
//
539
// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
540
#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
541
#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
542
#else
543
#define GTEST_MUST_USE_RESULT_
544
#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
545
546
// Determine whether the compiler supports Microsoft's Structured Exception
547
// Handling. This is supported by several Windows compilers but generally
548
// does not exist on any other system.
549
#ifndef GTEST_HAS_SEH
550
// The user didn't tell us, so we need to figure it out.
551
552
#if defined(_MSC_VER) || defined(__BORLANDC__)
553
// These two compilers are known to support SEH.
554
#define GTEST_HAS_SEH 1
555
#else
556
// Assume no SEH.
557
#define GTEST_HAS_SEH 0
558
#endif
559
560
#endif // GTEST_HAS_SEH
561
562
namespace testing {
563
564
class Message;
565
566
namespace internal {
567
568
class String;
569
570
// std::strstream is deprecated. However, we have to use it on
571
// Windows as std::stringstream won't compile on Windows when
572
// exceptions are disabled. We use std::stringstream on other
573
// platforms to avoid compiler warnings there.
574
#if GTEST_HAS_STD_STRING
575
typedef ::std::stringstream StrStream;
576
#else
577
typedef ::std::strstream StrStream;
578
#endif // GTEST_HAS_STD_STRING
579
580
// A helper for suppressing warnings on constant condition. It just
581
// returns 'condition'.
582
bool IsTrue(bool condition);
583
584
// Defines scoped_ptr.
585
586
// This implementation of scoped_ptr is PARTIAL - it only contains
587
// enough stuff to satisfy Google Test's need.
588
template <typename T>
589
class scoped_ptr {
590
public:
591
explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
592
~scoped_ptr() { reset(); }
593
594
T& operator*() const { return *ptr_; }
595
T* operator->() const { return ptr_; }
596
T* get() const { return ptr_; }
597
598
T* release() {
599
T* const ptr = ptr_;
600
ptr_ = NULL;
601
return ptr;
602
}
603
604
void reset(T* p = NULL) {
605
if (p != ptr_) {
606
if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type.
607
delete ptr_;
608
}
609
ptr_ = p;
610
}
611
}
612
private:
613
T* ptr_;
614
615
GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
616
};
617
618
// Defines RE.
619
620
// A simple C++ wrapper for <regex.h>. It uses the POSIX Enxtended
621
// Regular Expression syntax.
622
class RE {
623
public:
624
// Constructs an RE from a string.
625
#if GTEST_HAS_STD_STRING
626
RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT
627
#endif // GTEST_HAS_STD_STRING
628
629
#if GTEST_HAS_GLOBAL_STRING
630
RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT
631
#endif // GTEST_HAS_GLOBAL_STRING
632
633
RE(const char* regex) { Init(regex); } // NOLINT
634
~RE();
635
636
// Returns the string representation of the regex.
637
const char* pattern() const { return pattern_; }
638
639
// FullMatch(str, re) returns true iff regular expression re matches
640
// the entire str.
641
// PartialMatch(str, re) returns true iff regular expression re
642
// matches a substring of str (including str itself).
643
//
644
// TODO(wan@google.com): make FullMatch() and PartialMatch() work
645
// when str contains NUL characters.
646
#if GTEST_HAS_STD_STRING
647
static bool FullMatch(const ::std::string& str, const RE& re) {
648
return FullMatch(str.c_str(), re);
649
}
650
static bool PartialMatch(const ::std::string& str, const RE& re) {
651
return PartialMatch(str.c_str(), re);
652
}
653
#endif // GTEST_HAS_STD_STRING
654
655
#if GTEST_HAS_GLOBAL_STRING
656
static bool FullMatch(const ::string& str, const RE& re) {
657
return FullMatch(str.c_str(), re);
658
}
659
static bool PartialMatch(const ::string& str, const RE& re) {
660
return PartialMatch(str.c_str(), re);
661
}
662
#endif // GTEST_HAS_GLOBAL_STRING
663
664
static bool FullMatch(const char* str, const RE& re);
665
static bool PartialMatch(const char* str, const RE& re);
666
667
private:
668
void Init(const char* regex);
669
670
// We use a const char* instead of a string, as Google Test may be used
671
// where string is not available. We also do not use Google Test's own
672
// String type here, in order to simplify dependencies between the
673
// files.
674
const char* pattern_;
675
bool is_valid_;
676
#if GTEST_USES_POSIX_RE
677
regex_t full_regex_; // For FullMatch().
678
regex_t partial_regex_; // For PartialMatch().
679
#else // GTEST_USES_SIMPLE_RE
680
const char* full_pattern_; // For FullMatch();
681
#endif
682
683
GTEST_DISALLOW_COPY_AND_ASSIGN_(RE);
684
};
685
686
// Defines logging utilities:
687
// GTEST_LOG_(severity) - logs messages at the specified severity level. The
688
// message itself is streamed into the macro.
689
// LogToStderr() - directs all log messages to stderr.
690
// FlushInfoLog() - flushes informational log messages.
691
692
enum GTestLogSeverity {
693
GTEST_INFO,
694
GTEST_WARNING,
695
GTEST_ERROR,
696
GTEST_FATAL
697
};
698
699
// Formats log entry severity, provides a stream object for streaming the
700
// log message, and terminates the message with a newline when going out of
701
// scope.
702
class GTestLog {
703
public:
704
GTestLog(GTestLogSeverity severity, const char* file, int line);
705
706
// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
707
~GTestLog();
708
709
::std::ostream& GetStream() { return ::std::cerr; }
710
711
private:
712
const GTestLogSeverity severity_;
713
714
GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
715
};
716
717
#define GTEST_LOG_(severity) \
718
::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
719
__FILE__, __LINE__).GetStream()
720
721
inline void LogToStderr() {}
722
inline void FlushInfoLog() { fflush(NULL); }
723
724
// Defines the stderr capturer:
725
// CaptureStderr - starts capturing stderr.
726
// GetCapturedStderr - stops capturing stderr and returns the captured string.
727
728
void CaptureStderr();
729
String GetCapturedStderr();
730
731
#if GTEST_HAS_DEATH_TEST
732
733
// A copy of all command line arguments. Set by InitGoogleTest().
734
extern ::std::vector<String> g_argvs;
735
736
// GTEST_HAS_DEATH_TEST implies we have ::std::string.
737
const ::std::vector<String>& GetArgvs();
738
739
#endif // GTEST_HAS_DEATH_TEST
740
741
// Defines synchronization primitives.
742
743
// A dummy implementation of synchronization primitives (mutex, lock,
744
// and thread-local variable). Necessary for compiling Google Test where
745
// mutex is not supported - using Google Test in multiple threads is not
746
// supported on such platforms.
747
748
class Mutex {
749
public:
750
Mutex() {}
751
explicit Mutex(int /*unused*/) {}
752
void AssertHeld() const {}
753
enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 };
754
};
755
756
// We cannot call it MutexLock directly as the ctor declaration would
757
// conflict with a macro named MutexLock, which is defined on some
758
// platforms. Hence the typedef trick below.
759
class GTestMutexLock {
760
public:
761
explicit GTestMutexLock(Mutex*) {} // NOLINT
762
};
763
764
typedef GTestMutexLock MutexLock;
765
766
template <typename T>
767
class ThreadLocal {
768
public:
769
ThreadLocal() : value_() {}
770
explicit ThreadLocal(const T& value) : value_(value) {}
771
T* pointer() { return &value_; }
772
const T* pointer() const { return &value_; }
773
const T& get() const { return value_; }
774
void set(const T& value) { value_ = value; }
775
private:
776
T value_;
777
};
778
779
// Returns the number of threads running in the process, or 0 to indicate that
780
// we cannot detect it.
781
size_t GetThreadCount();
782
783
// The above synchronization primitives have dummy implementations.
784
// Therefore Google Test is not thread-safe.
785
#define GTEST_IS_THREADSAFE 0
786
787
#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
788
789
// Passing non-POD classes through ellipsis (...) crashes the ARM
790
// compiler. The Nokia Symbian and the IBM XL C/C++ compiler try to
791
// instantiate a copy constructor for objects passed through ellipsis
792
// (...), failing for uncopyable objects. We define this to indicate
793
// the fact.
794
#define GTEST_ELLIPSIS_NEEDS_COPY_ 1
795
796
// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
797
// const T& and const T* in a function template. These compilers
798
// _can_ decide between class template specializations for T and T*,
799
// so a tr1::type_traits-like is_pointer works.
800
#define GTEST_NEEDS_IS_POINTER_ 1
801
802
#endif // defined(__SYMBIAN32__) || defined(__IBMCPP__)
803
804
template <bool bool_value>
805
struct bool_constant {
806
typedef bool_constant<bool_value> type;
807
static const bool value = bool_value;
808
};
809
template <bool bool_value> const bool bool_constant<bool_value>::value;
810
811
typedef bool_constant<false> false_type;
812
typedef bool_constant<true> true_type;
813
814
template <typename T>
815
struct is_pointer : public false_type {};
816
817
template <typename T>
818
struct is_pointer<T*> : public true_type {};
819
820
#if GTEST_OS_WINDOWS
821
#define GTEST_PATH_SEP_ "\\"
822
// The biggest signed integer type the compiler supports.
823
typedef __int64 BiggestInt;
824
#else
825
#define GTEST_PATH_SEP_ "/"
826
typedef long long BiggestInt; // NOLINT
827
#endif // GTEST_OS_WINDOWS
828
829
// The testing::internal::posix namespace holds wrappers for common
830
// POSIX functions. These wrappers hide the differences between
831
// Windows/MSVC and POSIX systems. Since some compilers define these
832
// standard functions as macros, the wrapper cannot have the same name
833
// as the wrapped function.
834
835
namespace posix {
836
837
// Functions with a different name on Windows.
838
839
#if GTEST_OS_WINDOWS
840
841
typedef struct _stat StatStruct;
842
843
#ifdef __BORLANDC__
844
inline int IsATTY(int fd) { return isatty(fd); }
845
inline int StrCaseCmp(const char* s1, const char* s2) {
846
return stricmp(s1, s2);
847
}
848
inline char* StrDup(const char* src) { return strdup(src); }
849
#else // !__BORLANDC__
850
#if GTEST_OS_WINDOWS_MOBILE
851
inline int IsATTY(int /* fd */) { return 0; }
852
#else
853
inline int IsATTY(int fd) { return _isatty(fd); }
854
#endif // GTEST_OS_WINDOWS_MOBILE
855
inline int StrCaseCmp(const char* s1, const char* s2) {
856
return _stricmp(s1, s2);
857
}
858
inline char* StrDup(const char* src) { return _strdup(src); }
859
#endif // __BORLANDC__
860
861
#if GTEST_OS_WINDOWS_MOBILE
862
inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
863
// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
864
// time and thus not defined there.
865
#else
866
inline int FileNo(FILE* file) { return _fileno(file); }
867
inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
868
inline int RmDir(const char* dir) { return _rmdir(dir); }
869
inline bool IsDir(const StatStruct& st) {
870
return (_S_IFDIR & st.st_mode) != 0;
871
}
872
#endif // GTEST_OS_WINDOWS_MOBILE
873
874
#else
875
876
typedef struct stat StatStruct;
877
878
inline int FileNo(FILE* file) { return fileno(file); }
879
inline int IsATTY(int fd) { return isatty(fd); }
880
inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
881
inline int StrCaseCmp(const char* s1, const char* s2) {
882
return strcasecmp(s1, s2);
883
}
884
inline char* StrDup(const char* src) { return strdup(src); }
885
inline int RmDir(const char* dir) { return rmdir(dir); }
886
inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
887
888
#endif // GTEST_OS_WINDOWS
889
890
// Functions deprecated by MSVC 8.0.
891
892
#ifdef _MSC_VER
893
// Temporarily disable warning 4996 (deprecated function).
894
#pragma warning(push)
895
#pragma warning(disable:4996)
896
#endif
897
898
inline const char* StrNCpy(char* dest, const char* src, size_t n) {
899
return strncpy(dest, src, n);
900
}
901
902
// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
903
// StrError() aren't needed on Windows CE at this time and thus not
904
// defined there.
905
906
#if !GTEST_OS_WINDOWS_MOBILE
907
inline int ChDir(const char* dir) { return chdir(dir); }
908
#endif
909
inline FILE* FOpen(const char* path, const char* mode) {
910
return fopen(path, mode);
911
}
912
#if !GTEST_OS_WINDOWS_MOBILE
913
inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
914
return freopen(path, mode, stream);
915
}
916
inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
917
#endif
918
inline int FClose(FILE* fp) { return fclose(fp); }
919
#if !GTEST_OS_WINDOWS_MOBILE
920
inline int Read(int fd, void* buf, unsigned int count) {
921
return static_cast<int>(read(fd, buf, count));
922
}
923
inline int Write(int fd, const void* buf, unsigned int count) {
924
return static_cast<int>(write(fd, buf, count));
925
}
926
inline int Close(int fd) { return close(fd); }
927
inline const char* StrError(int errnum) { return strerror(errnum); }
928
#endif
929
inline const char* GetEnv(const char* name) {
930
#if GTEST_OS_WINDOWS_MOBILE
931
// We are on Windows CE, which has no environment variables.
932
return NULL;
933
#elif defined(__BORLANDC__)
934
// Environment variables which we programmatically clear will be set to the
935
// empty string rather than unset (NULL). Handle that case.
936
const char* const env = getenv(name);
937
return (env != NULL && env[0] != '\0') ? env : NULL;
938
#else
939
return getenv(name);
940
#endif
941
}
942
943
#ifdef _MSC_VER
944
#pragma warning(pop) // Restores the warning state.
945
#endif
946
947
#if GTEST_OS_WINDOWS_MOBILE
948
// Windows CE has no C library. The abort() function is used in
949
// several places in Google Test. This implementation provides a reasonable
950
// imitation of standard behaviour.
951
void Abort();
952
#else
953
inline void Abort() { abort(); }
954
#endif // GTEST_OS_WINDOWS_MOBILE
955
956
} // namespace posix
957
958
// The maximum number a BiggestInt can represent. This definition
959
// works no matter BiggestInt is represented in one's complement or
960
// two's complement.
961
//
962
// We cannot rely on numeric_limits in STL, as __int64 and long long
963
// are not part of standard C++ and numeric_limits doesn't need to be
964
// defined for them.
965
const BiggestInt kMaxBiggestInt =
966
~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
967
968
// This template class serves as a compile-time function from size to
969
// type. It maps a size in bytes to a primitive type with that
970
// size. e.g.
971
//
972
// TypeWithSize<4>::UInt
973
//
974
// is typedef-ed to be unsigned int (unsigned integer made up of 4
975
// bytes).
976
//
977
// Such functionality should belong to STL, but I cannot find it
978
// there.
979
//
980
// Google Test uses this class in the implementation of floating-point
981
// comparison.
982
//
983
// For now it only handles UInt (unsigned int) as that's all Google Test
984
// needs. Other types can be easily added in the future if need
985
// arises.
986
template <size_t size>
987
class TypeWithSize {
988
public:
989
// This prevents the user from using TypeWithSize<N> with incorrect
990
// values of N.
991
typedef void UInt;
992
};
993
994
// The specialization for size 4.
995
template <>
996
class TypeWithSize<4> {
997
public:
998
// unsigned int has size 4 in both gcc and MSVC.
999
//
1000
// As base/basictypes.h doesn't compile on Windows, we cannot use
1001
// uint32, uint64, and etc here.
1002
typedef int Int;
1003
typedef unsigned int UInt;
1004
};
1005
1006
// The specialization for size 8.
1007
template <>
1008
class TypeWithSize<8> {
1009
public:
1010
#if GTEST_OS_WINDOWS
1011
typedef __int64 Int;
1012
typedef unsigned __int64 UInt;
1013
#else
1014
typedef long long Int; // NOLINT
1015
typedef unsigned long long UInt; // NOLINT
1016
#endif // GTEST_OS_WINDOWS
1017
};
1018
1019
// Integer types of known sizes.
1020
typedef TypeWithSize<4>::Int Int32;
1021
typedef TypeWithSize<4>::UInt UInt32;
1022
typedef TypeWithSize<8>::Int Int64;
1023
typedef TypeWithSize<8>::UInt UInt64;
1024
typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds.
1025
1026
// Utilities for command line flags and environment variables.
1027
1028
// INTERNAL IMPLEMENTATION - DO NOT USE.
1029
//
1030
// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
1031
// is not satisfied.
1032
// Synopsys:
1033
// GTEST_CHECK_(boolean_condition);
1034
// or
1035
// GTEST_CHECK_(boolean_condition) << "Additional message";
1036
//
1037
// This checks the condition and if the condition is not satisfied
1038
// it prints message about the condition violation, including the
1039
// condition itself, plus additional message streamed into it, if any,
1040
// and then it aborts the program. It aborts the program irrespective of
1041
// whether it is built in the debug mode or not.
1042
#define GTEST_CHECK_(condition) \
1043
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1044
if (::testing::internal::IsTrue(condition)) \
1045
; \
1046
else \
1047
GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1048
1049
// Macro for referencing flags.
1050
#define GTEST_FLAG(name) FLAGS_gtest_##name
1051
1052
// Macros for declaring flags.
1053
#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name)
1054
#define GTEST_DECLARE_int32_(name) \
1055
extern ::testing::internal::Int32 GTEST_FLAG(name)
1056
#define GTEST_DECLARE_string_(name) \
1057
extern ::testing::internal::String GTEST_FLAG(name)
1058
1059
// Macros for defining flags.
1060
#define GTEST_DEFINE_bool_(name, default_val, doc) \
1061
bool GTEST_FLAG(name) = (default_val)
1062
#define GTEST_DEFINE_int32_(name, default_val, doc) \
1063
::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
1064
#define GTEST_DEFINE_string_(name, default_val, doc) \
1065
::testing::internal::String GTEST_FLAG(name) = (default_val)
1066
1067
// Parses 'str' for a 32-bit signed integer. If successful, writes the result
1068
// to *value and returns true; otherwise leaves *value unchanged and returns
1069
// false.
1070
// TODO(chandlerc): Find a better way to refactor flag and environment parsing
1071
// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
1072
// function.
1073
bool ParseInt32(const Message& src_text, const char* str, Int32* value);
1074
1075
// Parses a bool/Int32/string from the environment variable
1076
// corresponding to the given Google Test flag.
1077
bool BoolFromGTestEnv(const char* flag, bool default_val);
1078
Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
1079
const char* StringFromGTestEnv(const char* flag, const char* default_val);
1080
1081
} // namespace internal
1082
} // namespace testing
1083
1084
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
Loggerhead is a web-based interface for Breezy
Version: 2.0.1