Joseph Davies
10 years ago
211 changed files with 190719 additions and 9 deletions
@ -0,0 +1,7 @@
|
||||
set(gtest_force_shared_crt ON CACHE INTERNAL "don't link the CRT statically into gtest as we later link the test executable dynamically") |
||||
add_subdirectory(gtest-1.6.0) |
||||
|
||||
add_subdirectory(CoreTests) |
||||
add_subdirectory(NucleusTests) |
||||
add_subdirectory(PubUtilTests) |
||||
add_subdirectory(FeatureTests) |
@ -0,0 +1,15 @@
|
||||
include_directories(${GTEST_INCLUDE_DIR}) |
||||
include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR}) |
||||
include_directories(../../Plasma/CoreLib) |
||||
|
||||
SET(CoreLibTest_SOURCES |
||||
test_plString.cpp |
||||
) |
||||
|
||||
add_executable(test_CoreLib ${CoreLibTest_SOURCES}) |
||||
|
||||
target_link_libraries(test_CoreLib gtest gtest_main) |
||||
target_link_libraries(test_CoreLib CoreLib) |
||||
|
||||
add_test(NAME test_CoreLib COMMAND test_CoreLib) |
||||
add_dependencies(check test_CoreLib) |
@ -0,0 +1,278 @@
|
||||
#include <plString.h> |
||||
#include <HeadSpin.h> |
||||
|
||||
#include <gtest/gtest.h> |
||||
#include <wchar.h> |
||||
|
||||
|
||||
TEST(PlStringTest,ToUtf16) |
||||
{ |
||||
uint16_t text[] = {0x0061,0x0062,0x0063,0x0064}; //abcd as in utf16
|
||||
plStringBuffer<uint16_t> expected = plStringBuffer<uint16_t>(text,arrsize(text)); |
||||
plStringBuffer<uint16_t> output = plString("abcd").ToUtf16(); |
||||
|
||||
EXPECT_EQ(expected.GetSize(), output.GetSize()); //not really a good test
|
||||
} |
||||
|
||||
TEST(PlStringTest,ToWchar) |
||||
{ |
||||
wchar_t text[] =L"abcd\u00E9"; |
||||
plStringBuffer<wchar_t> expected = plStringBuffer<wchar_t>(text,arrsize(text)); |
||||
plStringBuffer<wchar_t> output = plString("abcd\xC3\xA9").ToWchar(); |
||||
EXPECT_STREQ(expected.GetData(),output.GetData()); |
||||
} |
||||
|
||||
TEST(PlStringTest,ToIso8859_1) |
||||
{ |
||||
char text[] ="abcde"; |
||||
plStringBuffer<char> expected = plStringBuffer<char>(text,arrsize(text)); |
||||
plStringBuffer<char> output = plString("abcde").ToIso8859_1(); |
||||
EXPECT_STREQ(expected.GetData(),output.GetData()); |
||||
} |
||||
|
||||
TEST(PlStringTest,FindChar) |
||||
{ |
||||
plString input = plString("abCdcBAeab"); |
||||
int result=0; |
||||
//available char, case sensitive
|
||||
result = input.Find('B',plString::kCaseSensitive); |
||||
EXPECT_EQ(5,result); |
||||
|
||||
//available char, case insensitive
|
||||
result = input.Find('B',plString::kCaseInsensitive); |
||||
EXPECT_EQ(1,result); |
||||
|
||||
//unavailable char, case sensitive
|
||||
result = input.Find('f',plString::kCaseSensitive); |
||||
EXPECT_EQ(-1,result); |
||||
|
||||
//unavailable char, case insensitive
|
||||
result=0; |
||||
result = input.Find('f',plString::kCaseInsensitive); |
||||
EXPECT_EQ(-1,result); |
||||
|
||||
plString input1 = plString("abCdcBÁèab"); |
||||
//available accented char, case sensitive
|
||||
result = input1.Find('Á',plString::kCaseSensitive); |
||||
EXPECT_EQ(7,result); |
||||
|
||||
//available accented char, case insensitive
|
||||
result = input1.Find('è',plString::kCaseInsensitive); |
||||
EXPECT_EQ(9,result); |
||||
} |
||||
|
||||
TEST(PlStringTest,FindLast) |
||||
{ |
||||
plString input = plString("abCdcBAeab"); |
||||
int result=0; |
||||
//available char, case sensitive
|
||||
result = input.FindLast('B',plString::kCaseSensitive); |
||||
EXPECT_EQ(5,result); |
||||
|
||||
//available char, case insensitive
|
||||
result = input.FindLast('B',plString::kCaseInsensitive); |
||||
EXPECT_EQ(9,result); |
||||
|
||||
//unavailable char, case sensitive
|
||||
result = input.FindLast('f',plString::kCaseSensitive); |
||||
EXPECT_EQ(-1,result); |
||||
|
||||
//unavailable char, case insensitive
|
||||
result=0; |
||||
result = input.FindLast('f',plString::kCaseInsensitive); |
||||
EXPECT_EQ(-1,result); |
||||
|
||||
plString input1 = plString("éeÉß"); |
||||
//available accented char, case sensitive
|
||||
result = input1.FindLast('e',plString::kCaseSensitive); |
||||
EXPECT_EQ(2,result); |
||||
|
||||
//available accented char, case insensitive
|
||||
result = input1.FindLast('ß',plString::kCaseInsensitive); |
||||
EXPECT_EQ(6,result); |
||||
} |
||||
|
||||
TEST(PlStringTest,FindString) |
||||
{ |
||||
plString input = plString("abABÁè"); |
||||
int result=0; |
||||
//available string, case sensitive
|
||||
result = input.Find("AB",plString::kCaseSensitive); |
||||
EXPECT_EQ(2,result); |
||||
|
||||
//available string, case insensitive
|
||||
result = input.Find("ab",plString::kCaseInsensitive); |
||||
EXPECT_EQ(0,result); |
||||
|
||||
//unavailable string, case sensitive
|
||||
result = input.Find("cd",plString::kCaseSensitive); |
||||
EXPECT_EQ(-1,result); |
||||
|
||||
//unavailable string, case insensitive
|
||||
result=0; |
||||
result = input.Find("cd",plString::kCaseInsensitive); |
||||
EXPECT_EQ(-1,result); |
||||
|
||||
plString input1 = plString("àbéCdcBÀéab"); |
||||
//available accented string, case sensitive
|
||||
result = input1.Find("À",plString::kCaseSensitive); |
||||
EXPECT_EQ(9,result); |
||||
|
||||
//the strnicmp method used does not support unicode
|
||||
//available accented string, case insensitive
|
||||
// result = input1.Find("À",plString::kCaseInsensitive);
|
||||
// EXPECT_EQ(1,result);
|
||||
} |
||||
|
||||
//TODO: test regex functions
|
||||
|
||||
TEST(PlStringTest,TrimLeft) |
||||
{ |
||||
plString input = plString("abcdefgh"); |
||||
plString output = input.TrimLeft("abc"); |
||||
plString expected = plString("defgh"); |
||||
EXPECT_EQ(expected,output); |
||||
|
||||
plString input1 = plString("abcdefgh"); |
||||
plString output1 = input1.TrimLeft("bc"); |
||||
EXPECT_EQ(input1,output1); |
||||
} |
||||
|
||||
TEST(PlStringTest,TrimRight) |
||||
{ |
||||
plString input = plString("abcdefgh"); |
||||
plString output = input.TrimRight("fgh"); |
||||
plString expected = plString("abcde"); |
||||
EXPECT_EQ(expected,output); |
||||
|
||||
plString input1 = plString("abcdefgh"); |
||||
plString output1 = input1.TrimRight("fg"); |
||||
EXPECT_EQ(input1,output1); |
||||
} |
||||
|
||||
TEST(PlStringTest,Trim) |
||||
{ |
||||
plString input = plString("abcdefba"); |
||||
plString output = input.Trim("ab"); |
||||
plString expected = plString("cdef"); |
||||
EXPECT_EQ(expected,output); |
||||
|
||||
plString input1 = plString("abcdefba"); |
||||
plString output1 = input1.Trim("f"); |
||||
EXPECT_EQ(input1,output1); |
||||
} |
||||
|
||||
TEST(PlStringTest,Substr) |
||||
{ |
||||
plString input = plString("abcdefgh"); |
||||
|
||||
//start > size returns null
|
||||
plString output = input.Substr(15,1); |
||||
EXPECT_EQ(plString::Null,output); |
||||
|
||||
//start<0
|
||||
plString output1 =input.Substr(-3,3); |
||||
plString expected1 = plString("fgh"); |
||||
EXPECT_EQ(expected1,output1); |
||||
|
||||
//start+size>size string
|
||||
plString output2 =input.Substr(4,6); |
||||
plString expected2 = plString("efgh"); |
||||
EXPECT_EQ(expected2,output2); |
||||
|
||||
//start =0 size = length string
|
||||
plString output3 =input.Substr(0,input.GetSize()); |
||||
EXPECT_EQ(input,output3); |
||||
|
||||
//normal case
|
||||
plString output4 =input.Substr(1,3); |
||||
plString expected4 = plString("bcd"); |
||||
EXPECT_EQ(expected4,output4); |
||||
} |
||||
|
||||
TEST(PlStringTest,Replace) |
||||
{ |
||||
plString input = plString("abcdabcd"); |
||||
|
||||
plString output = input.Replace("ab","cd"); |
||||
plString expected = plString("cdcdcdcd"); |
||||
EXPECT_EQ(expected,output); |
||||
|
||||
plString output1 = input.Replace("a","cd"); |
||||
plString expected1 = plString("cdbcdcdbcd"); |
||||
EXPECT_EQ(expected1,output1); |
||||
|
||||
} |
||||
|
||||
TEST(PlStringTest,ToUpper) |
||||
{ |
||||
plString input = plString("abCDe"); |
||||
plString output = input.ToUpper(); |
||||
plString expected = plString("ABCDE"); |
||||
EXPECT_EQ(expected,output); |
||||
} |
||||
|
||||
TEST(PlStringTest,ToLower) |
||||
{ |
||||
plString input = plString("aBcDe"); |
||||
plString output = input.ToLower(); |
||||
plString expected = plString("abcde"); |
||||
EXPECT_EQ(expected,output); |
||||
} |
||||
|
||||
TEST(PlStringTest,Tokenize) |
||||
{ |
||||
std::vector<plString> expected; |
||||
expected.push_back(plString("a")); |
||||
expected.push_back(plString("b")); |
||||
expected.push_back(plString("c")); |
||||
expected.push_back(plString("d")); |
||||
expected.push_back(plString("è")); |
||||
|
||||
plString input = plString("a\t\tb\n;c-d;è"); |
||||
std::vector<plString> output = input.Tokenize("\t\n-;"); |
||||
EXPECT_EQ(expected,output); |
||||
|
||||
} |
||||
|
||||
TEST(PlStringTest,Split) |
||||
{ |
||||
std::vector<plString> expected; |
||||
expected.push_back(plString("a")); |
||||
expected.push_back(plString("b")); |
||||
expected.push_back(plString("c")); |
||||
expected.push_back(plString("d")); |
||||
expected.push_back(plString("è")); |
||||
|
||||
plString input = plString("a-b-c-d-è"); |
||||
std::vector<plString> output = input.Split("-",4); |
||||
EXPECT_EQ(expected,output); |
||||
|
||||
} |
||||
|
||||
TEST(PlStringTest,Fill) |
||||
{ |
||||
plString expected = plString("aaaaa"); |
||||
plString output = plString::Fill(5,'a'); |
||||
EXPECT_EQ(expected,output); |
||||
} |
||||
|
||||
//overload operator+
|
||||
TEST(PlStringTest,Addition) |
||||
{ |
||||
plString expected = "abcde"; |
||||
plString input1 = "ab"; |
||||
plString input2 = "cde"; |
||||
|
||||
//plstring+plstring
|
||||
plString output = input1+input2; |
||||
EXPECT_EQ(expected,output); |
||||
|
||||
//plstring+char*
|
||||
plString output1 = input1 + input2.c_str(); |
||||
EXPECT_EQ(expected,output1); |
||||
|
||||
//char*+plstring
|
||||
plString output2 = input1.c_str() + input2; |
||||
EXPECT_EQ(expected,output2); |
||||
} |
@ -0,0 +1 @@
|
||||
add_subdirectory(pfPythonTest) |
@ -0,0 +1,121 @@
|
||||
include_directories(${GTEST_INCLUDE_DIR}) |
||||
include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR}) |
||||
include_directories(../../../Plasma/CoreLib) |
||||
include_directories(../../../Plasma/NucleusLib) |
||||
include_directories(../../../Plasma/NucleusLib/inc) |
||||
include_directories(../../../Plasma/PubUtilLib) |
||||
include_directories(../../../Plasma/PubUtilLib/inc) |
||||
include_directories(../../../Plasma/FeatureLib) |
||||
include_directories(../../../Plasma/FeatureLib/inc) |
||||
|
||||
set(pfPythonTest_SOURCES |
||||
test_cyMisc.cpp |
||||
) |
||||
|
||||
add_executable(test_pfPython ${pfPythonTest_SOURCES}) |
||||
target_link_libraries(test_pfPython gtest gtest_main) |
||||
|
||||
target_link_libraries(test_pfPython CoreLib) |
||||
target_link_libraries(test_pfPython pfAnimation) |
||||
target_link_libraries(test_pfPython pfAudio) |
||||
target_link_libraries(test_pfPython pfCamera) |
||||
target_link_libraries(test_pfPython pfCCR) |
||||
target_link_libraries(test_pfPython pfCharacter) |
||||
target_link_libraries(test_pfPython pfConditional) |
||||
target_link_libraries(test_pfPython pfConsole) |
||||
target_link_libraries(test_pfPython pfConsoleCore) |
||||
target_link_libraries(test_pfPython pfGameGUIMgr) |
||||
target_link_libraries(test_pfPython pfGameMgr) |
||||
target_link_libraries(test_pfPython pfGameScoreMgr) |
||||
target_link_libraries(test_pfPython pfJournalBook) |
||||
target_link_libraries(test_pfPython pfLocalizationMgr) |
||||
target_link_libraries(test_pfPython pfMessage) |
||||
target_link_libraries(test_pfPython pfPython) |
||||
target_link_libraries(test_pfPython pfSurface) |
||||
target_link_libraries(test_pfPython plAgeDescription) |
||||
target_link_libraries(test_pfPython plAgeLoader) |
||||
target_link_libraries(test_pfPython plAudible) |
||||
target_link_libraries(test_pfPython plAudio) |
||||
target_link_libraries(test_pfPython plAudioCore) |
||||
target_link_libraries(test_pfPython plAvatar) |
||||
target_link_libraries(test_pfPython plClientResMgr) |
||||
target_link_libraries(test_pfPython plClipboard) |
||||
target_link_libraries(test_pfPython plCompression) |
||||
target_link_libraries(test_pfPython plContainer) |
||||
target_link_libraries(test_pfPython plDrawable) |
||||
target_link_libraries(test_pfPython plFile) |
||||
target_link_libraries(test_pfPython plGImage) |
||||
target_link_libraries(test_pfPython plGLight) |
||||
target_link_libraries(test_pfPython plInputCore) |
||||
target_link_libraries(test_pfPython plInterp) |
||||
target_link_libraries(test_pfPython plIntersect) |
||||
target_link_libraries(test_pfPython plMath) |
||||
target_link_libraries(test_pfPython plMessage) |
||||
target_link_libraries(test_pfPython plModifier) |
||||
target_link_libraries(test_pfPython plNetClient) |
||||
target_link_libraries(test_pfPython plNetClientComm) |
||||
target_link_libraries(test_pfPython plNetClientRecorder) |
||||
target_link_libraries(test_pfPython plNetCommon) |
||||
target_link_libraries(test_pfPython plNetGameLib) |
||||
target_link_libraries(test_pfPython plNetMessage) |
||||
target_link_libraries(test_pfPython plNetTransport) |
||||
target_link_libraries(test_pfPython plParticleSystem) |
||||
target_link_libraries(test_pfPython plPhysical) |
||||
target_link_libraries(test_pfPython plPhysX) |
||||
target_link_libraries(test_pfPython plPipeline) |
||||
target_link_libraries(test_pfPython plProgressMgr) |
||||
target_link_libraries(test_pfPython plResMgr) |
||||
target_link_libraries(test_pfPython plScene) |
||||
target_link_libraries(test_pfPython plSDL) |
||||
target_link_libraries(test_pfPython plStatGather) |
||||
target_link_libraries(test_pfPython plStatusLog) |
||||
target_link_libraries(test_pfPython plStreamLogger) |
||||
target_link_libraries(test_pfPython plSurface) |
||||
target_link_libraries(test_pfPython plTransform) |
||||
target_link_libraries(test_pfPython plUnifiedTime) |
||||
target_link_libraries(test_pfPython plVault) |
||||
target_link_libraries(test_pfPython pnAsyncCore) |
||||
target_link_libraries(test_pfPython pnAsyncCoreExe) |
||||
target_link_libraries(test_pfPython pnDispatch) |
||||
target_link_libraries(test_pfPython pnEncryption) |
||||
target_link_libraries(test_pfPython pnFactory) |
||||
target_link_libraries(test_pfPython pnGameMgr) |
||||
target_link_libraries(test_pfPython pnInputCore) |
||||
target_link_libraries(test_pfPython pnKeyedObject) |
||||
target_link_libraries(test_pfPython pnMessage) |
||||
target_link_libraries(test_pfPython pnModifier) |
||||
target_link_libraries(test_pfPython pnNetBase) |
||||
target_link_libraries(test_pfPython pnNetCli) |
||||
target_link_libraries(test_pfPython pnNetCommon) |
||||
target_link_libraries(test_pfPython pnNetProtocol) |
||||
target_link_libraries(test_pfPython pnNucleusInc) |
||||
target_link_libraries(test_pfPython pnSceneObject) |
||||
target_link_libraries(test_pfPython pnTimer) |
||||
target_link_libraries(test_pfPython pnUtils) |
||||
target_link_libraries(test_pfPython pnUUID) |
||||
|
||||
target_link_libraries(test_pfPython ${PYTHON_LIBRARIES}) |
||||
|
||||
target_link_libraries(test_pfPython ${OPENAL_LIBRARY}) |
||||
target_link_libraries(test_pfPython ${OPENSSL_LIBRARIES}) |
||||
target_link_libraries(test_pfPython ${EXPAT_LIBRARY}) |
||||
target_link_libraries(test_pfPython ${JPEG_LIBRARY}) |
||||
target_link_libraries(test_pfPython ${PNG_LIBRARY}) |
||||
target_link_libraries(test_pfPython ${Speex_LIBRARY}) |
||||
target_link_libraries(test_pfPython ${PHYSX_LIBRARIES}) |
||||
target_link_libraries(test_pfPython ${Ogg_LIBRARIES}) |
||||
target_link_libraries(test_pfPython ${Vorbis_LIBRARIES}) |
||||
target_link_libraries(test_pfPython ${DirectX_LIBRARIES}) |
||||
target_link_libraries(test_pfPython ${CURL_LIBRARY}) |
||||
|
||||
if (WIN32) |
||||
target_link_libraries(test_pfPython Rpcrt4) |
||||
target_link_libraries(test_pfPython Version) |
||||
target_link_libraries(test_pfPython Vfw32) |
||||
target_link_libraries(test_pfPython Ws2_32) |
||||
target_link_libraries(test_pfPython winmm) |
||||
target_link_libraries(test_pfPython strmiids) |
||||
endif(WIN32) |
||||
|
||||
add_test(NAME test_pfPython COMMAND test_pfPython) |
||||
add_dependencies(check test_pfPython) |
@ -0,0 +1,118 @@
|
||||
/*==LICENSE==*
|
||||
|
||||
CyanWorlds.com Engine - MMOG client, server and tools |
||||
Copyright (C) 2011 Cyan Worlds, Inc. |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Additional permissions under GNU GPL version 3 section 7 |
||||
|
||||
If you modify this Program, or any covered work, by linking or |
||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
||||
(or a modified version of those libraries), |
||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
||||
licensors of this Program grant you additional |
||||
permission to convey the resulting work. Corresponding Source for a |
||||
non-source form of such a combination shall include the source code for |
||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
||||
work. |
||||
|
||||
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
||||
or by snail mail at: |
||||
Cyan Worlds, Inc. |
||||
14617 N Newport Hwy |
||||
Mead, WA 99021 |
||||
|
||||
*==LICENSE==*/ |
||||
|
||||
#include <iomanip> |
||||
#include <gtest/gtest.h> |
||||
|
||||
#include "pnAllCreatables.h" |
||||
#include "plAllCreatables.h" |
||||
#include "pfAllCreatables.h" |
||||
|
||||
#include "pfPython/cyMisc.h" |
||||
|
||||
// from zoneinfo/America/Denver version 2011g
|
||||
static const time_t dsttransitions[] = { |
||||
0x45F3C510, 0x472D7C00, |
||||
0x47D3A710, 0x490D5E00, |
||||
0x49B38910, 0x4AED4000, |
||||
0x4B9CA590, 0x4CD65C80, |
||||
0x4D7C8790, 0x4EB63E80, |
||||
0x4F5C6990, 0x50962080, |
||||
0x513C4B90, 0x52760280, |
||||
0x531C2D90, 0x5455E480, |
||||
0x54FC0F90, 0x5635C680, |
||||
0x56E52C10, 0x581EE300, |
||||
0x58C50E10, 0x59FEC500, |
||||
0x5AA4F010, 0x5BDEA700, |
||||
0x5C84D210, 0x5DBE8900, |
||||
0x5E64B410, 0x5F9E6B00, |
||||
0x604DD090, 0x61878780, |
||||
0x622DB290, 0x63676980, |
||||
0x640D9490, 0x65474B80, |
||||
0x65ED7690, 0x67272D80, |
||||
0x67CD5890, 0x69070F80, |
||||
0x69AD3A90, 0x6AE6F180, |
||||
0x6B965710, 0x6CD00E00, |
||||
0x6D763910, 0x6EAFF000, |
||||
0x6F561B10, 0x708FD200, |
||||
0x7135FD10, 0x726FB400, |
||||
0x7315DF10, 0x744F9600, |
||||
0x74FEFB90, 0x7638B280, |
||||
0x76DEDD90, 0x78189480, |
||||
0x78BEBF90, 0x79F87680, |
||||
0x7A9EA190, 0x7BD85880, |
||||
0x7C7E8390, 0x7DB83A80, |
||||
0x7E5E6590, 0x7F981C80 |
||||
}; |
||||
|
||||
static ::testing::AssertionResult TmHasHourMinSec(struct tm *tm, int hour, int min, int sec) { |
||||
if (tm->tm_hour == hour && tm->tm_min == min && tm->tm_sec == sec) { |
||||
return ::testing::AssertionSuccess(); |
||||
} |
||||
else { |
||||
char buf[128]; |
||||
strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S", tm); |
||||
return ::testing::AssertionFailure() << "Actual: " << buf << ", Expected: " << hour << ":" << (::testing::Message() << std::setfill('0') << std::setw(2) << min << ":" << std::setw(2) << sec); |
||||
// (intermediate Message required because AssertionResult::operator<< will create a new Message for every invocation, losing the manipulators)
|
||||
} |
||||
} |
||||
|
||||
TEST(cyMisc, ConvertGMTtoDni) |
||||
{ |
||||
for (int i = 0; i < sizeof(dsttransitions)/sizeof(dsttransitions[0]); i += 2) { |
||||
time_t dni1, dni2; |
||||
struct tm *tm; |
||||
dni1 = cyMisc::ConvertGMTtoDni(dsttransitions[i] - 1); |
||||
dni2 = cyMisc::ConvertGMTtoDni(dsttransitions[i]); |
||||
tm = gmtime(&dni1); |
||||
EXPECT_TRUE(TmHasHourMinSec(tm, 1, 59, 59)) << "(start before)"; |
||||
tm = gmtime(&dni2); |
||||
EXPECT_TRUE(TmHasHourMinSec(tm, 3, 0, 0)) << "(start after)"; |
||||
|
||||
dni1 = cyMisc::ConvertGMTtoDni(dsttransitions[i+1] - 1); |
||||
dni2 = cyMisc::ConvertGMTtoDni(dsttransitions[i+1]); |
||||
tm = gmtime(&dni1); |
||||
EXPECT_TRUE(TmHasHourMinSec(tm, 1, 59, 59)) << "(end before)"; |
||||
tm = gmtime(&dni2); |
||||
EXPECT_TRUE(TmHasHourMinSec(tm, 1, 0, 0)) << "(end after)"; |
||||
} |
||||
} |
@ -0,0 +1 @@
|
||||
add_subdirectory(pnEncryptionTest) |
@ -0,0 +1,16 @@
|
||||
include_directories(${GTEST_INCLUDE_DIR}) |
||||
include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR}) |
||||
include_directories(../../../Plasma/CoreLib) |
||||
include_directories(../../../Plasma/NucleusLib) |
||||
|
||||
set(pnEncryptionTest_SOURCES |
||||
test_plMD5Checksum.cpp |
||||
test_plSHA1Checksum.cpp |
||||
) |
||||
|
||||
add_executable(test_pnEncryption ${pnEncryptionTest_SOURCES}) |
||||
target_link_libraries(test_pnEncryption gtest gtest_main) |
||||
target_link_libraries(test_pnEncryption pnEncryption) |
||||
|
||||
add_test(NAME test_pnEncryption COMMAND test_pnEncryption) |
||||
add_dependencies(check test_pnEncryption) |
@ -0,0 +1,60 @@
|
||||
/*==LICENSE==*
|
||||
|
||||
CyanWorlds.com Engine - MMOG client, server and tools |
||||
Copyright (C) 2011 Cyan Worlds, Inc. |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Additional permissions under GNU GPL version 3 section 7 |
||||
|
||||
If you modify this Program, or any covered work, by linking or |
||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
||||
(or a modified version of those libraries), |
||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
||||
licensors of this Program grant you additional |
||||
permission to convey the resulting work. Corresponding Source for a |
||||
non-source form of such a combination shall include the source code for |
||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
||||
work. |
||||
|
||||
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
||||
or by snail mail at: |
||||
Cyan Worlds, Inc. |
||||
14617 N Newport Hwy |
||||
Mead, WA 99021 |
||||
|
||||
*==LICENSE==*/ |
||||
|
||||
#include <cstring> |
||||
#include <gtest/gtest.h> |
||||
#include "pnEncryption/plChecksum.h" |
||||
|
||||
TEST(plMD5Checksum, ctor_with_buffer) |
||||
{ |
||||
const char* buffer = "Hello World"; |
||||
const char* hexStr = "b10a8db164e0754105b7a99be72e3fe5"; |
||||
const uint8_t value[16] = {0xb1, 0x0a, 0x8d, 0xb1, 0x64, 0xe0, 0x75, 0x41, |
||||
0x05, 0xb7, 0xa9, 0x9b, 0xe7, 0x2e, 0x3f, 0xe5}; |
||||
|
||||
plMD5Checksum sum(strlen(buffer), (uint8_t*)buffer); |
||||
|
||||
EXPECT_EQ(sum.GetSize(), sizeof(value)); |
||||
EXPECT_EQ(memcmp(sum.GetValue(), value, 16), 0); |
||||
EXPECT_STREQ(sum.GetAsHexString(), hexStr); |
||||
} |
||||
|
@ -0,0 +1,62 @@
|
||||
/*==LICENSE==*
|
||||
|
||||
CyanWorlds.com Engine - MMOG client, server and tools |
||||
Copyright (C) 2011 Cyan Worlds, Inc. |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Additional permissions under GNU GPL version 3 section 7 |
||||
|
||||
If you modify this Program, or any covered work, by linking or |
||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
||||
(or a modified version of those libraries), |
||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
||||
licensors of this Program grant you additional |
||||
permission to convey the resulting work. Corresponding Source for a |
||||
non-source form of such a combination shall include the source code for |
||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
||||
work. |
||||
|
||||
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
||||
or by snail mail at: |
||||
Cyan Worlds, Inc. |
||||
14617 N Newport Hwy |
||||
Mead, WA 99021 |
||||
|
||||
*==LICENSE==*/ |
||||
|
||||
#include <cstring> |
||||
#include <gtest/gtest.h> |
||||
#include "pnEncryption/plChecksum.h" |
||||
|
||||
TEST(plSHA1Checksum, ctor_with_buffer) |
||||
{ |
||||
const char* buffer = "Hello World"; |
||||
const char* hexStr = "0a4d55a8d778e5022fab701977c5d840bbc486d0"; |
||||
const ShaDigest value = {0x0a, 0x4d, 0x55, 0xa8, |
||||
0xd7, 0x78, 0xe5, 0x02, |
||||
0x2f, 0xab, 0x70, 0x19, |
||||
0x77, 0xc5, 0xd8, 0x40, |
||||
0xbb, 0xc4, 0x86, 0xd0}; |
||||
|
||||
plSHA1Checksum sum(strlen(buffer), (uint8_t*)buffer); |
||||
|
||||
EXPECT_EQ(sum.GetSize(), sizeof(value)); |
||||
EXPECT_EQ(memcmp(sum.GetValue(), value, 20), 0); |
||||
EXPECT_STREQ(sum.GetAsHexString(), hexStr); |
||||
} |
@ -0,0 +1,2 @@
|
||||
add_subdirectory(plUnifiedTimeTest) |
||||
|
@ -0,0 +1,16 @@
|
||||
include_directories(${GTEST_INCLUDE_DIR}) |
||||
include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR}) |
||||
include_directories(../../../Plasma/CoreLib) |
||||
include_directories(../../../Plasma/NucleusLib) |
||||
include_directories(../../../Plasma/PubUtilLib) |
||||
|
||||
set(plUnifiedTimeTest_SOURCES |
||||
test_plUnifiedTime.cpp |
||||
) |
||||
|
||||
add_executable(test_plUnifiedTime ${plUnifiedTimeTest_SOURCES}) |
||||
target_link_libraries(test_plUnifiedTime gtest gtest_main) |
||||
target_link_libraries(test_plUnifiedTime plUnifiedTime) |
||||
|
||||
add_test(NAME test_plUnifiedTime COMMAND test_plUnifiedTime) |
||||
add_dependencies(check test_plUnifiedTime) |
@ -0,0 +1,71 @@
|
||||
/*==LICENSE==*
|
||||
|
||||
CyanWorlds.com Engine - MMOG client, server and tools |
||||
Copyright (C) 2011 Cyan Worlds, Inc. |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Additional permissions under GNU GPL version 3 section 7 |
||||
|
||||
If you modify this Program, or any covered work, by linking or |
||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
||||
(or a modified version of those libraries), |
||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
||||
licensors of this Program grant you additional |
||||
permission to convey the resulting work. Corresponding Source for a |
||||
non-source form of such a combination shall include the source code for |
||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
||||
work. |
||||
|
||||
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
||||
or by snail mail at: |
||||
Cyan Worlds, Inc. |
||||
14617 N Newport Hwy |
||||
Mead, WA 99021 |
||||
|
||||
*==LICENSE==*/ |
||||
|
||||
#include <gtest/gtest.h> |
||||
|
||||
#include "plUnifiedTime/plUnifiedTime.h" |
||||
|
||||
TEST(plUnifiedTime, SetGMTime) |
||||
{ |
||||
// test with two dates, one at the beginning and one in the middle of the year, so that one of them falls into local DST (if present)
|
||||
plUnifiedTime t1; |
||||
t1.SetGMTime(1984, 1, 24, 18, 27, 43, 123456); |
||||
EXPECT_EQ(plUnifiedTime::kGmt, t1.GetMode()); |
||||
EXPECT_EQ(1984, t1.GetYear()); |
||||
EXPECT_EQ(1, t1.GetMonth()); |
||||
EXPECT_EQ(24, t1.GetDay()); |
||||
EXPECT_EQ(18, t1.GetHour()); |
||||
EXPECT_EQ(27, t1.GetMinute()); |
||||
EXPECT_EQ(43, t1.GetSecond()); |
||||
EXPECT_EQ(123456, t1.GetMicros()); |
||||
|
||||
plUnifiedTime t2; |
||||
t2.SetGMTime(2003, 7, 10, 5, 46, 14, 654321); |
||||
EXPECT_EQ(plUnifiedTime::kGmt, t2.GetMode()); |
||||
EXPECT_EQ(2003, t2.GetYear()); |
||||
EXPECT_EQ(7, t2.GetMonth()); |
||||
EXPECT_EQ(10, t2.GetDay()); |
||||
EXPECT_EQ(5, t2.GetHour()); |
||||
EXPECT_EQ(46, t2.GetMinute()); |
||||
EXPECT_EQ(14, t2.GetSecond()); |
||||
EXPECT_EQ(654321, t2.GetMicros()); |
||||
} |
@ -0,0 +1,130 @@
|
||||
Changes for 1.6.0: |
||||
|
||||
* New feature: ADD_FAILURE_AT() for reporting a test failure at the |
||||
given source location -- useful for writing testing utilities. |
||||
* New feature: the universal value printer is moved from Google Mock |
||||
to Google Test. |
||||
* New feature: type parameters and value parameters are reported in |
||||
the XML report now. |
||||
* A gtest_disable_pthreads CMake option. |
||||
* Colored output works in GNU Screen sessions now. |
||||
* Parameters of value-parameterized tests are now printed in the |
||||
textual output. |
||||
* Failures from ad hoc test assertions run before RUN_ALL_TESTS() are |
||||
now correctly reported. |
||||
* Arguments of ASSERT_XY and EXPECT_XY no longer need to support << to |
||||
ostream. |
||||
* More complete handling of exceptions. |
||||
* GTEST_ASSERT_XY can be used instead of ASSERT_XY in case the latter |
||||
name is already used by another library. |
||||
* --gtest_catch_exceptions is now true by default, allowing a test |
||||
program to continue after an exception is thrown. |
||||
* Value-parameterized test fixtures can now derive from Test and |
||||
WithParamInterface<T> separately, easing conversion of legacy tests. |
||||
* Death test messages are clearly marked to make them more |
||||
distinguishable from other messages. |
||||
* Compatibility fixes for Android, Google Native Client, MinGW, HP UX, |
||||
PowerPC, Lucid autotools, libCStd, Sun C++, Borland C++ Builder (Code Gear), |
||||
IBM XL C++ (Visual Age C++), and C++0x. |
||||
* Bug fixes and implementation clean-ups. |
||||
* Potentially incompatible changes: disables the harmful 'make install' |
||||
command in autotools. |
||||
|
||||
Changes for 1.5.0: |
||||
|
||||
* New feature: assertions can be safely called in multiple threads |
||||
where the pthreads library is available. |
||||
* New feature: predicates used inside EXPECT_TRUE() and friends |
||||
can now generate custom failure messages. |
||||
* New feature: Google Test can now be compiled as a DLL. |
||||
* New feature: fused source files are included. |
||||
* New feature: prints help when encountering unrecognized Google Test flags. |
||||
* Experimental feature: CMake build script (requires CMake 2.6.4+). |
||||
* Experimental feature: the Pump script for meta programming. |
||||
* double values streamed to an assertion are printed with enough precision |
||||
to differentiate any two different values. |
||||
* Google Test now works on Solaris and AIX. |
||||
* Build and test script improvements. |
||||
* Bug fixes and implementation clean-ups. |
||||
|
||||
Potentially breaking changes: |
||||
|
||||
* Stopped supporting VC++ 7.1 with exceptions disabled. |
||||
* Dropped support for 'make install'. |
||||
|
||||
Changes for 1.4.0: |
||||
|
||||
* New feature: the event listener API |
||||
* New feature: test shuffling |
||||
* New feature: the XML report format is closer to junitreport and can |
||||
be parsed by Hudson now. |
||||
* New feature: when a test runs under Visual Studio, its failures are |
||||
integrated in the IDE. |
||||
* New feature: /MD(d) versions of VC++ projects. |
||||
* New feature: elapsed time for the tests is printed by default. |
||||
* New feature: comes with a TR1 tuple implementation such that Boost |
||||
is no longer needed for Combine(). |
||||
* New feature: EXPECT_DEATH_IF_SUPPORTED macro and friends. |
||||
* New feature: the Xcode project can now produce static gtest |
||||
libraries in addition to a framework. |
||||
* Compatibility fixes for Solaris, Cygwin, minGW, Windows Mobile, |
||||
Symbian, gcc, and C++Builder. |
||||
* Bug fixes and implementation clean-ups. |
||||
|
||||
Changes for 1.3.0: |
||||
|
||||
* New feature: death tests on Windows, Cygwin, and Mac. |
||||
* New feature: ability to use Google Test assertions in other testing |
||||
frameworks. |
||||
* New feature: ability to run disabled test via |
||||
--gtest_also_run_disabled_tests. |
||||
* New feature: the --help flag for printing the usage. |
||||
* New feature: access to Google Test flag values in user code. |
||||
* New feature: a script that packs Google Test into one .h and one |
||||
.cc file for easy deployment. |
||||
* New feature: support for distributing test functions to multiple |
||||
machines (requires support from the test runner). |
||||
* Bug fixes and implementation clean-ups. |
||||
|
||||
Changes for 1.2.1: |
||||
|
||||
* Compatibility fixes for Linux IA-64 and IBM z/OS. |
||||
* Added support for using Boost and other TR1 implementations. |
||||
* Changes to the build scripts to support upcoming release of Google C++ |
||||
Mocking Framework. |
||||
* Added Makefile to the distribution package. |
||||
* Improved build instructions in README. |
||||
|
||||
Changes for 1.2.0: |
||||
|
||||
* New feature: value-parameterized tests. |
||||
* New feature: the ASSERT/EXPECT_(NON)FATAL_FAILURE(_ON_ALL_THREADS) |
||||
macros. |
||||
* Changed the XML report format to match JUnit/Ant's. |
||||
* Added tests to the Xcode project. |
||||
* Added scons/SConscript for building with SCons. |
||||
* Added src/gtest-all.cc for building Google Test from a single file. |
||||
* Fixed compatibility with Solaris and z/OS. |
||||
* Enabled running Python tests on systems with python 2.3 installed, |
||||
e.g. Mac OS X 10.4. |
||||
* Bug fixes. |
||||
|
||||
Changes for 1.1.0: |
||||
|
||||
* New feature: type-parameterized tests. |
||||
* New feature: exception assertions. |
||||
* New feature: printing elapsed time of tests. |
||||
* Improved the robustness of death tests. |
||||
* Added an Xcode project and samples. |
||||
* Adjusted the output format on Windows to be understandable by Visual Studio. |
||||
* Minor bug fixes. |
||||
|
||||
Changes for 1.0.1: |
||||
|
||||
* Added project files for Visual Studio 7.1. |
||||
* Fixed issues with compiling on Mac OS X. |
||||
* Fixed issues with compiling on Cygwin. |
||||
|
||||
Changes for 1.0.0: |
||||
|
||||
* Initial Open Source release of Google Test |
@ -0,0 +1,240 @@
|
||||
######################################################################## |
||||
# CMake build script for Google Test. |
||||
# |
||||
# To run the tests for Google Test itself on Linux, use 'make test' or |
||||
# ctest. You can select which tests to run using 'ctest -R regex'. |
||||
# For more options, run 'ctest --help'. |
||||
|
||||
# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to |
||||
# make it prominent in the GUI. |
||||
option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF) |
||||
|
||||
# When other libraries are using a shared version of runtime libraries, |
||||
# Google Test also has to use one. |
||||
option( |
||||
gtest_force_shared_crt |
||||
"Use shared (DLL) run-time lib even when Google Test is built as static lib." |
||||
OFF) |
||||
|
||||
option(gtest_build_tests "Build all of gtest's own tests." OFF) |
||||
|
||||
option(gtest_build_samples "Build gtest's sample programs." OFF) |
||||
|
||||
option(gtest_disable_pthreads "Disable uses of pthreads in gtest." OFF) |
||||
|
||||
# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build(). |
||||
include(cmake/hermetic_build.cmake OPTIONAL) |
||||
|
||||
if (COMMAND pre_project_set_up_hermetic_build) |
||||
pre_project_set_up_hermetic_build() |
||||
endif() |
||||
|
||||
######################################################################## |
||||
# |
||||
# Project-wide settings |
||||
|
||||
# Name of the project. |
||||
# |
||||
# CMake files in this project can refer to the root source directory |
||||
# as ${gtest_SOURCE_DIR} and to the root binary directory as |
||||
# ${gtest_BINARY_DIR}. |
||||
# Language "C" is required for find_package(Threads). |
||||
project(gtest CXX C) |
||||
cmake_minimum_required(VERSION 2.6.2) |
||||
|
||||
if (COMMAND set_up_hermetic_build) |
||||
set_up_hermetic_build() |
||||
endif() |
||||
|
||||
# Define helper functions and macros used by Google Test. |
||||
include(cmake/internal_utils.cmake) |
||||
|
||||
config_compiler_and_linker() # Defined in internal_utils.cmake. |
||||
|
||||
# Where Google Test's .h files can be found. |
||||
include_directories( |
||||
${gtest_SOURCE_DIR}/include |
||||
${gtest_SOURCE_DIR}) |
||||
|
||||
# Where Google Test's libraries can be found. |
||||
link_directories(${gtest_BINARY_DIR}/src) |
||||
|
||||
######################################################################## |
||||
# |
||||
# Defines the gtest & gtest_main libraries. User tests should link |
||||
# with one of them. |
||||
|
||||
# Google Test libraries. We build them using more strict warnings than what |
||||
# are used for other targets, to ensure that gtest can be compiled by a user |
||||
# aggressive about warnings. |
||||
cxx_library(gtest "${cxx_strict}" src/gtest-all.cc) |
||||
cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc) |
||||
target_link_libraries(gtest_main gtest) |
||||
|
||||
######################################################################## |
||||
# |
||||
# Samples on how to link user tests with gtest or gtest_main. |
||||
# |
||||
# They are not built by default. To build them, set the |
||||
# gtest_build_samples option to ON. You can do it by running ccmake |
||||
# or specifying the -Dbuild_gtest_samples=ON flag when running cmake. |
||||
|
||||
if (gtest_build_samples) |
||||
cxx_executable(sample1_unittest samples gtest_main samples/sample1.cc) |
||||
cxx_executable(sample2_unittest samples gtest_main samples/sample2.cc) |
||||
cxx_executable(sample3_unittest samples gtest_main) |
||||
cxx_executable(sample4_unittest samples gtest_main samples/sample4.cc) |
||||
cxx_executable(sample5_unittest samples gtest_main samples/sample1.cc) |
||||
cxx_executable(sample6_unittest samples gtest_main) |
||||
cxx_executable(sample7_unittest samples gtest_main) |
||||
cxx_executable(sample8_unittest samples gtest_main) |
||||
cxx_executable(sample9_unittest samples gtest) |
||||
cxx_executable(sample10_unittest samples gtest) |
||||
endif() |
||||
|
||||
######################################################################## |
||||
# |
||||
# Google Test's own tests. |
||||
# |
||||
# You can skip this section if you aren't interested in testing |
||||
# Google Test itself. |
||||
# |
||||
# The tests are not built by default. To build them, set the |
||||
# gtest_build_tests option to ON. You can do it by running ccmake |
||||
# or specifying the -Dgtest_build_tests=ON flag when running cmake. |
||||
|
||||
if (gtest_build_tests) |
||||
# This must be set in the root directory for the tests to be run by |
||||
# 'make test' or ctest. |
||||
enable_testing() |
||||
|
||||
############################################################ |
||||
# C++ tests built with standard compiler flags. |
||||
|
||||
cxx_test(gtest-death-test_test gtest_main) |
||||
cxx_test(gtest_environment_test gtest) |
||||
cxx_test(gtest-filepath_test gtest_main) |
||||
cxx_test(gtest-linked_ptr_test gtest_main) |
||||
cxx_test(gtest-listener_test gtest_main) |
||||
cxx_test(gtest_main_unittest gtest_main) |
||||
cxx_test(gtest-message_test gtest_main) |
||||
cxx_test(gtest_no_test_unittest gtest) |
||||
cxx_test(gtest-options_test gtest_main) |
||||
cxx_test(gtest-param-test_test gtest |
||||
test/gtest-param-test2_test.cc) |
||||
cxx_test(gtest-port_test gtest_main) |
||||
cxx_test(gtest_pred_impl_unittest gtest_main) |
||||
cxx_test(gtest-printers_test gtest_main) |
||||
cxx_test(gtest_prod_test gtest_main |
||||
test/production.cc) |
||||
cxx_test(gtest_repeat_test gtest) |
||||
cxx_test(gtest_sole_header_test gtest_main) |
||||
cxx_test(gtest_stress_test gtest) |
||||
cxx_test(gtest-test-part_test gtest_main) |
||||
cxx_test(gtest_throw_on_failure_ex_test gtest) |
||||
cxx_test(gtest-typed-test_test gtest_main |
||||
test/gtest-typed-test2_test.cc) |
||||
cxx_test(gtest_unittest gtest_main) |
||||
cxx_test(gtest-unittest-api_test gtest) |
||||
|
||||
############################################################ |
||||
# C++ tests built with non-standard compiler flags. |
||||
|
||||
cxx_library(gtest_no_exception "${cxx_no_exception}" |
||||
src/gtest-all.cc) |
||||
cxx_library(gtest_main_no_exception "${cxx_no_exception}" |
||||
src/gtest-all.cc src/gtest_main.cc) |
||||
cxx_library(gtest_main_no_rtti "${cxx_no_rtti}" |
||||
src/gtest-all.cc src/gtest_main.cc) |
||||
|
||||
cxx_test_with_flags(gtest-death-test_ex_nocatch_test |
||||
"${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=0" |
||||
gtest test/gtest-death-test_ex_test.cc) |
||||
cxx_test_with_flags(gtest-death-test_ex_catch_test |
||||
"${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=1" |
||||
gtest test/gtest-death-test_ex_test.cc) |
||||
|
||||
cxx_test_with_flags(gtest_no_rtti_unittest "${cxx_no_rtti}" |
||||
gtest_main_no_rtti test/gtest_unittest.cc) |
||||
|
||||
cxx_shared_library(gtest_dll "${cxx_default}" |
||||
src/gtest-all.cc src/gtest_main.cc) |
||||
|
||||
cxx_executable_with_flags(gtest_dll_test_ "${cxx_default}" |
||||
gtest_dll test/gtest_all_test.cc) |
||||
set_target_properties(gtest_dll_test_ |
||||
PROPERTIES |
||||
COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1") |
||||
|
||||
if (NOT MSVC OR NOT MSVC_VERSION EQUAL 1600) |
||||
# The C++ Standard specifies tuple_element<int, class>. |
||||
# Yet MSVC 10's <utility> declares tuple_element<size_t, class>. |
||||
# That declaration conflicts with our own standard-conforming |
||||
# tuple implementation. Therefore using our own tuple with |
||||
# MSVC 10 doesn't compile. |
||||
cxx_library(gtest_main_use_own_tuple "${cxx_use_own_tuple}" |
||||
src/gtest-all.cc src/gtest_main.cc) |
||||
|
||||
cxx_test_with_flags(gtest-tuple_test "${cxx_use_own_tuple}" |
||||
gtest_main_use_own_tuple test/gtest-tuple_test.cc) |
||||
|
||||
cxx_test_with_flags(gtest_use_own_tuple_test "${cxx_use_own_tuple}" |
||||
gtest_main_use_own_tuple |
||||
test/gtest-param-test_test.cc test/gtest-param-test2_test.cc) |
||||
endif() |
||||
|
||||
############################################################ |
||||
# Python tests. |
||||
|
||||
cxx_executable(gtest_break_on_failure_unittest_ test gtest) |
||||
py_test(gtest_break_on_failure_unittest) |
||||
|
||||
cxx_executable_with_flags( |
||||
gtest_catch_exceptions_no_ex_test_ |
||||
"${cxx_no_exception}" |
||||
gtest_main_no_exception |
||||
test/gtest_catch_exceptions_test_.cc) |
||||
cxx_executable_with_flags( |
||||
gtest_catch_exceptions_ex_test_ |
||||
"${cxx_exception}" |
||||
gtest_main |
||||
test/gtest_catch_exceptions_test_.cc) |
||||
py_test(gtest_catch_exceptions_test) |
||||
|
||||
cxx_executable(gtest_color_test_ test gtest) |
||||
py_test(gtest_color_test) |
||||
|
||||
cxx_executable(gtest_env_var_test_ test gtest) |
||||
py_test(gtest_env_var_test) |
||||
|
||||
cxx_executable(gtest_filter_unittest_ test gtest) |
||||
py_test(gtest_filter_unittest) |
||||
|
||||
cxx_executable(gtest_help_test_ test gtest_main) |
||||
py_test(gtest_help_test) |
||||
|
||||
cxx_executable(gtest_list_tests_unittest_ test gtest) |
||||
py_test(gtest_list_tests_unittest) |
||||
|
||||
cxx_executable(gtest_output_test_ test gtest) |
||||
py_test(gtest_output_test) |
||||
|
||||
cxx_executable(gtest_shuffle_test_ test gtest) |
||||
py_test(gtest_shuffle_test) |
||||
|
||||
cxx_executable(gtest_throw_on_failure_test_ test gtest_no_exception) |
||||
set_target_properties(gtest_throw_on_failure_test_ |
||||
PROPERTIES |
||||
COMPILE_FLAGS "${cxx_no_exception}") |
||||
py_test(gtest_throw_on_failure_test) |
||||
|
||||
cxx_executable(gtest_uninitialized_test_ test gtest) |
||||
py_test(gtest_uninitialized_test) |
||||
|
||||
cxx_executable(gtest_xml_outfile1_test_ test gtest_main) |
||||
cxx_executable(gtest_xml_outfile2_test_ test gtest_main) |
||||
py_test(gtest_xml_outfiles_test) |
||||
|
||||
cxx_executable(gtest_xml_output_unittest_ test gtest) |
||||
py_test(gtest_xml_output_unittest) |
||||
endif() |
@ -0,0 +1,37 @@
|
||||
# This file contains a list of people who've made non-trivial |
||||
# contribution to the Google C++ Testing Framework project. People |
||||
# who commit code to the project are encouraged to add their names |
||||
# here. Please keep the list sorted by first names. |
||||
|
||||
Ajay Joshi <jaj@google.com> |
||||
Balázs Dán <balazs.dan@gmail.com> |
||||
Bharat Mediratta <bharat@menalto.com> |
||||
Chandler Carruth <chandlerc@google.com> |
||||
Chris Prince <cprince@google.com> |
||||
Chris Taylor <taylorc@google.com> |
||||
Dan Egnor <egnor@google.com> |
||||
Eric Roman <eroman@chromium.org> |
||||
Hady Zalek <hady.zalek@gmail.com> |
||||
Jeffrey Yasskin <jyasskin@google.com> |
||||
Jói Sigurðsson <joi@google.com> |
||||
Keir Mierle <mierle@gmail.com> |
||||
Keith Ray <keith.ray@gmail.com> |
||||
Kenton Varda <kenton@google.com> |
||||
Manuel Klimek <klimek@google.com> |
||||
Markus Heule <markus.heule@gmail.com> |
||||
Mika Raento <mikie@iki.fi> |
||||
Miklós Fazekas <mfazekas@szemafor.com> |
||||
Pasi Valminen <pasi.valminen@gmail.com> |
||||
Patrick Hanna <phanna@google.com> |
||||
Patrick Riley <pfr@google.com> |
||||
Peter Kaminski <piotrk@google.com> |
||||
Preston Jackson <preston.a.jackson@gmail.com> |
||||
Rainer Klaffenboeck <rainer.klaffenboeck@dynatrace.com> |
||||
Russ Cox <rsc@google.com> |
||||
Russ Rufer <russ@pentad.com> |
||||
Sean Mcafee <eefacm@gmail.com> |
||||
Sigurður Ásgeirsson <siggi@google.com> |
||||
Tracy Bialik <tracy@pentad.com> |
||||
Vadim Berman <vadimb@google.com> |
||||
Vlad Losev <vladl@google.com> |
||||
Zhanyong Wan <wan@google.com> |
@ -0,0 +1,28 @@
|
||||
Copyright 2008, Google Inc. |
||||
All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are |
||||
met: |
||||
|
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above |
||||
copyright notice, this list of conditions and the following disclaimer |
||||
in the documentation and/or other materials provided with the |
||||
distribution. |
||||
* Neither the name of Google Inc. nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
@ -0,0 +1,302 @@
|
||||
# Automake file
|
||||
|
||||
ACLOCAL_AMFLAGS = -I m4
|
||||
|
||||
# Nonstandard package files for distribution
|
||||
EXTRA_DIST = \
|
||||
CHANGES \
|
||||
CONTRIBUTORS \
|
||||
include/gtest/gtest-param-test.h.pump \
|
||||
include/gtest/internal/gtest-param-util-generated.h.pump \
|
||||
include/gtest/internal/gtest-tuple.h.pump \
|
||||
include/gtest/internal/gtest-type-util.h.pump \
|
||||
make/Makefile \
|
||||
scripts/fuse_gtest_files.py \
|
||||
scripts/gen_gtest_pred_impl.py \
|
||||
scripts/pump.py \
|
||||
scripts/test/Makefile
|
||||
|
||||
# gtest source files that we don't compile directly. They are
|
||||
# #included by gtest-all.cc.
|
||||
GTEST_SRC = \
|
||||
src/gtest-death-test.cc \
|
||||
src/gtest-filepath.cc \
|
||||
src/gtest-internal-inl.h \
|
||||
src/gtest-port.cc \
|
||||
src/gtest-printers.cc \
|
||||
src/gtest-test-part.cc \
|
||||
src/gtest-typed-test.cc \
|
||||
src/gtest.cc
|
||||
|
||||
EXTRA_DIST += $(GTEST_SRC)
|
||||
|
||||
# Sample files that we don't compile.
|
||||
EXTRA_DIST += \
|
||||
samples/prime_tables.h \
|
||||
samples/sample2_unittest.cc \
|
||||
samples/sample3_unittest.cc \
|
||||
samples/sample4_unittest.cc \
|
||||
samples/sample5_unittest.cc \
|
||||
samples/sample6_unittest.cc \
|
||||
samples/sample7_unittest.cc \
|
||||
samples/sample8_unittest.cc \
|
||||
samples/sample9_unittest.cc
|
||||
|
||||
# C++ test files that we don't compile directly.
|
||||
EXTRA_DIST += \
|
||||
test/gtest-death-test_ex_test.cc \
|
||||
test/gtest-death-test_test.cc \
|
||||
test/gtest-filepath_test.cc \
|
||||
test/gtest-linked_ptr_test.cc \
|
||||
test/gtest-listener_test.cc \
|
||||
test/gtest-message_test.cc \
|
||||
test/gtest-options_test.cc \
|
||||
test/gtest-param-test2_test.cc \
|
||||
test/gtest-param-test2_test.cc \
|
||||
test/gtest-param-test_test.cc \
|
||||
test/gtest-param-test_test.cc \
|
||||
test/gtest-param-test_test.h \
|
||||
test/gtest-port_test.cc \
|
||||
test/gtest-printers_test.cc \
|
||||
test/gtest-test-part_test.cc \
|
||||
test/gtest-tuple_test.cc \
|
||||
test/gtest-typed-test2_test.cc \
|
||||
test/gtest-typed-test_test.cc \
|
||||
test/gtest-typed-test_test.h \
|
||||
test/gtest-unittest-api_test.cc \
|
||||
test/gtest_break_on_failure_unittest_.cc \
|
||||
test/gtest_catch_exceptions_test_.cc \
|
||||
test/gtest_color_test_.cc \
|
||||
test/gtest_env_var_test_.cc \
|
||||
test/gtest_environment_test.cc \
|
||||
test/gtest_filter_unittest_.cc \
|
||||
test/gtest_help_test_.cc \
|
||||
test/gtest_list_tests_unittest_.cc \
|
||||
test/gtest_main_unittest.cc \
|
||||
test/gtest_no_test_unittest.cc \
|
||||
test/gtest_output_test_.cc \
|
||||
test/gtest_pred_impl_unittest.cc \
|
||||
test/gtest_prod_test.cc \
|
||||
test/gtest_repeat_test.cc \
|
||||
test/gtest_shuffle_test_.cc \
|
||||
test/gtest_sole_header_test.cc \
|
||||
test/gtest_stress_test.cc \
|
||||
test/gtest_throw_on_failure_ex_test.cc \
|
||||
test/gtest_throw_on_failure_test_.cc \
|
||||
test/gtest_uninitialized_test_.cc \
|
||||
test/gtest_unittest.cc \
|
||||
test/gtest_unittest.cc \
|
||||
test/gtest_xml_outfile1_test_.cc \
|
||||
test/gtest_xml_outfile2_test_.cc \
|
||||
test/gtest_xml_output_unittest_.cc \
|
||||
test/production.cc \
|
||||
test/production.h
|
||||
|
||||
# Python tests that we don't run.
|
||||
EXTRA_DIST += \
|
||||
test/gtest_break_on_failure_unittest.py \
|
||||
test/gtest_catch_exceptions_test.py \
|
||||
test/gtest_color_test.py \
|
||||
test/gtest_env_var_test.py \
|
||||
test/gtest_filter_unittest.py \
|
||||
test/gtest_help_test.py \
|
||||
test/gtest_list_tests_unittest.py \
|
||||
test/gtest_output_test.py \
|
||||
test/gtest_output_test_golden_lin.txt \
|
||||
test/gtest_shuffle_test.py \
|
||||
test/gtest_test_utils.py \
|
||||
test/gtest_throw_on_failure_test.py \
|
||||
test/gtest_uninitialized_test.py \
|
||||
test/gtest_xml_outfiles_test.py \
|
||||
test/gtest_xml_output_unittest.py \
|
||||
test/gtest_xml_test_utils.py
|
||||
|
||||
# CMake script
|
||||
EXTRA_DIST += \
|
||||
CMakeLists.txt \
|
||||
cmake/internal_utils.cmake
|
||||
|
||||
# MSVC project files
|
||||
EXTRA_DIST += \
|
||||
msvc/gtest-md.sln \
|
||||
msvc/gtest-md.vcproj \
|
||||
msvc/gtest.sln \
|
||||
msvc/gtest.vcproj \
|
||||
msvc/gtest_main-md.vcproj \
|
||||
msvc/gtest_main.vcproj \
|
||||
msvc/gtest_prod_test-md.vcproj \
|
||||
msvc/gtest_prod_test.vcproj \
|
||||
msvc/gtest_unittest-md.vcproj \
|
||||
msvc/gtest_unittest.vcproj
|
||||
|
||||
# xcode project files
|
||||
EXTRA_DIST += \
|
||||
xcode/Config/DebugProject.xcconfig \
|
||||
xcode/Config/FrameworkTarget.xcconfig \
|
||||
xcode/Config/General.xcconfig \
|
||||
xcode/Config/ReleaseProject.xcconfig \
|
||||
xcode/Config/StaticLibraryTarget.xcconfig \
|
||||
xcode/Config/TestTarget.xcconfig \
|
||||
xcode/Resources/Info.plist \
|
||||
xcode/Scripts/runtests.sh \
|
||||
xcode/Scripts/versiongenerate.py \
|
||||
xcode/gtest.xcodeproj/project.pbxproj
|
||||
|
||||
# xcode sample files
|
||||
EXTRA_DIST += \
|
||||
xcode/Samples/FrameworkSample/Info.plist \
|
||||
xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj \
|
||||
xcode/Samples/FrameworkSample/runtests.sh \
|
||||
xcode/Samples/FrameworkSample/widget.cc \
|
||||
xcode/Samples/FrameworkSample/widget.h \
|
||||
xcode/Samples/FrameworkSample/widget_test.cc
|
||||
|
||||
# C++Builder project files
|
||||
EXTRA_DIST += \
|
||||
codegear/gtest.cbproj \
|
||||
codegear/gtest.groupproj \
|
||||
codegear/gtest_all.cc \
|
||||
codegear/gtest_link.cc \
|
||||
codegear/gtest_main.cbproj \
|
||||
codegear/gtest_unittest.cbproj
|
||||
|
||||
# Distribute and install M4 macro
|
||||
m4datadir = $(datadir)/aclocal
|
||||
m4data_DATA = m4/gtest.m4
|
||||
EXTRA_DIST += $(m4data_DATA)
|
||||
|
||||
# We define the global AM_CPPFLAGS as everything we compile includes from these
|
||||
# directories.
|
||||
AM_CPPFLAGS = -I$(srcdir) -I$(srcdir)/include
|
||||
|
||||
# Modifies compiler and linker flags for pthreads compatibility.
|
||||
if HAVE_PTHREADS |
||||
AM_CXXFLAGS = @PTHREAD_CFLAGS@ -DGTEST_HAS_PTHREAD=1
|
||||
AM_LIBS = @PTHREAD_LIBS@
|
||||
else |
||||
AM_CXXFLAGS = -DGTEST_HAS_PTHREAD=0
|
||||
endif |
||||
|
||||
# Build rules for libraries.
|
||||
lib_LTLIBRARIES = lib/libgtest.la lib/libgtest_main.la
|
||||
|
||||
lib_libgtest_la_SOURCES = src/gtest-all.cc
|
||||
|
||||
pkginclude_HEADERS = \
|
||||
include/gtest/gtest-death-test.h \
|
||||
include/gtest/gtest-message.h \
|
||||
include/gtest/gtest-param-test.h \
|
||||
include/gtest/gtest-printers.h \
|
||||
include/gtest/gtest-spi.h \
|
||||
include/gtest/gtest-test-part.h \
|
||||
include/gtest/gtest-typed-test.h \
|
||||
include/gtest/gtest.h \
|
||||
include/gtest/gtest_pred_impl.h \
|
||||
include/gtest/gtest_prod.h
|
||||
|
||||
pkginclude_internaldir = $(pkgincludedir)/internal
|
||||
pkginclude_internal_HEADERS = \
|
||||
include/gtest/internal/gtest-death-test-internal.h \
|
||||
include/gtest/internal/gtest-filepath.h \
|
||||
include/gtest/internal/gtest-internal.h \
|
||||
include/gtest/internal/gtest-linked_ptr.h \
|
||||
include/gtest/internal/gtest-param-util-generated.h \
|
||||
include/gtest/internal/gtest-param-util.h \
|
||||
include/gtest/internal/gtest-port.h \
|
||||
include/gtest/internal/gtest-string.h \
|
||||
include/gtest/internal/gtest-tuple.h \
|
||||
include/gtest/internal/gtest-type-util.h
|
||||
|
||||
lib_libgtest_main_la_SOURCES = src/gtest_main.cc
|
||||
lib_libgtest_main_la_LIBADD = lib/libgtest.la
|
||||
|
||||
# Bulid rules for samples and tests. Automake's naming for some of
|
||||
# these variables isn't terribly obvious, so this is a brief
|
||||
# reference:
|
||||
#
|
||||
# TESTS -- Programs run automatically by "make check"
|
||||
# check_PROGRAMS -- Programs built by "make check" but not necessarily run
|
||||
|
||||
noinst_LTLIBRARIES = samples/libsamples.la
|
||||
|
||||
samples_libsamples_la_SOURCES = \
|
||||
samples/sample1.cc \
|
||||
samples/sample1.h \
|
||||
samples/sample2.cc \
|
||||
samples/sample2.h \
|
||||
samples/sample3-inl.h \
|
||||
samples/sample4.cc \
|
||||
samples/sample4.h
|
||||
|
||||
TESTS=
|
||||
TESTS_ENVIRONMENT = GTEST_SOURCE_DIR="$(srcdir)/test" \
|
||||
GTEST_BUILD_DIR="$(top_builddir)/test"
|
||||
check_PROGRAMS=
|
||||
|
||||
# A simple sample on using gtest.
|
||||
TESTS += samples/sample1_unittest
|
||||
check_PROGRAMS += samples/sample1_unittest
|
||||
samples_sample1_unittest_SOURCES = samples/sample1_unittest.cc
|
||||
samples_sample1_unittest_LDADD = lib/libgtest_main.la \
|
||||
lib/libgtest.la \
|
||||
samples/libsamples.la
|
||||
|
||||
# Another sample. It also verifies that libgtest works.
|
||||
TESTS += samples/sample10_unittest
|
||||
check_PROGRAMS += samples/sample10_unittest
|
||||
samples_sample10_unittest_SOURCES = samples/sample10_unittest.cc
|
||||
samples_sample10_unittest_LDADD = lib/libgtest.la
|
||||
|
||||
# This tests most constructs of gtest and verifies that libgtest_main
|
||||
# and libgtest work.
|
||||
TESTS += test/gtest_all_test
|
||||
check_PROGRAMS += test/gtest_all_test
|
||||
test_gtest_all_test_SOURCES = test/gtest_all_test.cc
|
||||
test_gtest_all_test_LDADD = lib/libgtest_main.la \
|
||||
lib/libgtest.la
|
||||
|
||||
# Tests that fused gtest files compile and work.
|
||||
FUSED_GTEST_SRC = \
|
||||
fused-src/gtest/gtest-all.cc \
|
||||
fused-src/gtest/gtest.h \
|
||||
fused-src/gtest/gtest_main.cc
|
||||
|
||||
TESTS += test/fused_gtest_test
|
||||
check_PROGRAMS += test/fused_gtest_test
|
||||
test_fused_gtest_test_SOURCES = $(FUSED_GTEST_SRC) \
|
||||
samples/sample1.cc samples/sample1_unittest.cc
|
||||
test_fused_gtest_test_CPPFLAGS = -I"$(srcdir)/fused-src"
|
||||
|
||||
# Build rules for putting fused Google Test files into the distribution
|
||||
# package. The user can also create those files by manually running
|
||||
# scripts/fuse_gtest_files.py.
|
||||
$(test_fused_gtest_test_SOURCES): fused-gtest |
||||
|
||||
fused-gtest: $(pkginclude_HEADERS) $(pkginclude_internal_HEADERS) \
|
||||
$(GTEST_SRC) src/gtest-all.cc src/gtest_main.cc \
|
||||
scripts/fuse_gtest_files.py
|
||||
mkdir -p "$(srcdir)/fused-src"
|
||||
chmod -R u+w "$(srcdir)/fused-src"
|
||||
rm -f "$(srcdir)/fused-src/gtest/gtest-all.cc"
|
||||
rm -f "$(srcdir)/fused-src/gtest/gtest.h"
|
||||
"$(srcdir)/scripts/fuse_gtest_files.py" "$(srcdir)/fused-src"
|
||||
cp -f "$(srcdir)/src/gtest_main.cc" "$(srcdir)/fused-src/gtest/"
|
||||
|
||||
maintainer-clean-local: |
||||
rm -rf "$(srcdir)/fused-src"
|
||||
|
||||
# Death tests may produce core dumps in the build directory. In case
|
||||
# this happens, clean them to keep distcleancheck happy.
|
||||
CLEANFILES = core
|
||||
|
||||
# Disables 'make install' as installing a compiled version of Google
|
||||
# Test can lead to undefined behavior due to violation of the
|
||||
# One-Definition Rule.
|
||||
|
||||
install-exec-local: |
||||
echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Test into your build system."
|
||||
false
|
||||
|
||||
install-data-local: |
||||
echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Test into your build system."
|
||||
false
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,424 @@
|
||||
Google C++ Testing Framework |
||||
============================ |
||||
|
||||
http://code.google.com/p/googletest/ |
||||
|
||||
Overview |
||||
-------- |
||||
|
||||
Google's framework for writing C++ tests on a variety of platforms |
||||
(Linux, Mac OS X, Windows, Windows CE, Symbian, etc). Based on the |
||||
xUnit architecture. Supports automatic test discovery, a rich set of |
||||
assertions, user-defined assertions, death tests, fatal and non-fatal |
||||
failures, various options for running the tests, and XML test report |
||||
generation. |
||||
|
||||
Please see the project page above for more information as well as the |
||||
mailing list for questions, discussions, and development. There is |
||||
also an IRC channel on OFTC (irc.oftc.net) #gtest available. Please |
||||
join us! |
||||
|
||||
Requirements for End Users |
||||
-------------------------- |
||||
|
||||
Google Test is designed to have fairly minimal requirements to build |
||||
and use with your projects, but there are some. Currently, we support |
||||
Linux, Windows, Mac OS X, and Cygwin. We will also make our best |
||||
effort to support other platforms (e.g. Solaris, AIX, and z/OS). |
||||
However, since core members of the Google Test project have no access |
||||
to these platforms, Google Test may have outstanding issues there. If |
||||
you notice any problems on your platform, please notify |
||||
googletestframework@googlegroups.com. Patches for fixing them are |
||||
even more welcome! |
||||
|
||||
### Linux Requirements ### |
||||
|
||||
These are the base requirements to build and use Google Test from a source |
||||
package (as described below): |
||||
* GNU-compatible Make or gmake |
||||
* POSIX-standard shell |
||||
* POSIX(-2) Regular Expressions (regex.h) |
||||
* A C++98-standard-compliant compiler |
||||
|
||||
### Windows Requirements ### |
||||
|
||||
* Microsoft Visual C++ 7.1 or newer |
||||
|
||||
### Cygwin Requirements ### |
||||
|
||||
* Cygwin 1.5.25-14 or newer |
||||
|
||||
### Mac OS X Requirements ### |
||||
|
||||
* Mac OS X 10.4 Tiger or newer |
||||
* Developer Tools Installed |
||||
|
||||
Also, you'll need CMake 2.6.4 or higher if you want to build the |
||||
samples using the provided CMake script, regardless of the platform. |
||||
|
||||
Requirements for Contributors |
||||
----------------------------- |
||||
|
||||
We welcome patches. If you plan to contribute a patch, you need to |
||||
build Google Test and its own tests from an SVN checkout (described |
||||
below), which has further requirements: |
||||
|
||||
* Python version 2.3 or newer (for running some of the tests and |
||||
re-generating certain source files from templates) |
||||
* CMake 2.6.4 or newer |
||||
|
||||
Getting the Source |
||||
------------------ |
||||
|
||||
There are two primary ways of getting Google Test's source code: you |
||||
can download a stable source release in your preferred archive format, |
||||
or directly check out the source from our Subversion (SVN) repositary. |
||||
The SVN checkout requires a few extra steps and some extra software |
||||
packages on your system, but lets you track the latest development and |
||||
make patches much more easily, so we highly encourage it. |
||||
|
||||
### Source Package ### |
||||
|
||||
Google Test is released in versioned source packages which can be |
||||
downloaded from the download page [1]. Several different archive |
||||
formats are provided, but the only difference is the tools used to |
||||
manipulate them, and the size of the resulting file. Download |
||||
whichever you are most comfortable with. |
||||
|
||||
[1] http://code.google.com/p/googletest/downloads/list |
||||
|
||||
Once the package is downloaded, expand it using whichever tools you |
||||
prefer for that type. This will result in a new directory with the |
||||
name "gtest-X.Y.Z" which contains all of the source code. Here are |
||||
some examples on Linux: |
||||
|
||||
tar -xvzf gtest-X.Y.Z.tar.gz |
||||
tar -xvjf gtest-X.Y.Z.tar.bz2 |
||||
unzip gtest-X.Y.Z.zip |
||||
|
||||
### SVN Checkout ### |
||||
|
||||
To check out the main branch (also known as the "trunk") of Google |
||||
Test, run the following Subversion command: |
||||
|
||||
svn checkout http://googletest.googlecode.com/svn/trunk/ gtest-svn |
||||
|
||||
Setting up the Build |
||||
-------------------- |
||||
|
||||
To build Google Test and your tests that use it, you need to tell your |
||||
build system where to find its headers and source files. The exact |
||||
way to do it depends on which build system you use, and is usually |
||||
straightforward. |
||||
|
||||
### Generic Build Instructions ### |
||||
|
||||
Suppose you put Google Test in directory ${GTEST_DIR}. To build it, |
||||
create a library build target (or a project as called by Visual Studio |
||||
and Xcode) to compile |
||||
|
||||
${GTEST_DIR}/src/gtest-all.cc |
||||
|
||||
with |
||||
|
||||
${GTEST_DIR}/include and ${GTEST_DIR} |
||||
|
||||
in the header search path. Assuming a Linux-like system and gcc, |
||||
something like the following will do: |
||||
|
||||
g++ -I${GTEST_DIR}/include -I${GTEST_DIR} -c ${GTEST_DIR}/src/gtest-all.cc |
||||
ar -rv libgtest.a gtest-all.o |
||||
|
||||
Next, you should compile your test source file with |
||||
${GTEST_DIR}/include in the header search path, and link it with gtest |
||||
and any other necessary libraries: |
||||
|
||||
g++ -I${GTEST_DIR}/include path/to/your_test.cc libgtest.a -o your_test |
||||
|
||||
As an example, the make/ directory contains a Makefile that you can |
||||
use to build Google Test on systems where GNU make is available |
||||
(e.g. Linux, Mac OS X, and Cygwin). It doesn't try to build Google |
||||
Test's own tests. Instead, it just builds the Google Test library and |
||||
a sample test. You can use it as a starting point for your own build |
||||
script. |
||||
|
||||
If the default settings are correct for your environment, the |
||||
following commands should succeed: |
||||
|
||||
cd ${GTEST_DIR}/make |
||||
make |
||||
./sample1_unittest |
||||
|
||||
If you see errors, try to tweak the contents of make/Makefile to make |
||||
them go away. There are instructions in make/Makefile on how to do |
||||
it. |
||||
|
||||
### Using CMake ### |
||||
|
||||
Google Test comes with a CMake build script (CMakeLists.txt) that can |
||||
be used on a wide range of platforms ("C" stands for cross-platofrm.). |
||||
If you don't have CMake installed already, you can download it for |
||||
free from http://www.cmake.org/. |
||||
|
||||
CMake works by generating native makefiles or build projects that can |
||||
be used in the compiler environment of your choice. The typical |
||||
workflow starts with: |
||||
|
||||
mkdir mybuild # Create a directory to hold the build output. |
||||
cd mybuild |
||||
cmake ${GTEST_DIR} # Generate native build scripts. |
||||
|
||||
If you want to build Google Test's samples, you should replace the |
||||
last command with |
||||
|
||||
cmake -Dgtest_build_samples=ON ${GTEST_DIR} |
||||
|
||||
If you are on a *nix system, you should now see a Makefile in the |
||||
current directory. Just type 'make' to build gtest. |
||||
|
||||
If you use Windows and have Vistual Studio installed, a gtest.sln file |
||||
and several .vcproj files will be created. You can then build them |
||||
using Visual Studio. |
||||
|
||||
On Mac OS X with Xcode installed, a .xcodeproj file will be generated. |
||||
|
||||
### Legacy Build Scripts ### |
||||
|
||||
Before settling on CMake, we have been providing hand-maintained build |
||||
projects/scripts for Visual Studio, Xcode, and Autotools. While we |
||||
continue to provide them for convenience, they are not actively |
||||
maintained any more. We highly recommend that you follow the |
||||
instructions in the previous two sections to integrate Google Test |
||||
with your existing build system. |
||||
|
||||
If you still need to use the legacy build scripts, here's how: |
||||
|
||||
The msvc\ folder contains two solutions with Visual C++ projects. |
||||
Open the gtest.sln or gtest-md.sln file using Visual Studio, and you |
||||
are ready to build Google Test the same way you build any Visual |
||||
Studio project. Files that have names ending with -md use DLL |
||||
versions of Microsoft runtime libraries (the /MD or the /MDd compiler |
||||
option). Files without that suffix use static versions of the runtime |
||||
libraries (the /MT or the /MTd option). Please note that one must use |
||||
the same option to compile both gtest and the test code. If you use |
||||
Visual Studio 2005 or above, we recommend the -md version as /MD is |
||||
the default for new projects in these versions of Visual Studio. |
||||
|
||||
On Mac OS X, open the gtest.xcodeproj in the xcode/ folder using |
||||
Xcode. Build the "gtest" target. The universal binary framework will |
||||
end up in your selected build directory (selected in the Xcode |
||||
"Preferences..." -> "Building" pane and defaults to xcode/build). |
||||
Alternatively, at the command line, enter: |
||||
|
||||
xcodebuild |
||||
|
||||
This will build the "Release" configuration of gtest.framework in your |
||||
default build location. See the "xcodebuild" man page for more |
||||
information about building different configurations and building in |
||||
different locations. |
||||
|
||||
Tweaking Google Test |
||||
-------------------- |
||||
|
||||
Google Test can be used in diverse environments. The default |
||||
configuration may not work (or may not work well) out of the box in |
||||
some environments. However, you can easily tweak Google Test by |
||||
defining control macros on the compiler command line. Generally, |
||||
these macros are named like GTEST_XYZ and you define them to either 1 |
||||
or 0 to enable or disable a certain feature. |
||||
|
||||
We list the most frequently used macros below. For a complete list, |
||||
see file include/gtest/internal/gtest-port.h. |
||||
|
||||
### Choosing a TR1 Tuple Library ### |
||||
|
||||
Some Google Test features require the C++ Technical Report 1 (TR1) |
||||
tuple library, which is not yet available with all compilers. The |
||||
good news is that Google Test implements a subset of TR1 tuple that's |
||||
enough for its own need, and will automatically use this when the |
||||
compiler doesn't provide TR1 tuple. |
||||
|
||||
Usually you don't need to care about which tuple library Google Test |
||||
uses. However, if your project already uses TR1 tuple, you need to |
||||
tell Google Test to use the same TR1 tuple library the rest of your |
||||
project uses, or the two tuple implementations will clash. To do |
||||
that, add |
||||
|
||||
-DGTEST_USE_OWN_TR1_TUPLE=0 |
||||
|
||||
to the compiler flags while compiling Google Test and your tests. If |
||||
you want to force Google Test to use its own tuple library, just add |
||||
|
||||
-DGTEST_USE_OWN_TR1_TUPLE=1 |
||||
|
||||
to the compiler flags instead. |
||||
|
||||
If you don't want Google Test to use tuple at all, add |
||||
|
||||
-DGTEST_HAS_TR1_TUPLE=0 |
||||
|
||||
and all features using tuple will be disabled. |
||||
|
||||
### Multi-threaded Tests ### |
||||
|
||||
Google Test is thread-safe where the pthread library is available. |
||||
After #include "gtest/gtest.h", you can check the GTEST_IS_THREADSAFE |
||||
macro to see whether this is the case (yes if the macro is #defined to |
||||
1, no if it's undefined.). |
||||
|
||||
If Google Test doesn't correctly detect whether pthread is available |
||||
in your environment, you can force it with |
||||
|
||||
-DGTEST_HAS_PTHREAD=1 |
||||
|
||||
or |
||||
|
||||
-DGTEST_HAS_PTHREAD=0 |
||||
|
||||
When Google Test uses pthread, you may need to add flags to your |
||||
compiler and/or linker to select the pthread library, or you'll get |
||||
link errors. If you use the CMake script or the deprecated Autotools |
||||
script, this is taken care of for you. If you use your own build |
||||
script, you'll need to read your compiler and linker's manual to |
||||
figure out what flags to add. |
||||
|
||||
### As a Shared Library (DLL) ### |
||||
|
||||
Google Test is compact, so most users can build and link it as a |
||||
static library for the simplicity. You can choose to use Google Test |
||||
as a shared library (known as a DLL on Windows) if you prefer. |
||||
|
||||
To compile *gtest* as a shared library, add |
||||
|
||||
-DGTEST_CREATE_SHARED_LIBRARY=1 |
||||
|
||||
to the compiler flags. You'll also need to tell the linker to produce |
||||
a shared library instead - consult your linker's manual for how to do |
||||
it. |
||||
|
||||
To compile your *tests* that use the gtest shared library, add |
||||
|
||||
-DGTEST_LINKED_AS_SHARED_LIBRARY=1 |
||||
|
||||
to the compiler flags. |
||||
|
||||
Note: while the above steps aren't technically necessary today when |
||||
using some compilers (e.g. GCC), they may become necessary in the |
||||
future, if we decide to improve the speed of loading the library (see |
||||
http://gcc.gnu.org/wiki/Visibility for details). Therefore you are |
||||
recommended to always add the above flags when using Google Test as a |
||||
shared library. Otherwise a future release of Google Test may break |
||||
your build script. |
||||
|
||||
### Avoiding Macro Name Clashes ### |
||||
|
||||
In C++, macros don't obey namespaces. Therefore two libraries that |
||||
both define a macro of the same name will clash if you #include both |
||||
definitions. In case a Google Test macro clashes with another |
||||
library, you can force Google Test to rename its macro to avoid the |
||||
conflict. |
||||
|
||||
Specifically, if both Google Test and some other code define macro |
||||
FOO, you can add |
||||
|
||||
-DGTEST_DONT_DEFINE_FOO=1 |
||||
|
||||
to the compiler flags to tell Google Test to change the macro's name |
||||
from FOO to GTEST_FOO. Currently FOO can be FAIL, SUCCEED, or TEST. |
||||
For example, with -DGTEST_DONT_DEFINE_TEST=1, you'll need to write |
||||
|
||||
GTEST_TEST(SomeTest, DoesThis) { ... } |
||||
|
||||
instead of |
||||
|
||||
TEST(SomeTest, DoesThis) { ... } |
||||
|
||||
in order to define a test. |
||||
|
||||
Upgrating from an Earlier Version |
||||
--------------------------------- |
||||
|
||||
We strive to keep Google Test releases backward compatible. |
||||
Sometimes, though, we have to make some breaking changes for the |
||||
users' long-term benefits. This section describes what you'll need to |
||||
do if you are upgrading from an earlier version of Google Test. |
||||
|
||||
### Upgrading from 1.3.0 or Earlier ### |
||||
|
||||
You may need to explicitly enable or disable Google Test's own TR1 |
||||
tuple library. See the instructions in section "Choosing a TR1 Tuple |
||||
Library". |
||||
|
||||
### Upgrading from 1.4.0 or Earlier ### |
||||
|
||||
The Autotools build script (configure + make) is no longer officially |
||||
supportted. You are encouraged to migrate to your own build system or |
||||
use CMake. If you still need to use Autotools, you can find |
||||
instructions in the README file from Google Test 1.4.0. |
||||
|
||||
On platforms where the pthread library is available, Google Test uses |
||||
it in order to be thread-safe. See the "Multi-threaded Tests" section |
||||
for what this means to your build script. |
||||
|
||||
If you use Microsoft Visual C++ 7.1 with exceptions disabled, Google |
||||
Test will no longer compile. This should affect very few people, as a |
||||
large portion of STL (including <string>) doesn't compile in this mode |
||||
anyway. We decided to stop supporting it in order to greatly simplify |
||||
Google Test's implementation. |
||||
|
||||
Developing Google Test |
||||
---------------------- |
||||
|
||||
This section discusses how to make your own changes to Google Test. |
||||
|
||||
### Testing Google Test Itself ### |
||||
|
||||
To make sure your changes work as intended and don't break existing |
||||
functionality, you'll want to compile and run Google Test's own tests. |
||||
For that you can use CMake: |
||||
|
||||
mkdir mybuild |
||||
cd mybuild |
||||
cmake -Dgtest_build_tests=ON ${GTEST_DIR} |
||||
|
||||
Make sure you have Python installed, as some of Google Test's tests |
||||
are written in Python. If the cmake command complains about not being |
||||
able to find Python ("Could NOT find PythonInterp (missing: |
||||
PYTHON_EXECUTABLE)"), try telling it explicitly where your Python |
||||
executable can be found: |
||||
|
||||
cmake -DPYTHON_EXECUTABLE=path/to/python -Dgtest_build_tests=ON ${GTEST_DIR} |
||||
|
||||
Next, you can build Google Test and all of its own tests. On *nix, |
||||
this is usually done by 'make'. To run the tests, do |
||||
|
||||
make test |
||||
|
||||
All tests should pass. |
||||
|
||||
### Regenerating Source Files ### |
||||
|
||||
Some of Google Test's source files are generated from templates (not |
||||
in the C++ sense) using a script. A template file is named FOO.pump, |
||||
where FOO is the name of the file it will generate. For example, the |
||||
file include/gtest/internal/gtest-type-util.h.pump is used to generate |
||||
gtest-type-util.h in the same directory. |
||||
|
||||
Normally you don't need to worry about regenerating the source files, |
||||
unless you need to modify them. In that case, you should modify the |
||||
corresponding .pump files instead and run the pump.py Python script to |
||||
regenerate them. You can find pump.py in the scripts/ directory. |
||||
Read the Pump manual [2] for how to use it. |
||||
|
||||
[2] http://code.google.com/p/googletest/wiki/PumpManual |
||||
|
||||
### Contributing a Patch ### |
||||
|
||||
We welcome patches. Please read the Google Test developer's guide [3] |
||||
for how you can contribute. In particular, make sure you have signed |
||||
the Contributor License Agreement, or we won't be able to accept the |
||||
patch. |
||||
|
||||
[3] http://code.google.com/p/googletest/wiki/GoogleTestDevGuide |
||||
|
||||
Happy testing! |
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,216 @@
|
||||
# Defines functions and macros useful for building Google Test and |
||||
# Google Mock. |
||||
# |
||||
# Note: |
||||
# |
||||
# - This file will be run twice when building Google Mock (once via |
||||
# Google Test's CMakeLists.txt, and once via Google Mock's). |
||||
# Therefore it shouldn't have any side effects other than defining |
||||
# the functions and macros. |
||||
# |
||||
# - The functions/macros defined in this file may depend on Google |
||||
# Test and Google Mock's option() definitions, and thus must be |
||||
# called *after* the options have been defined. |
||||
|
||||
# Tweaks CMake's default compiler/linker settings to suit Google Test's needs. |
||||
# |
||||
# This must be a macro(), as inside a function string() can only |
||||
# update variables in the function scope. |
||||
macro(fix_default_compiler_settings_) |
||||
if (MSVC) |
||||
# For MSVC, CMake sets certain flags to defaults we want to override. |
||||
# This replacement code is taken from sample in the CMake Wiki at |
||||
# http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace. |
||||
foreach (flag_var |
||||
CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE |
||||
CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) |
||||
if (NOT BUILD_SHARED_LIBS AND NOT gtest_force_shared_crt) |
||||
# When Google Test is built as a shared library, it should also use |
||||
# shared runtime libraries. Otherwise, it may end up with multiple |
||||
# copies of runtime library data in different modules, resulting in |
||||
# hard-to-find crashes. When it is built as a static library, it is |
||||
# preferable to use CRT as static libraries, as we don't have to rely |
||||
# on CRT DLLs being available. CMake always defaults to using shared |
||||
# CRT libraries, so we override that default here. |
||||
string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}") |
||||
endif() |
||||
|
||||
# We prefer more strict warning checking for building Google Test. |
||||
# Replaces /W3 with /W4 in defaults. |
||||
string(REPLACE "/W3" "-W4" ${flag_var} "${${flag_var}}") |
||||
endforeach() |
||||
endif() |
||||
endmacro() |
||||
|
||||
# Defines the compiler/linker flags used to build Google Test and |
||||
# Google Mock. You can tweak these definitions to suit your need. A |
||||
# variable's value is empty before it's explicitly assigned to. |
||||
macro(config_compiler_and_linker) |
||||
if (NOT gtest_disable_pthreads) |
||||
# Defines CMAKE_USE_PTHREADS_INIT and CMAKE_THREAD_LIBS_INIT. |
||||
find_package(Threads) |
||||
endif() |
||||
|
||||
fix_default_compiler_settings_() |
||||
if (MSVC) |
||||
# Newlines inside flags variables break CMake's NMake generator. |
||||
# TODO(vladl@google.com): Add -RTCs and -RTCu to debug builds. |
||||
set(cxx_base_flags "-GS -W4 -WX -wd4127 -wd4251 -wd4275 -nologo -J -Zi") |
||||
set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32") |
||||
set(cxx_base_flags "${cxx_base_flags} -DSTRICT -DWIN32_LEAN_AND_MEAN") |
||||
set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1") |
||||
set(cxx_no_exception_flags "-D_HAS_EXCEPTIONS=0") |
||||
set(cxx_no_rtti_flags "-GR-") |
||||
elseif (CMAKE_COMPILER_IS_GNUCXX) |
||||
set(cxx_base_flags "-Wall -Wshadow") |
||||
set(cxx_exception_flags "-fexceptions") |
||||
set(cxx_no_exception_flags "-fno-exceptions") |
||||
# Until version 4.3.2, GCC doesn't define a macro to indicate |
||||
# whether RTTI is enabled. Therefore we define GTEST_HAS_RTTI |
||||
# explicitly. |
||||
set(cxx_no_rtti_flags "-fno-rtti -DGTEST_HAS_RTTI=0") |
||||
set(cxx_strict_flags "-Wextra") |
||||
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "SunPro") |
||||
set(cxx_exception_flags "-features=except") |
||||
# Sun Pro doesn't provide macros to indicate whether exceptions and |
||||
# RTTI are enabled, so we define GTEST_HAS_* explicitly. |
||||
set(cxx_no_exception_flags "-features=no%except -DGTEST_HAS_EXCEPTIONS=0") |
||||
set(cxx_no_rtti_flags "-features=no%rtti -DGTEST_HAS_RTTI=0") |
||||
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "VisualAge" OR |
||||
CMAKE_CXX_COMPILER_ID STREQUAL "XL") |
||||
# CMake 2.8 changes Visual Age's compiler ID to "XL". |
||||
set(cxx_exception_flags "-qeh") |
||||
set(cxx_no_exception_flags "-qnoeh") |
||||
# Until version 9.0, Visual Age doesn't define a macro to indicate |
||||
# whether RTTI is enabled. Therefore we define GTEST_HAS_RTTI |
||||
# explicitly. |
||||
set(cxx_no_rtti_flags "-qnortti -DGTEST_HAS_RTTI=0") |
||||
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "HP") |
||||
set(cxx_base_flags "-AA -mt") |
||||
set(cxx_exception_flags "-DGTEST_HAS_EXCEPTIONS=1") |
||||
set(cxx_no_exception_flags "+noeh -DGTEST_HAS_EXCEPTIONS=0") |
||||
# RTTI can not be disabled in HP aCC compiler. |
||||
set(cxx_no_rtti_flags "") |
||||
endif() |
||||
|
||||
if (CMAKE_USE_PTHREADS_INIT) # The pthreads library is available and allowed. |
||||
set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=1") |
||||
else() |
||||
set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=0") |
||||
endif() |
||||
|
||||
# For building gtest's own tests and samples. |
||||
set(cxx_exception "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_exception_flags}") |
||||
set(cxx_no_exception |
||||
"${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_no_exception_flags}") |
||||
set(cxx_default "${cxx_exception}") |
||||
set(cxx_no_rtti "${cxx_default} ${cxx_no_rtti_flags}") |
||||
set(cxx_use_own_tuple "${cxx_default} -DGTEST_USE_OWN_TR1_TUPLE=1") |
||||
|
||||
# For building the gtest libraries. |
||||
set(cxx_strict "${cxx_default} ${cxx_strict_flags}") |
||||
endmacro() |
||||
|
||||
# Defines the gtest & gtest_main libraries. User tests should link |
||||
# with one of them. |
||||
function(cxx_library_with_type name type cxx_flags) |
||||
# type can be either STATIC or SHARED to denote a static or shared library. |
||||
# ARGN refers to additional arguments after 'cxx_flags'. |
||||
add_library(${name} ${type} ${ARGN}) |
||||
set_target_properties(${name} |
||||
PROPERTIES |
||||
COMPILE_FLAGS "${cxx_flags}") |
||||
if (BUILD_SHARED_LIBS OR type STREQUAL "SHARED") |
||||
set_target_properties(${name} |
||||
PROPERTIES |
||||
COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1") |
||||
endif() |
||||
if (CMAKE_USE_PTHREADS_INIT) |
||||
target_link_libraries(${name} ${CMAKE_THREAD_LIBS_INIT}) |
||||
endif() |
||||
endfunction() |
||||
|
||||
######################################################################## |
||||
# |
||||
# Helper functions for creating build targets. |
||||
|
||||
function(cxx_shared_library name cxx_flags) |
||||
cxx_library_with_type(${name} SHARED "${cxx_flags}" ${ARGN}) |
||||
endfunction() |
||||
|
||||
function(cxx_library name cxx_flags) |
||||
cxx_library_with_type(${name} "" "${cxx_flags}" ${ARGN}) |
||||
endfunction() |
||||
|
||||
# cxx_executable_with_flags(name cxx_flags libs srcs...) |
||||
# |
||||
# creates a named C++ executable that depends on the given libraries and |
||||
# is built from the given source files with the given compiler flags. |
||||
function(cxx_executable_with_flags name cxx_flags libs) |
||||
add_executable(${name} ${ARGN}) |
||||
if (cxx_flags) |
||||
set_target_properties(${name} |
||||
PROPERTIES |
||||
COMPILE_FLAGS "${cxx_flags}") |
||||
endif() |
||||
if (BUILD_SHARED_LIBS) |
||||
set_target_properties(${name} |
||||
PROPERTIES |
||||
COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1") |
||||
endif() |
||||
# To support mixing linking in static and dynamic libraries, link each |
||||
# library in with an extra call to target_link_libraries. |
||||
foreach (lib "${libs}") |
||||
target_link_libraries(${name} ${lib}) |
||||
endforeach() |
||||
endfunction() |
||||
|
||||
# cxx_executable(name dir lib srcs...) |
||||
# |
||||
# creates a named target that depends on the given libs and is built |
||||
# from the given source files. dir/name.cc is implicitly included in |
||||
# the source file list. |
||||
function(cxx_executable name dir libs) |
||||
cxx_executable_with_flags( |
||||
${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN}) |
||||
endfunction() |
||||
|
||||
# Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE. |
||||
find_package(PythonInterp) |
||||
|
||||
# cxx_test_with_flags(name cxx_flags libs srcs...) |
||||
# |
||||
# creates a named C++ test that depends on the given libs and is built |
||||
# from the given source files with the given compiler flags. |
||||
function(cxx_test_with_flags name cxx_flags libs) |
||||
cxx_executable_with_flags(${name} "${cxx_flags}" "${libs}" ${ARGN}) |
||||
add_test(${name} ${name}) |
||||
endfunction() |
||||
|
||||
# cxx_test(name libs srcs...) |
||||
# |
||||
# creates a named test target that depends on the given libs and is |
||||
# built from the given source files. Unlike cxx_test_with_flags, |
||||
# test/name.cc is already implicitly included in the source file list. |
||||
function(cxx_test name libs) |
||||
cxx_test_with_flags("${name}" "${cxx_default}" "${libs}" |
||||
"test/${name}.cc" ${ARGN}) |
||||
endfunction() |
||||
|
||||
# py_test(name) |
||||
# |
||||
# creates a Python test with the given name whose main module is in |
||||
# test/name.py. It does nothing if Python is not installed. |
||||
function(py_test name) |
||||
# We are not supporting Python tests on Linux yet as they consider |
||||
# all Linux environments to be google3 and try to use google3 features. |
||||
if (PYTHONINTERP_FOUND) |
||||
# ${CMAKE_BINARY_DIR} is known at configuration time, so we can |
||||
# directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known |
||||
# only at ctest runtime (by calling ctest -c <Configuration>), so |
||||
# we have to escape $ to delay variable substitution here. |
||||
add_test(${name} |
||||
${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py |
||||
--build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE}) |
||||
endif() |
||||
endfunction() |
@ -0,0 +1,138 @@
|
||||
<?xml version="1.0" encoding="utf-8"?> |
||||
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
||||
<PropertyGroup> |
||||
<ProjectGuid>{bca37a72-5b07-46cf-b44e-89f8e06451a2}</ProjectGuid> |
||||
<Config Condition="'$(Config)'==''">Release</Config> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''"> |
||||
<Base>true</Base> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''"> |
||||
<Base>true</Base> |
||||
<Cfg_1>true</Cfg_1> |
||||
<CfgParent>Base</CfgParent> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''"> |
||||
<Base>true</Base> |
||||
<Cfg_2>true</Cfg_2> |
||||
<CfgParent>Base</CfgParent> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Base)'!=''"> |
||||
<BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed> |
||||
<OutputExt>lib</OutputExt> |
||||
<DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput> |
||||
<Defines>NO_STRICT</Defines> |
||||
<DynamicRTL>true</DynamicRTL> |
||||
<UsePackages>true</UsePackages> |
||||
<ProjectType>CppStaticLibrary</ProjectType> |
||||
<BCC_CPPCompileAlways>true</BCC_CPPCompileAlways> |
||||
<PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;dclZipForged11.bpi;vclZipForged11.bpi;GR32_BDS2006.bpi;GR32_DSGN_BDS2006.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi;CExceptionExpert11.bpi</PackageImports> |
||||
<BCC_wpar>false</BCC_wpar> |
||||
<IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</IncludePath> |
||||
<AllPackageLibs>rtl.lib;vcl.lib</AllPackageLibs> |
||||
<TLIB_PageSize>32</TLIB_PageSize> |
||||
<ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</ILINK_LibraryPath> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Cfg_1)'!=''"> |
||||
<BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed> |
||||
<DCC_Optimize>false</DCC_Optimize> |
||||
<DCC_DebugInfoInExe>true</DCC_DebugInfoInExe> |
||||
<Defines>_DEBUG;$(Defines)</Defines> |
||||
<ILINK_FullDebugInfo>true</ILINK_FullDebugInfo> |
||||
<BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion> |
||||
<ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking> |
||||
<BCC_UseRegisterVariables>None</BCC_UseRegisterVariables> |
||||
<DCC_Define>DEBUG</DCC_Define> |
||||
<BCC_DebugLineNumbers>true</BCC_DebugLineNumbers> |
||||
<IntermediateOutputDir>Debug</IntermediateOutputDir> |
||||
<TASM_DisplaySourceLines>true</TASM_DisplaySourceLines> |
||||
<BCC_StackFrames>true</BCC_StackFrames> |
||||
<BCC_DisableOptimizations>true</BCC_DisableOptimizations> |
||||
<ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath> |
||||
<TASM_Debugging>Full</TASM_Debugging> |
||||
<BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Cfg_2)'!=''"> |
||||
<Defines>NDEBUG;$(Defines)</Defines> |
||||
<IntermediateOutputDir>Release</IntermediateOutputDir> |
||||
<ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath> |
||||
<TASM_Debugging>None</TASM_Debugging> |
||||
</PropertyGroup> |
||||
<ProjectExtensions> |
||||
<Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality> |
||||
<Borland.ProjectType>CppStaticLibrary</Borland.ProjectType> |
||||
<BorlandProject> |
||||
<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages> |
||||
|
||||
|
||||
<Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages> |
||||
<Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages> |
||||
</Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\src;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">1</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines><HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Count">1</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item0">32</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item1">16</HistoryLists_hlTLIB_PageSize></HistoryLists_hlTLIB_PageSize></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject> |
||||
</ProjectExtensions> |
||||
<Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" /> |
||||
<ItemGroup> |
||||
<None Include="..\include\gtest\gtest-death-test.h"> |
||||
<BuildOrder>3</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\gtest-message.h"> |
||||
<BuildOrder>4</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\gtest-param-test.h"> |
||||
<BuildOrder>5</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\gtest-spi.h"> |
||||
<BuildOrder>6</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\gtest-test-part.h"> |
||||
<BuildOrder>7</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\gtest-typed-test.h"> |
||||
<BuildOrder>8</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\gtest.h"> |
||||
<BuildOrder>0</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\gtest_pred_impl.h"> |
||||
<BuildOrder>1</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\gtest_prod.h"> |
||||
<BuildOrder>2</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-death-test-internal.h"> |
||||
<BuildOrder>9</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-filepath.h"> |
||||
<BuildOrder>10</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-internal.h"> |
||||
<BuildOrder>11</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-linked_ptr.h"> |
||||
<BuildOrder>12</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-param-util-generated.h"> |
||||
<BuildOrder>14</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-param-util.h"> |
||||
<BuildOrder>13</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-port.h"> |
||||
<BuildOrder>15</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-string.h"> |
||||
<BuildOrder>16</BuildOrder> |
||||
</None> |
||||
<None Include="..\include\gtest\internal\gtest-type-util.h"> |
||||
<BuildOrder>17</BuildOrder> |
||||
</None> |
||||
<CppCompile Include="gtest_all.cc"> |
||||
<BuildOrder>18</BuildOrder> |
||||
</CppCompile> |
||||
<BuildConfiguration Include="Debug"> |
||||
<Key>Cfg_1</Key> |
||||
</BuildConfiguration> |
||||
<BuildConfiguration Include="Release"> |
||||
<Key>Cfg_2</Key> |
||||
</BuildConfiguration> |
||||
</ItemGroup> |
||||
</Project> |
@ -0,0 +1,54 @@
|
||||
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
||||
<PropertyGroup> |
||||
<ProjectGuid>{c1d923e0-6cba-4332-9b6f-3420acbf5091}</ProjectGuid> |
||||
</PropertyGroup> |
||||
<ItemGroup /> |
||||
<ItemGroup> |
||||
<Projects Include="gtest.cbproj" /> |
||||
<Projects Include="gtest_main.cbproj" /> |
||||
<Projects Include="gtest_unittest.cbproj" /> |
||||
</ItemGroup> |
||||
<ProjectExtensions> |
||||
<Borland.Personality>Default.Personality</Borland.Personality> |
||||
<Borland.ProjectType /> |
||||
<BorlandProject> |
||||
<BorlandProject xmlns=""><Default.Personality></Default.Personality></BorlandProject></BorlandProject> |
||||
</ProjectExtensions> |
||||
<Target Name="gtest"> |
||||
<MSBuild Projects="gtest.cbproj" Targets="" /> |
||||
</Target> |
||||
<Target Name="gtest:Clean"> |
||||
<MSBuild Projects="gtest.cbproj" Targets="Clean" /> |
||||
</Target> |
||||
<Target Name="gtest:Make"> |
||||
<MSBuild Projects="gtest.cbproj" Targets="Make" /> |
||||
</Target> |
||||
<Target Name="gtest_main"> |
||||
<MSBuild Projects="gtest_main.cbproj" Targets="" /> |
||||
</Target> |
||||
<Target Name="gtest_main:Clean"> |
||||
<MSBuild Projects="gtest_main.cbproj" Targets="Clean" /> |
||||
</Target> |
||||
<Target Name="gtest_main:Make"> |
||||
<MSBuild Projects="gtest_main.cbproj" Targets="Make" /> |
||||
</Target> |
||||
<Target Name="gtest_unittest"> |
||||
<MSBuild Projects="gtest_unittest.cbproj" Targets="" /> |
||||
</Target> |
||||
<Target Name="gtest_unittest:Clean"> |
||||
<MSBuild Projects="gtest_unittest.cbproj" Targets="Clean" /> |
||||
</Target> |
||||
<Target Name="gtest_unittest:Make"> |
||||
<MSBuild Projects="gtest_unittest.cbproj" Targets="Make" /> |
||||
</Target> |
||||
<Target Name="Build"> |
||||
<CallTarget Targets="gtest;gtest_main;gtest_unittest" /> |
||||
</Target> |
||||
<Target Name="Clean"> |
||||
<CallTarget Targets="gtest:Clean;gtest_main:Clean;gtest_unittest:Clean" /> |
||||
</Target> |
||||
<Target Name="Make"> |
||||
<CallTarget Targets="gtest:Make;gtest_main:Make;gtest_unittest:Make" /> |
||||
</Target> |
||||
<Import Condition="Exists('$(MSBuildBinPath)\Borland.Group.Targets')" Project="$(MSBuildBinPath)\Borland.Group.Targets" /> |
||||
</Project> |
@ -0,0 +1,38 @@
|
||||
// Copyright 2009, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: Josh Kelley (joshkel@gmail.com)
|
||||
//
|
||||
// Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// C++Builder's IDE cannot build a static library from files with hyphens
|
||||
// in their name. See http://qc.codegear.com/wc/qcmain.aspx?d=70977 .
|
||||
// This file serves as a workaround.
|
||||
|
||||
#include "src/gtest-all.cc" |
@ -0,0 +1,40 @@
|
||||
// Copyright 2009, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: Josh Kelley (joshkel@gmail.com)
|
||||
//
|
||||
// Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// Links gtest.lib and gtest_main.lib into the current project in C++Builder.
|
||||
// This means that these libraries can't be renamed, but it's the only way to
|
||||
// ensure that Debug versus Release test builds are linked against the
|
||||
// appropriate Debug or Release build of the libraries.
|
||||
|
||||
#pragma link "gtest.lib" |
||||
#pragma link "gtest_main.lib" |
@ -0,0 +1,82 @@
|
||||
<?xml version="1.0" encoding="utf-8"?> |
||||
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
||||
<PropertyGroup> |
||||
<ProjectGuid>{bca37a72-5b07-46cf-b44e-89f8e06451a2}</ProjectGuid> |
||||
<Config Condition="'$(Config)'==''">Release</Config> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''"> |
||||
<Base>true</Base> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''"> |
||||
<Base>true</Base> |
||||
<Cfg_1>true</Cfg_1> |
||||
<CfgParent>Base</CfgParent> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''"> |
||||
<Base>true</Base> |
||||
<Cfg_2>true</Cfg_2> |
||||
<CfgParent>Base</CfgParent> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Base)'!=''"> |
||||
<BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed> |
||||
<OutputExt>lib</OutputExt> |
||||
<DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput> |
||||
<Defines>NO_STRICT</Defines> |
||||
<DynamicRTL>true</DynamicRTL> |
||||
<UsePackages>true</UsePackages> |
||||
<ProjectType>CppStaticLibrary</ProjectType> |
||||
<BCC_CPPCompileAlways>true</BCC_CPPCompileAlways> |
||||
<PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;dclZipForged11.bpi;vclZipForged11.bpi;GR32_BDS2006.bpi;GR32_DSGN_BDS2006.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi;CExceptionExpert11.bpi</PackageImports> |
||||
<BCC_wpar>false</BCC_wpar> |
||||
<IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</IncludePath> |
||||
<AllPackageLibs>rtl.lib;vcl.lib</AllPackageLibs> |
||||
<TLIB_PageSize>32</TLIB_PageSize> |
||||
<ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</ILINK_LibraryPath> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Cfg_1)'!=''"> |
||||
<BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed> |
||||
<DCC_Optimize>false</DCC_Optimize> |
||||
<DCC_DebugInfoInExe>true</DCC_DebugInfoInExe> |
||||
<Defines>_DEBUG;$(Defines)</Defines> |
||||
<ILINK_FullDebugInfo>true</ILINK_FullDebugInfo> |
||||
<BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion> |
||||
<ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking> |
||||
<BCC_UseRegisterVariables>None</BCC_UseRegisterVariables> |
||||
<DCC_Define>DEBUG</DCC_Define> |
||||
<BCC_DebugLineNumbers>true</BCC_DebugLineNumbers> |
||||
<IntermediateOutputDir>Debug</IntermediateOutputDir> |
||||
<TASM_DisplaySourceLines>true</TASM_DisplaySourceLines> |
||||
<BCC_StackFrames>true</BCC_StackFrames> |
||||
<BCC_DisableOptimizations>true</BCC_DisableOptimizations> |
||||
<ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath> |
||||
<TASM_Debugging>Full</TASM_Debugging> |
||||
<BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Cfg_2)'!=''"> |
||||
<Defines>NDEBUG;$(Defines)</Defines> |
||||
<IntermediateOutputDir>Release</IntermediateOutputDir> |
||||
<ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath> |
||||
<TASM_Debugging>None</TASM_Debugging> |
||||
</PropertyGroup> |
||||
<ProjectExtensions> |
||||
<Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality> |
||||
<Borland.ProjectType>CppStaticLibrary</Borland.ProjectType> |
||||
<BorlandProject> |
||||
<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages> |
||||
<Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages> |
||||
<Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages> |
||||
</Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\src;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">1</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines><HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Count">1</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item0">32</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item1">16</HistoryLists_hlTLIB_PageSize></HistoryLists_hlTLIB_PageSize></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject> |
||||
</ProjectExtensions> |
||||
<Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" /> |
||||
<ItemGroup> |
||||
<CppCompile Include="..\src\gtest_main.cc"> |
||||
<BuildOrder>0</BuildOrder> |
||||
</CppCompile> |
||||
<BuildConfiguration Include="Debug"> |
||||
<Key>Cfg_1</Key> |
||||
</BuildConfiguration> |
||||
<BuildConfiguration Include="Release"> |
||||
<Key>Cfg_2</Key> |
||||
</BuildConfiguration> |
||||
</ItemGroup> |
||||
</Project> |
@ -0,0 +1,88 @@
|
||||
<?xml version="1.0" encoding="utf-8"?> |
||||
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
||||
<PropertyGroup> |
||||
<ProjectGuid>{eea63393-5ac5-4b9c-8909-d75fef2daa41}</ProjectGuid> |
||||
<Config Condition="'$(Config)'==''">Release</Config> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''"> |
||||
<Base>true</Base> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''"> |
||||
<Base>true</Base> |
||||
<Cfg_1>true</Cfg_1> |
||||
<CfgParent>Base</CfgParent> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''"> |
||||
<Base>true</Base> |
||||
<Cfg_2>true</Cfg_2> |
||||
<CfgParent>Base</CfgParent> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Base)'!=''"> |
||||
<OutputExt>exe</OutputExt> |
||||
<BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed> |
||||
<Defines>NO_STRICT</Defines> |
||||
<DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput> |
||||
<DynamicRTL>true</DynamicRTL> |
||||
<ILINK_ObjectSearchPath>..\test</ILINK_ObjectSearchPath> |
||||
<UsePackages>true</UsePackages> |
||||
<ProjectType>CppConsoleApplication</ProjectType> |
||||
<NoVCL>true</NoVCL> |
||||
<BCC_CPPCompileAlways>true</BCC_CPPCompileAlways> |
||||
<PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi</PackageImports> |
||||
<BCC_wpar>false</BCC_wpar> |
||||
<IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test;..</IncludePath> |
||||
<ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</ILINK_LibraryPath> |
||||
<Multithreaded>true</Multithreaded> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Cfg_1)'!=''"> |
||||
<BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed> |
||||
<DCC_Optimize>false</DCC_Optimize> |
||||
<DCC_DebugInfoInExe>true</DCC_DebugInfoInExe> |
||||
<Defines>_DEBUG;$(Defines)</Defines> |
||||
<ILINK_FullDebugInfo>true</ILINK_FullDebugInfo> |
||||
<BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion> |
||||
<ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking> |
||||
<BCC_UseRegisterVariables>None</BCC_UseRegisterVariables> |
||||
<DCC_Define>DEBUG</DCC_Define> |
||||
<BCC_DebugLineNumbers>true</BCC_DebugLineNumbers> |
||||
<IntermediateOutputDir>Debug</IntermediateOutputDir> |
||||
<TASM_DisplaySourceLines>true</TASM_DisplaySourceLines> |
||||
<BCC_StackFrames>true</BCC_StackFrames> |
||||
<BCC_DisableOptimizations>true</BCC_DisableOptimizations> |
||||
<ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath> |
||||
<TASM_Debugging>Full</TASM_Debugging> |
||||
<BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition="'$(Cfg_2)'!=''"> |
||||
<Defines>NDEBUG;$(Defines)</Defines> |
||||
<IntermediateOutputDir>Release</IntermediateOutputDir> |
||||
<ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath> |
||||
<TASM_Debugging>None</TASM_Debugging> |
||||
</PropertyGroup> |
||||
<ProjectExtensions> |
||||
<Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality> |
||||
<Borland.ProjectType>CppConsoleApplication</Borland.ProjectType> |
||||
<BorlandProject> |
||||
<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages> |
||||
|
||||
|
||||
<Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages> |
||||
<Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages> |
||||
</Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item1">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item2">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;$(OUTPUTDIR);..\test</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">2</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item1">STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject> |
||||
</ProjectExtensions> |
||||
<Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" /> |
||||
<ItemGroup> |
||||
<CppCompile Include="..\test\gtest_unittest.cc"> |
||||
<BuildOrder>0</BuildOrder> |
||||
</CppCompile> |
||||
<CppCompile Include="gtest_link.cc"> |
||||
<BuildOrder>1</BuildOrder> |
||||
</CppCompile> |
||||
<BuildConfiguration Include="Debug"> |
||||
<Key>Cfg_1</Key> |
||||
</BuildConfiguration> |
||||
<BuildConfiguration Include="Release"> |
||||
<Key>Cfg_2</Key> |
||||
</BuildConfiguration> |
||||
</ItemGroup> |
||||
</Project> |
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,68 @@
|
||||
m4_include(m4/acx_pthread.m4) |
||||
|
||||
# At this point, the Xcode project assumes the version string will be three |
||||
# integers separated by periods and surrounded by square brackets (e.g. |
||||
# "[1.0.1]"). It also asumes that there won't be any closing parenthesis |
||||
# between "AC_INIT(" and the closing ")" including comments and strings. |
||||
AC_INIT([Google C++ Testing Framework], |
||||
[1.6.0], |
||||
[googletestframework@googlegroups.com], |
||||
[gtest]) |
||||
|
||||
# Provide various options to initialize the Autoconf and configure processes. |
||||
AC_PREREQ([2.59]) |
||||
AC_CONFIG_SRCDIR([./COPYING]) |
||||
AC_CONFIG_MACRO_DIR([m4]) |
||||
AC_CONFIG_AUX_DIR([build-aux]) |
||||
AC_CONFIG_HEADERS([build-aux/config.h]) |
||||
AC_CONFIG_FILES([Makefile]) |
||||
AC_CONFIG_FILES([scripts/gtest-config], [chmod +x scripts/gtest-config]) |
||||
|
||||
# Initialize Automake with various options. We require at least v1.9, prevent |
||||
# pedantic complaints about package files, and enable various distribution |
||||
# targets. |
||||
AM_INIT_AUTOMAKE([1.9 dist-bzip2 dist-zip foreign subdir-objects]) |
||||
|
||||
# Check for programs used in building Google Test. |
||||
AC_PROG_CC |
||||
AC_PROG_CXX |
||||
AC_LANG([C++]) |
||||
AC_PROG_LIBTOOL |
||||
|
||||
# TODO(chandlerc@google.com): Currently we aren't running the Python tests |
||||
# against the interpreter detected by AM_PATH_PYTHON, and so we condition |
||||
# HAVE_PYTHON by requiring "python" to be in the PATH, and that interpreter's |
||||
# version to be >= 2.3. This will allow the scripts to use a "/usr/bin/env" |
||||
# hashbang. |
||||
PYTHON= # We *do not* allow the user to specify a python interpreter |
||||
AC_PATH_PROG([PYTHON],[python],[:]) |
||||
AS_IF([test "$PYTHON" != ":"], |
||||
[AM_PYTHON_CHECK_VERSION([$PYTHON],[2.3],[:],[PYTHON=":"])]) |
||||
AM_CONDITIONAL([HAVE_PYTHON],[test "$PYTHON" != ":"]) |
||||
|
||||
# Configure pthreads. |
||||
AC_ARG_WITH([pthreads], |
||||
[AS_HELP_STRING([--with-pthreads], |
||||
[use pthreads (default is yes)])], |
||||
[with_pthreads=$withval], |
||||
[with_pthreads=check]) |
||||
|
||||
have_pthreads=no |
||||
AS_IF([test "x$with_pthreads" != "xno"], |
||||
[ACX_PTHREAD( |
||||
[], |
||||
[AS_IF([test "x$with_pthreads" != "xcheck"], |
||||
[AC_MSG_FAILURE( |
||||
[--with-pthreads was specified, but unable to be used])])]) |
||||
have_pthreads="$acx_pthread_ok"]) |
||||
AM_CONDITIONAL([HAVE_PTHREADS],[test "x$have_pthreads" == "xyes"]) |
||||
AC_SUBST(PTHREAD_CFLAGS) |
||||
AC_SUBST(PTHREAD_LIBS) |
||||
|
||||
# TODO(chandlerc@google.com) Check for the necessary system headers. |
||||
|
||||
# TODO(chandlerc@google.com) Check the types, structures, and other compiler |
||||
# and architecture characteristics. |
||||
|
||||
# Output the generated files. No further autoconf macros may be used. |
||||
AC_OUTPUT |
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1 @@
|
||||
# dummy |
@ -0,0 +1 @@
|
||||
# dummy |
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,39 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#include <iostream> |
||||
|
||||
#include "gtest/gtest.h" |
||||
|
||||
GTEST_API_ int main(int argc, char **argv) { |
||||
std::cout << "Running main() from gtest_main.cc\n"; |
||||
|
||||
testing::InitGoogleTest(&argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
@ -0,0 +1,283 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// The Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// This header file defines the public API for death tests. It is
|
||||
// #included by gtest.h so a user doesn't need to include this
|
||||
// directly.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ |
||||
|
||||
#include "gtest/internal/gtest-death-test-internal.h" |
||||
|
||||
namespace testing { |
||||
|
||||
// This flag controls the style of death tests. Valid values are "threadsafe",
|
||||
// meaning that the death test child process will re-execute the test binary
|
||||
// from the start, running only a single death test, or "fast",
|
||||
// meaning that the child process will execute the test logic immediately
|
||||
// after forking.
|
||||
GTEST_DECLARE_string_(death_test_style); |
||||
|
||||
#if GTEST_HAS_DEATH_TEST |
||||
|
||||
// The following macros are useful for writing death tests.
|
||||
|
||||
// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
|
||||
// executed:
|
||||
//
|
||||
// 1. It generates a warning if there is more than one active
|
||||
// thread. This is because it's safe to fork() or clone() only
|
||||
// when there is a single thread.
|
||||
//
|
||||
// 2. The parent process clone()s a sub-process and runs the death
|
||||
// test in it; the sub-process exits with code 0 at the end of the
|
||||
// death test, if it hasn't exited already.
|
||||
//
|
||||
// 3. The parent process waits for the sub-process to terminate.
|
||||
//
|
||||
// 4. The parent process checks the exit code and error message of
|
||||
// the sub-process.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
|
||||
// for (int i = 0; i < 5; i++) {
|
||||
// EXPECT_DEATH(server.ProcessRequest(i),
|
||||
// "Invalid request .* in ProcessRequest()")
|
||||
// << "Failed to die on request " << i);
|
||||
// }
|
||||
//
|
||||
// ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
|
||||
//
|
||||
// bool KilledBySIGHUP(int exit_code) {
|
||||
// return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
|
||||
// }
|
||||
//
|
||||
// ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
|
||||
//
|
||||
// On the regular expressions used in death tests:
|
||||
//
|
||||
// On POSIX-compliant systems (*nix), we use the <regex.h> library,
|
||||
// which uses the POSIX extended regex syntax.
|
||||
//
|
||||
// On other platforms (e.g. Windows), we only support a simple regex
|
||||
// syntax implemented as part of Google Test. This limited
|
||||
// implementation should be enough most of the time when writing
|
||||
// death tests; though it lacks many features you can find in PCRE
|
||||
// or POSIX extended regex syntax. For example, we don't support
|
||||
// union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
|
||||
// repetition count ("x{5,7}"), among others.
|
||||
//
|
||||
// Below is the syntax that we do support. We chose it to be a
|
||||
// subset of both PCRE and POSIX extended regex, so it's easy to
|
||||
// learn wherever you come from. In the following: 'A' denotes a
|
||||
// literal character, period (.), or a single \\ escape sequence;
|
||||
// 'x' and 'y' denote regular expressions; 'm' and 'n' are for
|
||||
// natural numbers.
|
||||
//
|
||||
// c matches any literal character c
|
||||
// \\d matches any decimal digit
|
||||
// \\D matches any character that's not a decimal digit
|
||||
// \\f matches \f
|
||||
// \\n matches \n
|
||||
// \\r matches \r
|
||||
// \\s matches any ASCII whitespace, including \n
|
||||
// \\S matches any character that's not a whitespace
|
||||
// \\t matches \t
|
||||
// \\v matches \v
|
||||
// \\w matches any letter, _, or decimal digit
|
||||
// \\W matches any character that \\w doesn't match
|
||||
// \\c matches any literal character c, which must be a punctuation
|
||||
// . matches any single character except \n
|
||||
// A? matches 0 or 1 occurrences of A
|
||||
// A* matches 0 or many occurrences of A
|
||||
// A+ matches 1 or many occurrences of A
|
||||
// ^ matches the beginning of a string (not that of each line)
|
||||
// $ matches the end of a string (not that of each line)
|
||||
// xy matches x followed by y
|
||||
//
|
||||
// If you accidentally use PCRE or POSIX extended regex features
|
||||
// not implemented by us, you will get a run-time failure. In that
|
||||
// case, please try to rewrite your regular expression within the
|
||||
// above syntax.
|
||||
//
|
||||
// This implementation is *not* meant to be as highly tuned or robust
|
||||
// as a compiled regex library, but should perform well enough for a
|
||||
// death test, which already incurs significant overhead by launching
|
||||
// a child process.
|
||||
//
|
||||
// Known caveats:
|
||||
//
|
||||
// A "threadsafe" style death test obtains the path to the test
|
||||
// program from argv[0] and re-executes it in the sub-process. For
|
||||
// simplicity, the current implementation doesn't search the PATH
|
||||
// when launching the sub-process. This means that the user must
|
||||
// invoke the test program via a path that contains at least one
|
||||
// path separator (e.g. path/to/foo_test and
|
||||
// /absolute/path/to/bar_test are fine, but foo_test is not). This
|
||||
// is rarely a problem as people usually don't put the test binary
|
||||
// directory in PATH.
|
||||
//
|
||||
// TODO(wan@google.com): make thread-safe death tests search the PATH.
|
||||
|
||||
// Asserts that a given statement causes the program to exit, with an
|
||||
// integer exit status that satisfies predicate, and emitting error output
|
||||
// that matches regex.
|
||||
# define ASSERT_EXIT(statement, predicate, regex) \ |
||||
GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_) |
||||
|
||||
// Like ASSERT_EXIT, but continues on to successive tests in the
|
||||
// test case, if any:
|
||||
# define EXPECT_EXIT(statement, predicate, regex) \ |
||||
GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_) |
||||
|
||||
// Asserts that a given statement causes the program to exit, either by
|
||||
// explicitly exiting with a nonzero exit code or being killed by a
|
||||
// signal, and emitting error output that matches regex.
|
||||
# define ASSERT_DEATH(statement, regex) \ |
||||
ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) |
||||
|
||||
// Like ASSERT_DEATH, but continues on to successive tests in the
|
||||
// test case, if any:
|
||||
# define EXPECT_DEATH(statement, regex) \ |
||||
EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) |
||||
|
||||
// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
|
||||
|
||||
// Tests that an exit code describes a normal exit with a given exit code.
|
||||
class GTEST_API_ ExitedWithCode { |
||||
public: |
||||
explicit ExitedWithCode(int exit_code); |
||||
bool operator()(int exit_status) const; |
||||
private: |
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const ExitedWithCode& other); |
||||
|
||||
const int exit_code_; |
||||
}; |
||||
|
||||
# if !GTEST_OS_WINDOWS |
||||
// Tests that an exit code describes an exit due to termination by a
|
||||
// given signal.
|
||||
class GTEST_API_ KilledBySignal { |
||||
public: |
||||
explicit KilledBySignal(int signum); |
||||
bool operator()(int exit_status) const; |
||||
private: |
||||
const int signum_; |
||||
}; |
||||
# endif // !GTEST_OS_WINDOWS
|
||||
|
||||
// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
|
||||
// The death testing framework causes this to have interesting semantics,
|
||||
// since the sideeffects of the call are only visible in opt mode, and not
|
||||
// in debug mode.
|
||||
//
|
||||
// In practice, this can be used to test functions that utilize the
|
||||
// LOG(DFATAL) macro using the following style:
|
||||
//
|
||||
// int DieInDebugOr12(int* sideeffect) {
|
||||
// if (sideeffect) {
|
||||
// *sideeffect = 12;
|
||||
// }
|
||||
// LOG(DFATAL) << "death";
|
||||
// return 12;
|
||||
// }
|
||||
//
|
||||
// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
|
||||
// int sideeffect = 0;
|
||||
// // Only asserts in dbg.
|
||||
// EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
|
||||
//
|
||||
// #ifdef NDEBUG
|
||||
// // opt-mode has sideeffect visible.
|
||||
// EXPECT_EQ(12, sideeffect);
|
||||
// #else
|
||||
// // dbg-mode no visible sideeffect.
|
||||
// EXPECT_EQ(0, sideeffect);
|
||||
// #endif
|
||||
// }
|
||||
//
|
||||
// This will assert that DieInDebugReturn12InOpt() crashes in debug
|
||||
// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
|
||||
// appropriate fallback value (12 in this case) in opt mode. If you
|
||||
// need to test that a function has appropriate side-effects in opt
|
||||
// mode, include assertions against the side-effects. A general
|
||||
// pattern for this is:
|
||||
//
|
||||
// EXPECT_DEBUG_DEATH({
|
||||
// // Side-effects here will have an effect after this statement in
|
||||
// // opt mode, but none in debug mode.
|
||||
// EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
|
||||
// }, "death");
|
||||
//
|
||||
# ifdef NDEBUG |
||||
|
||||
# define EXPECT_DEBUG_DEATH(statement, regex) \ |
||||
do { statement; } while (::testing::internal::AlwaysFalse()) |
||||
|
||||
# define ASSERT_DEBUG_DEATH(statement, regex) \ |
||||
do { statement; } while (::testing::internal::AlwaysFalse()) |
||||
|
||||
# else |
||||
|
||||
# define EXPECT_DEBUG_DEATH(statement, regex) \ |
||||
EXPECT_DEATH(statement, regex) |
||||
|
||||
# define ASSERT_DEBUG_DEATH(statement, regex) \ |
||||
ASSERT_DEATH(statement, regex) |
||||
|
||||
# endif // NDEBUG for EXPECT_DEBUG_DEATH
|
||||
#endif // GTEST_HAS_DEATH_TEST
|
||||
|
||||
// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
|
||||
// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
|
||||
// death tests are supported; otherwise they just issue a warning. This is
|
||||
// useful when you are combining death test assertions with normal test
|
||||
// assertions in one test.
|
||||
#if GTEST_HAS_DEATH_TEST |
||||
# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ |
||||
EXPECT_DEATH(statement, regex) |
||||
# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ |
||||
ASSERT_DEATH(statement, regex) |
||||
#else |
||||
# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ |
||||
GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, ) |
||||
# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ |
||||
GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return) |
||||
#endif |
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
|
@ -0,0 +1,230 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// The Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// This header file defines the Message class.
|
||||
//
|
||||
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
|
||||
// leave some internal implementation details in this header file.
|
||||
// They are clearly marked by comments like this:
|
||||
//
|
||||
// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
|
||||
//
|
||||
// Such code is NOT meant to be used by a user directly, and is subject
|
||||
// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user
|
||||
// program!
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ |
||||
|
||||
#include <limits> |
||||
|
||||
#include "gtest/internal/gtest-string.h" |
||||
#include "gtest/internal/gtest-internal.h" |
||||
|
||||
namespace testing { |
||||
|
||||
// The Message class works like an ostream repeater.
|
||||
//
|
||||
// Typical usage:
|
||||
//
|
||||
// 1. You stream a bunch of values to a Message object.
|
||||
// It will remember the text in a stringstream.
|
||||
// 2. Then you stream the Message object to an ostream.
|
||||
// This causes the text in the Message to be streamed
|
||||
// to the ostream.
|
||||
//
|
||||
// For example;
|
||||
//
|
||||
// testing::Message foo;
|
||||
// foo << 1 << " != " << 2;
|
||||
// std::cout << foo;
|
||||
//
|
||||
// will print "1 != 2".
|
||||
//
|
||||
// Message is not intended to be inherited from. In particular, its
|
||||
// destructor is not virtual.
|
||||
//
|
||||
// Note that stringstream behaves differently in gcc and in MSVC. You
|
||||
// can stream a NULL char pointer to it in the former, but not in the
|
||||
// latter (it causes an access violation if you do). The Message
|
||||
// class hides this difference by treating a NULL char pointer as
|
||||
// "(null)".
|
||||
class GTEST_API_ Message { |
||||
private: |
||||
// The type of basic IO manipulators (endl, ends, and flush) for
|
||||
// narrow streams.
|
||||
typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&); |
||||
|
||||
public: |
||||
// Constructs an empty Message.
|
||||
// We allocate the stringstream separately because otherwise each use of
|
||||
// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
|
||||
// stack frame leading to huge stack frames in some cases; gcc does not reuse
|
||||
// the stack space.
|
||||
Message() : ss_(new ::std::stringstream) { |
||||
// By default, we want there to be enough precision when printing
|
||||
// a double to a Message.
|
||||
*ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2); |
||||
} |
||||
|
||||
// Copy constructor.
|
||||
Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
|
||||
*ss_ << msg.GetString(); |
||||
} |
||||
|
||||
// Constructs a Message from a C-string.
|
||||
explicit Message(const char* str) : ss_(new ::std::stringstream) { |
||||
*ss_ << str; |
||||
} |
||||
|
||||
#if GTEST_OS_SYMBIAN |
||||
// Streams a value (either a pointer or not) to this object.
|
||||
template <typename T> |
||||
inline Message& operator <<(const T& value) { |
||||
StreamHelper(typename internal::is_pointer<T>::type(), value); |
||||
return *this; |
||||
} |
||||
#else |
||||
// Streams a non-pointer value to this object.
|
||||
template <typename T> |
||||
inline Message& operator <<(const T& val) { |
||||
::GTestStreamToHelper(ss_.get(), val); |
||||
return *this; |
||||
} |
||||
|
||||
// Streams a pointer value to this object.
|
||||
//
|
||||
// This function is an overload of the previous one. When you
|
||||
// stream a pointer to a Message, this definition will be used as it
|
||||
// is more specialized. (The C++ Standard, section
|
||||
// [temp.func.order].) If you stream a non-pointer, then the
|
||||
// previous definition will be used.
|
||||
//
|
||||
// The reason for this overload is that streaming a NULL pointer to
|
||||
// ostream is undefined behavior. Depending on the compiler, you
|
||||
// may get "0", "(nil)", "(null)", or an access violation. To
|
||||
// ensure consistent result across compilers, we always treat NULL
|
||||
// as "(null)".
|
||||
template <typename T> |
||||
inline Message& operator <<(T* const& pointer) { // NOLINT
|
||||
if (pointer == NULL) { |
||||
*ss_ << "(null)"; |
||||
} else { |
||||
::GTestStreamToHelper(ss_.get(), pointer); |
||||
} |
||||
return *this; |
||||
} |
||||
#endif // GTEST_OS_SYMBIAN
|
||||
|
||||
// Since the basic IO manipulators are overloaded for both narrow
|
||||
// and wide streams, we have to provide this specialized definition
|
||||
// of operator <<, even though its body is the same as the
|
||||
// templatized version above. Without this definition, streaming
|
||||
// endl or other basic IO manipulators to Message will confuse the
|
||||
// compiler.
|
||||
Message& operator <<(BasicNarrowIoManip val) { |
||||
*ss_ << val; |
||||
return *this; |
||||
} |
||||
|
||||
// Instead of 1/0, we want to see true/false for bool values.
|
||||
Message& operator <<(bool b) { |
||||
return *this << (b ? "true" : "false"); |
||||
} |
||||
|
||||
// These two overloads allow streaming a wide C string to a Message
|
||||
// using the UTF-8 encoding.
|
||||
Message& operator <<(const wchar_t* wide_c_str) { |
||||
return *this << internal::String::ShowWideCString(wide_c_str); |
||||
} |
||||
Message& operator <<(wchar_t* wide_c_str) { |
||||
return *this << internal::String::ShowWideCString(wide_c_str); |
||||
} |
||||
|
||||
#if GTEST_HAS_STD_WSTRING |
||||
// Converts the given wide string to a narrow string using the UTF-8
|
||||
// encoding, and streams the result to this Message object.
|
||||
Message& operator <<(const ::std::wstring& wstr); |
||||
#endif // GTEST_HAS_STD_WSTRING
|
||||
|
||||
#if GTEST_HAS_GLOBAL_WSTRING |
||||
// Converts the given wide string to a narrow string using the UTF-8
|
||||
// encoding, and streams the result to this Message object.
|
||||
Message& operator <<(const ::wstring& wstr); |
||||
#endif // GTEST_HAS_GLOBAL_WSTRING
|
||||
|
||||
// Gets the text streamed to this object so far as a String.
|
||||
// Each '\0' character in the buffer is replaced with "\\0".
|
||||
//
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
|
||||
internal::String GetString() const { |
||||
return internal::StringStreamToString(ss_.get()); |
||||
} |
||||
|
||||
private: |
||||
|
||||
#if GTEST_OS_SYMBIAN |
||||
// These are needed as the Nokia Symbian Compiler cannot decide between
|
||||
// const T& and const T* in a function template. The Nokia compiler _can_
|
||||
// decide between class template specializations for T and T*, so a
|
||||
// tr1::type_traits-like is_pointer works, and we can overload on that.
|
||||
template <typename T> |
||||
inline void StreamHelper(internal::true_type /*dummy*/, T* pointer) { |
||||
if (pointer == NULL) { |
||||
*ss_ << "(null)"; |
||||
} else { |
||||
::GTestStreamToHelper(ss_.get(), pointer); |
||||
} |
||||
} |
||||
template <typename T> |
||||
inline void StreamHelper(internal::false_type /*dummy*/, const T& value) { |
||||
::GTestStreamToHelper(ss_.get(), value); |
||||
} |
||||
#endif // GTEST_OS_SYMBIAN
|
||||
|
||||
// We'll hold the text streamed to this object here.
|
||||
const internal::scoped_ptr< ::std::stringstream> ss_; |
||||
|
||||
// We declare (but don't implement) this to prevent the compiler
|
||||
// from implementing the assignment operator.
|
||||
void operator=(const Message&); |
||||
}; |
||||
|
||||
// Streams a Message to an ostream.
|
||||
inline std::ostream& operator <<(std::ostream& os, const Message& sb) { |
||||
return os << sb.GetString(); |
||||
} |
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,487 @@
|
||||
$$ -*- mode: c++; -*- |
||||
$var n = 50 $$ Maximum length of Values arguments we want to support. |
||||
$var maxtuple = 10 $$ Maximum number of Combine arguments we want to support. |
||||
// Copyright 2008, Google Inc. |
||||
// All rights reserved. |
||||
// |
||||
// Redistribution and use in source and binary forms, with or without |
||||
// modification, are permitted provided that the following conditions are |
||||
// met: |
||||
// |
||||
// * Redistributions of source code must retain the above copyright |
||||
// notice, this list of conditions and the following disclaimer. |
||||
// * Redistributions in binary form must reproduce the above |
||||
// copyright notice, this list of conditions and the following disclaimer |
||||
// in the documentation and/or other materials provided with the |
||||
// distribution. |
||||
// * Neither the name of Google Inc. nor the names of its |
||||
// contributors may be used to endorse or promote products derived from |
||||
// this software without specific prior written permission. |
||||
// |
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
// |
||||
// Authors: vladl@google.com (Vlad Losev) |
||||
// |
||||
// Macros and functions for implementing parameterized tests |
||||
// in Google C++ Testing Framework (Google Test) |
||||
// |
||||
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND! |
||||
// |
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ |
||||
|
||||
|
||||
// Value-parameterized tests allow you to test your code with different |
||||
// parameters without writing multiple copies of the same test. |
||||
// |
||||
// Here is how you use value-parameterized tests: |
||||
|
||||
#if 0 |
||||
|
||||
// To write value-parameterized tests, first you should define a fixture |
||||
// class. It is usually derived from testing::TestWithParam<T> (see below for |
||||
// another inheritance scheme that's sometimes useful in more complicated |
||||
// class hierarchies), where the type of your parameter values. |
||||
// TestWithParam<T> is itself derived from testing::Test. T can be any |
||||
// copyable type. If it's a raw pointer, you are responsible for managing the |
||||
// lifespan of the pointed values. |
||||
|
||||
class FooTest : public ::testing::TestWithParam<const char*> { |
||||
// You can implement all the usual class fixture members here. |
||||
}; |
||||
|
||||
// Then, use the TEST_P macro to define as many parameterized tests |
||||
// for this fixture as you want. The _P suffix is for "parameterized" |
||||
// or "pattern", whichever you prefer to think. |
||||
|
||||
TEST_P(FooTest, DoesBlah) { |
||||
// Inside a test, access the test parameter with the GetParam() method |
||||
// of the TestWithParam<T> class: |
||||
EXPECT_TRUE(foo.Blah(GetParam())); |
||||
... |
||||
} |
||||
|
||||
TEST_P(FooTest, HasBlahBlah) { |
||||
... |
||||
} |
||||
|
||||
// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test |
||||
// case with any set of parameters you want. Google Test defines a number |
||||
// of functions for generating test parameters. They return what we call |
||||
// (surprise!) parameter generators. Here is a summary of them, which |
||||
// are all in the testing namespace: |
||||
// |
||||
// |
||||
// Range(begin, end [, step]) - Yields values {begin, begin+step, |
||||
// begin+step+step, ...}. The values do not |
||||
// include end. step defaults to 1. |
||||
// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}. |
||||
// ValuesIn(container) - Yields values from a C-style array, an STL |
||||
// ValuesIn(begin,end) container, or an iterator range [begin, end). |
||||
// Bool() - Yields sequence {false, true}. |
||||
// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product |
||||
// for the math savvy) of the values generated |
||||
// by the N generators. |
||||
// |
||||
// For more details, see comments at the definitions of these functions below |
||||
// in this file. |
||||
// |
||||
// The following statement will instantiate tests from the FooTest test case |
||||
// each with parameter values "meeny", "miny", and "moe". |
||||
|
||||
INSTANTIATE_TEST_CASE_P(InstantiationName, |
||||
FooTest, |
||||
Values("meeny", "miny", "moe")); |
||||
|
||||
// To distinguish different instances of the pattern, (yes, you |
||||
// can instantiate it more then once) the first argument to the |
||||
// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the |
||||
// actual test case name. Remember to pick unique prefixes for different |
||||
// instantiations. The tests from the instantiation above will have |
||||
// these names: |
||||
// |
||||
// * InstantiationName/FooTest.DoesBlah/0 for "meeny" |
||||
// * InstantiationName/FooTest.DoesBlah/1 for "miny" |
||||
// * InstantiationName/FooTest.DoesBlah/2 for "moe" |
||||
// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny" |
||||
// * InstantiationName/FooTest.HasBlahBlah/1 for "miny" |
||||
// * InstantiationName/FooTest.HasBlahBlah/2 for "moe" |
||||
// |
||||
// You can use these names in --gtest_filter. |
||||
// |
||||
// This statement will instantiate all tests from FooTest again, each |
||||
// with parameter values "cat" and "dog": |
||||
|
||||
const char* pets[] = {"cat", "dog"}; |
||||
INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); |
||||
|
||||
// The tests from the instantiation above will have these names: |
||||
// |
||||
// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat" |
||||
// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog" |
||||
// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat" |
||||
// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog" |
||||
// |
||||
// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests |
||||
// in the given test case, whether their definitions come before or |
||||
// AFTER the INSTANTIATE_TEST_CASE_P statement. |
||||
// |
||||
// Please also note that generator expressions (including parameters to the |
||||
// generators) are evaluated in InitGoogleTest(), after main() has started. |
||||
// This allows the user on one hand, to adjust generator parameters in order |
||||
// to dynamically determine a set of tests to run and on the other hand, |
||||
// give the user a chance to inspect the generated tests with Google Test |
||||
// reflection API before RUN_ALL_TESTS() is executed. |
||||
// |
||||
// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc |
||||
// for more examples. |
||||
// |
||||
// In the future, we plan to publish the API for defining new parameter |
||||
// generators. But for now this interface remains part of the internal |
||||
// implementation and is subject to change. |
||||
// |
||||
// |
||||
// A parameterized test fixture must be derived from testing::Test and from |
||||
// testing::WithParamInterface<T>, where T is the type of the parameter |
||||
// values. Inheriting from TestWithParam<T> satisfies that requirement because |
||||
// TestWithParam<T> inherits from both Test and WithParamInterface. In more |
||||
// complicated hierarchies, however, it is occasionally useful to inherit |
||||
// separately from Test and WithParamInterface. For example: |
||||
|
||||
class BaseTest : public ::testing::Test { |
||||
// You can inherit all the usual members for a non-parameterized test |
||||
// fixture here. |
||||
}; |
||||
|
||||
class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> { |
||||
// The usual test fixture members go here too. |
||||
}; |
||||
|
||||
TEST_F(BaseTest, HasFoo) { |
||||
// This is an ordinary non-parameterized test. |
||||
} |
||||
|
||||
TEST_P(DerivedTest, DoesBlah) { |
||||
// GetParam works just the same here as if you inherit from TestWithParam. |
||||
EXPECT_TRUE(foo.Blah(GetParam())); |
||||
} |
||||
|
||||
#endif // 0 |
||||
|
||||
#include "gtest/internal/gtest-port.h" |
||||
|
||||
#if !GTEST_OS_SYMBIAN |
||||
# include <utility> |
||||
#endif |
||||
|
||||
// scripts/fuse_gtest.py depends on gtest's own header being #included |
||||
// *unconditionally*. Therefore these #includes cannot be moved |
||||
// inside #if GTEST_HAS_PARAM_TEST. |
||||
#include "gtest/internal/gtest-internal.h" |
||||
#include "gtest/internal/gtest-param-util.h" |
||||
#include "gtest/internal/gtest-param-util-generated.h" |
||||
|
||||
#if GTEST_HAS_PARAM_TEST |
||||
|
||||
namespace testing { |
||||
|
||||
// Functions producing parameter generators. |
||||
// |
||||
// Google Test uses these generators to produce parameters for value- |
||||
// parameterized tests. When a parameterized test case is instantiated |
||||
// with a particular generator, Google Test creates and runs tests |
||||
// for each element in the sequence produced by the generator. |
||||
// |
||||
// In the following sample, tests from test case FooTest are instantiated |
||||
// each three times with parameter values 3, 5, and 8: |
||||
// |
||||
// class FooTest : public TestWithParam<int> { ... }; |
||||
// |
||||
// TEST_P(FooTest, TestThis) { |
||||
// } |
||||
// TEST_P(FooTest, TestThat) { |
||||
// } |
||||
// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8)); |
||||
// |
||||
|
||||
// Range() returns generators providing sequences of values in a range. |
||||
// |
||||
// Synopsis: |
||||
// Range(start, end) |
||||
// - returns a generator producing a sequence of values {start, start+1, |
||||
// start+2, ..., }. |
||||
// Range(start, end, step) |
||||
// - returns a generator producing a sequence of values {start, start+step, |
||||
// start+step+step, ..., }. |
||||
// Notes: |
||||
// * The generated sequences never include end. For example, Range(1, 5) |
||||
// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2) |
||||
// returns a generator producing {1, 3, 5, 7}. |
||||
// * start and end must have the same type. That type may be any integral or |
||||
// floating-point type or a user defined type satisfying these conditions: |
||||
// * It must be assignable (have operator=() defined). |
||||
// * It must have operator+() (operator+(int-compatible type) for |
||||
// two-operand version). |
||||
// * It must have operator<() defined. |
||||
// Elements in the resulting sequences will also have that type. |
||||
// * Condition start < end must be satisfied in order for resulting sequences |
||||
// to contain any elements. |
||||
// |
||||
template <typename T, typename IncrementT> |
||||
internal::ParamGenerator<T> Range(T start, T end, IncrementT step) { |
||||
return internal::ParamGenerator<T>( |
||||
new internal::RangeGenerator<T, IncrementT>(start, end, step)); |
||||
} |
||||
|
||||
template <typename T> |
||||
internal::ParamGenerator<T> Range(T start, T end) { |
||||
return Range(start, end, 1); |
||||
} |
||||
|
||||
// ValuesIn() function allows generation of tests with parameters coming from |
||||
// a container. |
||||
// |
||||
// Synopsis: |
||||
// ValuesIn(const T (&array)[N]) |
||||
// - returns a generator producing sequences with elements from |
||||
// a C-style array. |
||||
// ValuesIn(const Container& container) |
||||
// - returns a generator producing sequences with elements from |
||||
// an STL-style container. |
||||
// ValuesIn(Iterator begin, Iterator end) |
||||
// - returns a generator producing sequences with elements from |
||||
// a range [begin, end) defined by a pair of STL-style iterators. These |
||||
// iterators can also be plain C pointers. |
||||
// |
||||
// Please note that ValuesIn copies the values from the containers |
||||
// passed in and keeps them to generate tests in RUN_ALL_TESTS(). |
||||
// |
||||
// Examples: |
||||
// |
||||
// This instantiates tests from test case StringTest |
||||
// each with C-string values of "foo", "bar", and "baz": |
||||
// |
||||
// const char* strings[] = {"foo", "bar", "baz"}; |
||||
// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings)); |
||||
// |
||||
// This instantiates tests from test case StlStringTest |
||||
// each with STL strings with values "a" and "b": |
||||
// |
||||
// ::std::vector< ::std::string> GetParameterStrings() { |
||||
// ::std::vector< ::std::string> v; |
||||
// v.push_back("a"); |
||||
// v.push_back("b"); |
||||
// return v; |
||||
// } |
||||
// |
||||
// INSTANTIATE_TEST_CASE_P(CharSequence, |
||||
// StlStringTest, |
||||
// ValuesIn(GetParameterStrings())); |
||||
// |
||||
// |
||||
// This will also instantiate tests from CharTest |
||||
// each with parameter values 'a' and 'b': |
||||
// |
||||
// ::std::list<char> GetParameterChars() { |
||||
// ::std::list<char> list; |
||||
// list.push_back('a'); |
||||
// list.push_back('b'); |
||||
// return list; |
||||
// } |
||||
// ::std::list<char> l = GetParameterChars(); |
||||
// INSTANTIATE_TEST_CASE_P(CharSequence2, |
||||
// CharTest, |
||||
// ValuesIn(l.begin(), l.end())); |
||||
// |
||||
template <typename ForwardIterator> |
||||
internal::ParamGenerator< |
||||
typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type> |
||||
ValuesIn(ForwardIterator begin, ForwardIterator end) { |
||||
typedef typename ::testing::internal::IteratorTraits<ForwardIterator> |
||||
::value_type ParamType; |
||||
return internal::ParamGenerator<ParamType>( |
||||
new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end)); |
||||
} |
||||
|
||||
template <typename T, size_t N> |
||||
internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) { |
||||
return ValuesIn(array, array + N); |
||||
} |
||||
|
||||
template <class Container> |
||||
internal::ParamGenerator<typename Container::value_type> ValuesIn( |
||||
const Container& container) { |
||||
return ValuesIn(container.begin(), container.end()); |
||||
} |
||||
|
||||
// Values() allows generating tests from explicitly specified list of |
||||
// parameters. |
||||
// |
||||
// Synopsis: |
||||
// Values(T v1, T v2, ..., T vN) |
||||
// - returns a generator producing sequences with elements v1, v2, ..., vN. |
||||
// |
||||
// For example, this instantiates tests from test case BarTest each |
||||
// with values "one", "two", and "three": |
||||
// |
||||
// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three")); |
||||
// |
||||
// This instantiates tests from test case BazTest each with values 1, 2, 3.5. |
||||
// The exact type of values will depend on the type of parameter in BazTest. |
||||
// |
||||
// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); |
||||
// |
||||
// Currently, Values() supports from 1 to $n parameters. |
||||
// |
||||
$range i 1..n |
||||
$for i [[ |
||||
$range j 1..i |
||||
|
||||
template <$for j, [[typename T$j]]> |
||||
internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) { |
||||
return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]); |
||||
} |
||||
|
||||
]] |
||||
|
||||
// Bool() allows generating tests with parameters in a set of (false, true). |
||||
// |
||||
// Synopsis: |
||||
// Bool() |
||||
// - returns a generator producing sequences with elements {false, true}. |
||||
// |
||||
// It is useful when testing code that depends on Boolean flags. Combinations |
||||
// of multiple flags can be tested when several Bool()'s are combined using |
||||
// Combine() function. |
||||
// |
||||
// In the following example all tests in the test case FlagDependentTest |
||||
// will be instantiated twice with parameters false and true. |
||||
// |
||||
// class FlagDependentTest : public testing::TestWithParam<bool> { |
||||
// virtual void SetUp() { |
||||
// external_flag = GetParam(); |
||||
// } |
||||
// } |
||||
// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool()); |
||||
// |
||||
inline internal::ParamGenerator<bool> Bool() { |
||||
return Values(false, true); |
||||
} |
||||
|
||||
# if GTEST_HAS_COMBINE |
||||
// Combine() allows the user to combine two or more sequences to produce |
||||
// values of a Cartesian product of those sequences' elements. |
||||
// |
||||
// Synopsis: |
||||
// Combine(gen1, gen2, ..., genN) |
||||
// - returns a generator producing sequences with elements coming from |
||||
// the Cartesian product of elements from the sequences generated by |
||||
// gen1, gen2, ..., genN. The sequence elements will have a type of |
||||
// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types |
||||
// of elements from sequences produces by gen1, gen2, ..., genN. |
||||
// |
||||
// Combine can have up to $maxtuple arguments. This number is currently limited |
||||
// by the maximum number of elements in the tuple implementation used by Google |
||||
// Test. |
||||
// |
||||
// Example: |
||||
// |
||||
// This will instantiate tests in test case AnimalTest each one with |
||||
// the parameter values tuple("cat", BLACK), tuple("cat", WHITE), |
||||
// tuple("dog", BLACK), and tuple("dog", WHITE): |
||||
// |
||||
// enum Color { BLACK, GRAY, WHITE }; |
||||
// class AnimalTest |
||||
// : public testing::TestWithParam<tuple<const char*, Color> > {...}; |
||||
// |
||||
// TEST_P(AnimalTest, AnimalLooksNice) {...} |
||||
// |
||||
// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest, |
||||
// Combine(Values("cat", "dog"), |
||||
// Values(BLACK, WHITE))); |
||||
// |
||||
// This will instantiate tests in FlagDependentTest with all variations of two |
||||
// Boolean flags: |
||||
// |
||||
// class FlagDependentTest |
||||
// : public testing::TestWithParam<tuple(bool, bool)> > { |
||||
// virtual void SetUp() { |
||||
// // Assigns external_flag_1 and external_flag_2 values from the tuple. |
||||
// tie(external_flag_1, external_flag_2) = GetParam(); |
||||
// } |
||||
// }; |
||||
// |
||||
// TEST_P(FlagDependentTest, TestFeature1) { |
||||
// // Test your code using external_flag_1 and external_flag_2 here. |
||||
// } |
||||
// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest, |
||||
// Combine(Bool(), Bool())); |
||||
// |
||||
$range i 2..maxtuple |
||||
$for i [[ |
||||
$range j 1..i |
||||
|
||||
template <$for j, [[typename Generator$j]]> |
||||
internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine( |
||||
$for j, [[const Generator$j& g$j]]) { |
||||
return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>( |
||||
$for j, [[g$j]]); |
||||
} |
||||
|
||||
]] |
||||
# endif // GTEST_HAS_COMBINE |
||||
|
||||
|
||||
|
||||
# define TEST_P(test_case_name, test_name) \ |
||||
class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ |
||||
: public test_case_name { \ |
||||
public: \ |
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \ |
||||
virtual void TestBody(); \ |
||||
private: \ |
||||
static int AddToRegistry() { \ |
||||
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ |
||||
GetTestCasePatternHolder<test_case_name>(\ |
||||
#test_case_name, __FILE__, __LINE__)->AddTestPattern(\ |
||||
#test_case_name, \ |
||||
#test_name, \ |
||||
new ::testing::internal::TestMetaFactory< \ |
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \ |
||||
return 0; \ |
||||
} \ |
||||
static int gtest_registering_dummy_; \ |
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(\ |
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \ |
||||
}; \ |
||||
int GTEST_TEST_CLASS_NAME_(test_case_name, \ |
||||
test_name)::gtest_registering_dummy_ = \ |
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \ |
||||
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() |
||||
|
||||
# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \ |
||||
::testing::internal::ParamGenerator<test_case_name::ParamType> \ |
||||
gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \ |
||||
int gtest_##prefix##test_case_name##_dummy_ = \ |
||||
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ |
||||
GetTestCasePatternHolder<test_case_name>(\ |
||||
#test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\ |
||||
#prefix, \ |
||||
>est_##prefix##test_case_name##_EvalGenerator_, \ |
||||
__FILE__, __LINE__) |
||||
|
||||
} // namespace testing |
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST |
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ |
@ -0,0 +1,796 @@
|
||||
// Copyright 2007, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Google Test - The Google C++ Testing Framework
|
||||
//
|
||||
// This file implements a universal value printer that can print a
|
||||
// value of any type T:
|
||||
//
|
||||
// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
|
||||
//
|
||||
// A user can teach this function how to print a class type T by
|
||||
// defining either operator<<() or PrintTo() in the namespace that
|
||||
// defines T. More specifically, the FIRST defined function in the
|
||||
// following list will be used (assuming T is defined in namespace
|
||||
// foo):
|
||||
//
|
||||
// 1. foo::PrintTo(const T&, ostream*)
|
||||
// 2. operator<<(ostream&, const T&) defined in either foo or the
|
||||
// global namespace.
|
||||
//
|
||||
// If none of the above is defined, it will print the debug string of
|
||||
// the value if it is a protocol buffer, or print the raw bytes in the
|
||||
// value otherwise.
|
||||
//
|
||||
// To aid debugging: when T is a reference type, the address of the
|
||||
// value is also printed; when T is a (const) char pointer, both the
|
||||
// pointer value and the NUL-terminated string it points to are
|
||||
// printed.
|
||||
//
|
||||
// We also provide some convenient wrappers:
|
||||
//
|
||||
// // Prints a value to a string. For a (const or not) char
|
||||
// // pointer, the NUL-terminated string (but not the pointer) is
|
||||
// // printed.
|
||||
// std::string ::testing::PrintToString(const T& value);
|
||||
//
|
||||
// // Prints a value tersely: for a reference type, the referenced
|
||||
// // value (but not the address) is printed; for a (const or not) char
|
||||
// // pointer, the NUL-terminated string (but not the pointer) is
|
||||
// // printed.
|
||||
// void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
|
||||
//
|
||||
// // Prints value using the type inferred by the compiler. The difference
|
||||
// // from UniversalTersePrint() is that this function prints both the
|
||||
// // pointer and the NUL-terminated string for a (const or not) char pointer.
|
||||
// void ::testing::internal::UniversalPrint(const T& value, ostream*);
|
||||
//
|
||||
// // Prints the fields of a tuple tersely to a string vector, one
|
||||
// // element for each field. Tuple support must be enabled in
|
||||
// // gtest-port.h.
|
||||
// std::vector<string> UniversalTersePrintTupleFieldsToStrings(
|
||||
// const Tuple& value);
|
||||
//
|
||||
// Known limitation:
|
||||
//
|
||||
// The print primitives print the elements of an STL-style container
|
||||
// using the compiler-inferred type of *iter where iter is a
|
||||
// const_iterator of the container. When const_iterator is an input
|
||||
// iterator but not a forward iterator, this inferred type may not
|
||||
// match value_type, and the print output may be incorrect. In
|
||||
// practice, this is rarely a problem as for most containers
|
||||
// const_iterator is a forward iterator. We'll fix this if there's an
|
||||
// actual need for it. Note that this fix cannot rely on value_type
|
||||
// being defined as many user-defined container types don't have
|
||||
// value_type.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ |
||||
|
||||
#include <ostream> // NOLINT |
||||
#include <sstream> |
||||
#include <string> |
||||
#include <utility> |
||||
#include <vector> |
||||
#include "gtest/internal/gtest-port.h" |
||||
#include "gtest/internal/gtest-internal.h" |
||||
|
||||
namespace testing { |
||||
|
||||
// Definitions in the 'internal' and 'internal2' name spaces are
|
||||
// subject to change without notice. DO NOT USE THEM IN USER CODE!
|
||||
namespace internal2 { |
||||
|
||||
// Prints the given number of bytes in the given object to the given
|
||||
// ostream.
|
||||
GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, |
||||
size_t count, |
||||
::std::ostream* os); |
||||
|
||||
// For selecting which printer to use when a given type has neither <<
|
||||
// nor PrintTo().
|
||||
enum TypeKind { |
||||
kProtobuf, // a protobuf type
|
||||
kConvertibleToInteger, // a type implicitly convertible to BiggestInt
|
||||
// (e.g. a named or unnamed enum type)
|
||||
kOtherType // anything else
|
||||
}; |
||||
|
||||
// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
|
||||
// by the universal printer to print a value of type T when neither
|
||||
// operator<< nor PrintTo() is defined for T, where kTypeKind is the
|
||||
// "kind" of T as defined by enum TypeKind.
|
||||
template <typename T, TypeKind kTypeKind> |
||||
class TypeWithoutFormatter { |
||||
public: |
||||
// This default version is called when kTypeKind is kOtherType.
|
||||
static void PrintValue(const T& value, ::std::ostream* os) { |
||||
PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value), |
||||
sizeof(value), os); |
||||
} |
||||
}; |
||||
|
||||
// We print a protobuf using its ShortDebugString() when the string
|
||||
// doesn't exceed this many characters; otherwise we print it using
|
||||
// DebugString() for better readability.
|
||||
const size_t kProtobufOneLinerMaxLength = 50; |
||||
|
||||
template <typename T> |
||||
class TypeWithoutFormatter<T, kProtobuf> { |
||||
public: |
||||
static void PrintValue(const T& value, ::std::ostream* os) { |
||||
const ::testing::internal::string short_str = value.ShortDebugString(); |
||||
const ::testing::internal::string pretty_str = |
||||
short_str.length() <= kProtobufOneLinerMaxLength ? |
||||
short_str : ("\n" + value.DebugString()); |
||||
*os << ("<" + pretty_str + ">"); |
||||
} |
||||
}; |
||||
|
||||
template <typename T> |
||||
class TypeWithoutFormatter<T, kConvertibleToInteger> { |
||||
public: |
||||
// Since T has no << operator or PrintTo() but can be implicitly
|
||||
// converted to BiggestInt, we print it as a BiggestInt.
|
||||
//
|
||||
// Most likely T is an enum type (either named or unnamed), in which
|
||||
// case printing it as an integer is the desired behavior. In case
|
||||
// T is not an enum, printing it as an integer is the best we can do
|
||||
// given that it has no user-defined printer.
|
||||
static void PrintValue(const T& value, ::std::ostream* os) { |
||||
const internal::BiggestInt kBigInt = value; |
||||
*os << kBigInt; |
||||
} |
||||
}; |
||||
|
||||
// Prints the given value to the given ostream. If the value is a
|
||||
// protocol message, its debug string is printed; if it's an enum or
|
||||
// of a type implicitly convertible to BiggestInt, it's printed as an
|
||||
// integer; otherwise the bytes in the value are printed. This is
|
||||
// what UniversalPrinter<T>::Print() does when it knows nothing about
|
||||
// type T and T has neither << operator nor PrintTo().
|
||||
//
|
||||
// A user can override this behavior for a class type Foo by defining
|
||||
// a << operator in the namespace where Foo is defined.
|
||||
//
|
||||
// We put this operator in namespace 'internal2' instead of 'internal'
|
||||
// to simplify the implementation, as much code in 'internal' needs to
|
||||
// use << in STL, which would conflict with our own << were it defined
|
||||
// in 'internal'.
|
||||
//
|
||||
// Note that this operator<< takes a generic std::basic_ostream<Char,
|
||||
// CharTraits> type instead of the more restricted std::ostream. If
|
||||
// we define it to take an std::ostream instead, we'll get an
|
||||
// "ambiguous overloads" compiler error when trying to print a type
|
||||
// Foo that supports streaming to std::basic_ostream<Char,
|
||||
// CharTraits>, as the compiler cannot tell whether
|
||||
// operator<<(std::ostream&, const T&) or
|
||||
// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
|
||||
// specific.
|
||||
template <typename Char, typename CharTraits, typename T> |
||||
::std::basic_ostream<Char, CharTraits>& operator<<( |
||||
::std::basic_ostream<Char, CharTraits>& os, const T& x) { |
||||
TypeWithoutFormatter<T, |
||||
(internal::IsAProtocolMessage<T>::value ? kProtobuf : |
||||
internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ? |
||||
kConvertibleToInteger : kOtherType)>::PrintValue(x, &os); |
||||
return os; |
||||
} |
||||
|
||||
} // namespace internal2
|
||||
} // namespace testing
|
||||
|
||||
// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
|
||||
// magic needed for implementing UniversalPrinter won't work.
|
||||
namespace testing_internal { |
||||
|
||||
// Used to print a value that is not an STL-style container when the
|
||||
// user doesn't define PrintTo() for it.
|
||||
template <typename T> |
||||
void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) { |
||||
// With the following statement, during unqualified name lookup,
|
||||
// testing::internal2::operator<< appears as if it was declared in
|
||||
// the nearest enclosing namespace that contains both
|
||||
// ::testing_internal and ::testing::internal2, i.e. the global
|
||||
// namespace. For more details, refer to the C++ Standard section
|
||||
// 7.3.4-1 [namespace.udir]. This allows us to fall back onto
|
||||
// testing::internal2::operator<< in case T doesn't come with a <<
|
||||
// operator.
|
||||
//
|
||||
// We cannot write 'using ::testing::internal2::operator<<;', which
|
||||
// gcc 3.3 fails to compile due to a compiler bug.
|
||||
using namespace ::testing::internal2; // NOLINT
|
||||
|
||||
// Assuming T is defined in namespace foo, in the next statement,
|
||||
// the compiler will consider all of:
|
||||
//
|
||||
// 1. foo::operator<< (thanks to Koenig look-up),
|
||||
// 2. ::operator<< (as the current namespace is enclosed in ::),
|
||||
// 3. testing::internal2::operator<< (thanks to the using statement above).
|
||||
//
|
||||
// The operator<< whose type matches T best will be picked.
|
||||
//
|
||||
// We deliberately allow #2 to be a candidate, as sometimes it's
|
||||
// impossible to define #1 (e.g. when foo is ::std, defining
|
||||
// anything in it is undefined behavior unless you are a compiler
|
||||
// vendor.).
|
||||
*os << value; |
||||
} |
||||
|
||||
} // namespace testing_internal
|
||||
|
||||
namespace testing { |
||||
namespace internal { |
||||
|
||||
// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
|
||||
// value to the given ostream. The caller must ensure that
|
||||
// 'ostream_ptr' is not NULL, or the behavior is undefined.
|
||||
//
|
||||
// We define UniversalPrinter as a class template (as opposed to a
|
||||
// function template), as we need to partially specialize it for
|
||||
// reference types, which cannot be done with function templates.
|
||||
template <typename T> |
||||
class UniversalPrinter; |
||||
|
||||
template <typename T> |
||||
void UniversalPrint(const T& value, ::std::ostream* os); |
||||
|
||||
// Used to print an STL-style container when the user doesn't define
|
||||
// a PrintTo() for it.
|
||||
template <typename C> |
||||
void DefaultPrintTo(IsContainer /* dummy */, |
||||
false_type /* is not a pointer */, |
||||
const C& container, ::std::ostream* os) { |
||||
const size_t kMaxCount = 32; // The maximum number of elements to print.
|
||||
*os << '{'; |
||||
size_t count = 0; |
||||
for (typename C::const_iterator it = container.begin(); |
||||
it != container.end(); ++it, ++count) { |
||||
if (count > 0) { |
||||
*os << ','; |
||||
if (count == kMaxCount) { // Enough has been printed.
|
||||
*os << " ..."; |
||||
break; |
||||
} |
||||
} |
||||
*os << ' '; |
||||
// We cannot call PrintTo(*it, os) here as PrintTo() doesn't
|
||||
// handle *it being a native array.
|
||||
internal::UniversalPrint(*it, os); |
||||
} |
||||
|
||||
if (count > 0) { |
||||
*os << ' '; |
||||
} |
||||
*os << '}'; |
||||
} |
||||
|
||||
// Used to print a pointer that is neither a char pointer nor a member
|
||||
// pointer, when the user doesn't define PrintTo() for it. (A member
|
||||
// variable pointer or member function pointer doesn't really point to
|
||||
// a location in the address space. Their representation is
|
||||
// implementation-defined. Therefore they will be printed as raw
|
||||
// bytes.)
|
||||
template <typename T> |
||||
void DefaultPrintTo(IsNotContainer /* dummy */, |
||||
true_type /* is a pointer */, |
||||
T* p, ::std::ostream* os) { |
||||
if (p == NULL) { |
||||
*os << "NULL"; |
||||
} else { |
||||
// C++ doesn't allow casting from a function pointer to any object
|
||||
// pointer.
|
||||
//
|
||||
// IsTrue() silences warnings: "Condition is always true",
|
||||
// "unreachable code".
|
||||
if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) { |
||||
// T is not a function type. We just call << to print p,
|
||||
// relying on ADL to pick up user-defined << for their pointer
|
||||
// types, if any.
|
||||
*os << p; |
||||
} else { |
||||
// T is a function type, so '*os << p' doesn't do what we want
|
||||
// (it just prints p as bool). We want to print p as a const
|
||||
// void*. However, we cannot cast it to const void* directly,
|
||||
// even using reinterpret_cast, as earlier versions of gcc
|
||||
// (e.g. 3.4.5) cannot compile the cast when p is a function
|
||||
// pointer. Casting to UInt64 first solves the problem.
|
||||
*os << reinterpret_cast<const void*>( |
||||
reinterpret_cast<internal::UInt64>(p)); |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Used to print a non-container, non-pointer value when the user
|
||||
// doesn't define PrintTo() for it.
|
||||
template <typename T> |
||||
void DefaultPrintTo(IsNotContainer /* dummy */, |
||||
false_type /* is not a pointer */, |
||||
const T& value, ::std::ostream* os) { |
||||
::testing_internal::DefaultPrintNonContainerTo(value, os); |
||||
} |
||||
|
||||
// Prints the given value using the << operator if it has one;
|
||||
// otherwise prints the bytes in it. This is what
|
||||
// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
|
||||
// or overloaded for type T.
|
||||
//
|
||||
// A user can override this behavior for a class type Foo by defining
|
||||
// an overload of PrintTo() in the namespace where Foo is defined. We
|
||||
// give the user this option as sometimes defining a << operator for
|
||||
// Foo is not desirable (e.g. the coding style may prevent doing it,
|
||||
// or there is already a << operator but it doesn't do what the user
|
||||
// wants).
|
||||
template <typename T> |
||||
void PrintTo(const T& value, ::std::ostream* os) { |
||||
// DefaultPrintTo() is overloaded. The type of its first two
|
||||
// arguments determine which version will be picked. If T is an
|
||||
// STL-style container, the version for container will be called; if
|
||||
// T is a pointer, the pointer version will be called; otherwise the
|
||||
// generic version will be called.
|
||||
//
|
||||
// Note that we check for container types here, prior to we check
|
||||
// for protocol message types in our operator<<. The rationale is:
|
||||
//
|
||||
// For protocol messages, we want to give people a chance to
|
||||
// override Google Mock's format by defining a PrintTo() or
|
||||
// operator<<. For STL containers, other formats can be
|
||||
// incompatible with Google Mock's format for the container
|
||||
// elements; therefore we check for container types here to ensure
|
||||
// that our format is used.
|
||||
//
|
||||
// The second argument of DefaultPrintTo() is needed to bypass a bug
|
||||
// in Symbian's C++ compiler that prevents it from picking the right
|
||||
// overload between:
|
||||
//
|
||||
// PrintTo(const T& x, ...);
|
||||
// PrintTo(T* x, ...);
|
||||
DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os); |
||||
} |
||||
|
||||
// The following list of PrintTo() overloads tells
|
||||
// UniversalPrinter<T>::Print() how to print standard types (built-in
|
||||
// types, strings, plain arrays, and pointers).
|
||||
|
||||
// Overloads for various char types.
|
||||
GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os); |
||||
GTEST_API_ void PrintTo(signed char c, ::std::ostream* os); |
||||
inline void PrintTo(char c, ::std::ostream* os) { |
||||
// When printing a plain char, we always treat it as unsigned. This
|
||||
// way, the output won't be affected by whether the compiler thinks
|
||||
// char is signed or not.
|
||||
PrintTo(static_cast<unsigned char>(c), os); |
||||
} |
||||
|
||||
// Overloads for other simple built-in types.
|
||||
inline void PrintTo(bool x, ::std::ostream* os) { |
||||
*os << (x ? "true" : "false"); |
||||
} |
||||
|
||||
// Overload for wchar_t type.
|
||||
// Prints a wchar_t as a symbol if it is printable or as its internal
|
||||
// code otherwise and also as its decimal code (except for L'\0').
|
||||
// The L'\0' char is printed as "L'\\0'". The decimal code is printed
|
||||
// as signed integer when wchar_t is implemented by the compiler
|
||||
// as a signed type and is printed as an unsigned integer when wchar_t
|
||||
// is implemented as an unsigned type.
|
||||
GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os); |
||||
|
||||
// Overloads for C strings.
|
||||
GTEST_API_ void PrintTo(const char* s, ::std::ostream* os); |
||||
inline void PrintTo(char* s, ::std::ostream* os) { |
||||
PrintTo(ImplicitCast_<const char*>(s), os); |
||||
} |
||||
|
||||
// signed/unsigned char is often used for representing binary data, so
|
||||
// we print pointers to it as void* to be safe.
|
||||
inline void PrintTo(const signed char* s, ::std::ostream* os) { |
||||
PrintTo(ImplicitCast_<const void*>(s), os); |
||||
} |
||||
inline void PrintTo(signed char* s, ::std::ostream* os) { |
||||
PrintTo(ImplicitCast_<const void*>(s), os); |
||||
} |
||||
inline void PrintTo(const unsigned char* s, ::std::ostream* os) { |
||||
PrintTo(ImplicitCast_<const void*>(s), os); |
||||
} |
||||
inline void PrintTo(unsigned char* s, ::std::ostream* os) { |
||||
PrintTo(ImplicitCast_<const void*>(s), os); |
||||
} |
||||
|
||||
// MSVC can be configured to define wchar_t as a typedef of unsigned
|
||||
// short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
|
||||
// type. When wchar_t is a typedef, defining an overload for const
|
||||
// wchar_t* would cause unsigned short* be printed as a wide string,
|
||||
// possibly causing invalid memory accesses.
|
||||
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) |
||||
// Overloads for wide C strings
|
||||
GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os); |
||||
inline void PrintTo(wchar_t* s, ::std::ostream* os) { |
||||
PrintTo(ImplicitCast_<const wchar_t*>(s), os); |
||||
} |
||||
#endif |
||||
|
||||
// Overload for C arrays. Multi-dimensional arrays are printed
|
||||
// properly.
|
||||
|
||||
// Prints the given number of elements in an array, without printing
|
||||
// the curly braces.
|
||||
template <typename T> |
||||
void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) { |
||||
UniversalPrint(a[0], os); |
||||
for (size_t i = 1; i != count; i++) { |
||||
*os << ", "; |
||||
UniversalPrint(a[i], os); |
||||
} |
||||
} |
||||
|
||||
// Overloads for ::string and ::std::string.
|
||||
#if GTEST_HAS_GLOBAL_STRING |
||||
GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os); |
||||
inline void PrintTo(const ::string& s, ::std::ostream* os) { |
||||
PrintStringTo(s, os); |
||||
} |
||||
#endif // GTEST_HAS_GLOBAL_STRING
|
||||
|
||||
GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os); |
||||
inline void PrintTo(const ::std::string& s, ::std::ostream* os) { |
||||
PrintStringTo(s, os); |
||||
} |
||||
|
||||
// Overloads for ::wstring and ::std::wstring.
|
||||
#if GTEST_HAS_GLOBAL_WSTRING |
||||
GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os); |
||||
inline void PrintTo(const ::wstring& s, ::std::ostream* os) { |
||||
PrintWideStringTo(s, os); |
||||
} |
||||
#endif // GTEST_HAS_GLOBAL_WSTRING
|
||||
|
||||
#if GTEST_HAS_STD_WSTRING |
||||
GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os); |
||||
inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) { |
||||
PrintWideStringTo(s, os); |
||||
} |
||||
#endif // GTEST_HAS_STD_WSTRING
|
||||
|
||||
#if GTEST_HAS_TR1_TUPLE |
||||
// Overload for ::std::tr1::tuple. Needed for printing function arguments,
|
||||
// which are packed as tuples.
|
||||
|
||||
// Helper function for printing a tuple. T must be instantiated with
|
||||
// a tuple type.
|
||||
template <typename T> |
||||
void PrintTupleTo(const T& t, ::std::ostream* os); |
||||
|
||||
// Overloaded PrintTo() for tuples of various arities. We support
|
||||
// tuples of up-to 10 fields. The following implementation works
|
||||
// regardless of whether tr1::tuple is implemented using the
|
||||
// non-standard variadic template feature or not.
|
||||
|
||||
inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1> |
||||
void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2> |
||||
void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2, typename T3> |
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4> |
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5> |
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t, |
||||
::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, |
||||
typename T6> |
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t, |
||||
::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, |
||||
typename T6, typename T7> |
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t, |
||||
::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, |
||||
typename T6, typename T7, typename T8> |
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t, |
||||
::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, |
||||
typename T6, typename T7, typename T8, typename T9> |
||||
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t, |
||||
::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
|
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, |
||||
typename T6, typename T7, typename T8, typename T9, typename T10> |
||||
void PrintTo( |
||||
const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t, |
||||
::std::ostream* os) { |
||||
PrintTupleTo(t, os); |
||||
} |
||||
#endif // GTEST_HAS_TR1_TUPLE
|
||||
|
||||
// Overload for std::pair.
|
||||
template <typename T1, typename T2> |
||||
void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) { |
||||
*os << '('; |
||||
// We cannot use UniversalPrint(value.first, os) here, as T1 may be
|
||||
// a reference type. The same for printing value.second.
|
||||
UniversalPrinter<T1>::Print(value.first, os); |
||||
*os << ", "; |
||||
UniversalPrinter<T2>::Print(value.second, os); |
||||
*os << ')'; |
||||
} |
||||
|
||||
// Implements printing a non-reference type T by letting the compiler
|
||||
// pick the right overload of PrintTo() for T.
|
||||
template <typename T> |
||||
class UniversalPrinter { |
||||
public: |
||||
// MSVC warns about adding const to a function type, so we want to
|
||||
// disable the warning.
|
||||
#ifdef _MSC_VER |
||||
# pragma warning(push) // Saves the current warning state.
|
||||
# pragma warning(disable:4180) // Temporarily disables warning 4180.
|
||||
#endif // _MSC_VER
|
||||
|
||||
// Note: we deliberately don't call this PrintTo(), as that name
|
||||
// conflicts with ::testing::internal::PrintTo in the body of the
|
||||
// function.
|
||||
static void Print(const T& value, ::std::ostream* os) { |
||||
// By default, ::testing::internal::PrintTo() is used for printing
|
||||
// the value.
|
||||
//
|
||||
// Thanks to Koenig look-up, if T is a class and has its own
|
||||
// PrintTo() function defined in its namespace, that function will
|
||||
// be visible here. Since it is more specific than the generic ones
|
||||
// in ::testing::internal, it will be picked by the compiler in the
|
||||
// following statement - exactly what we want.
|
||||
PrintTo(value, os); |
||||
} |
||||
|
||||
#ifdef _MSC_VER |
||||
# pragma warning(pop) // Restores the warning state.
|
||||
#endif // _MSC_VER
|
||||
}; |
||||
|
||||
// UniversalPrintArray(begin, len, os) prints an array of 'len'
|
||||
// elements, starting at address 'begin'.
|
||||
template <typename T> |
||||
void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) { |
||||
if (len == 0) { |
||||
*os << "{}"; |
||||
} else { |
||||
*os << "{ "; |
||||
const size_t kThreshold = 18; |
||||
const size_t kChunkSize = 8; |
||||
// If the array has more than kThreshold elements, we'll have to
|
||||
// omit some details by printing only the first and the last
|
||||
// kChunkSize elements.
|
||||
// TODO(wan@google.com): let the user control the threshold using a flag.
|
||||
if (len <= kThreshold) { |
||||
PrintRawArrayTo(begin, len, os); |
||||
} else { |
||||
PrintRawArrayTo(begin, kChunkSize, os); |
||||
*os << ", ..., "; |
||||
PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os); |
||||
} |
||||
*os << " }"; |
||||
} |
||||
} |
||||
// This overload prints a (const) char array compactly.
|
||||
GTEST_API_ void UniversalPrintArray(const char* begin, |
||||
size_t len, |
||||
::std::ostream* os); |
||||
|
||||
// Implements printing an array type T[N].
|
||||
template <typename T, size_t N> |
||||
class UniversalPrinter<T[N]> { |
||||
public: |
||||
// Prints the given array, omitting some elements when there are too
|
||||
// many.
|
||||
static void Print(const T (&a)[N], ::std::ostream* os) { |
||||
UniversalPrintArray(a, N, os); |
||||
} |
||||
}; |
||||
|
||||
// Implements printing a reference type T&.
|
||||
template <typename T> |
||||
class UniversalPrinter<T&> { |
||||
public: |
||||
// MSVC warns about adding const to a function type, so we want to
|
||||
// disable the warning.
|
||||
#ifdef _MSC_VER |
||||
# pragma warning(push) // Saves the current warning state.
|
||||
# pragma warning(disable:4180) // Temporarily disables warning 4180.
|
||||
#endif // _MSC_VER
|
||||
|
||||
static void Print(const T& value, ::std::ostream* os) { |
||||
// Prints the address of the value. We use reinterpret_cast here
|
||||
// as static_cast doesn't compile when T is a function type.
|
||||
*os << "@" << reinterpret_cast<const void*>(&value) << " "; |
||||
|
||||
// Then prints the value itself.
|
||||
UniversalPrint(value, os); |
||||
} |
||||
|
||||
#ifdef _MSC_VER |
||||
# pragma warning(pop) // Restores the warning state.
|
||||
#endif // _MSC_VER
|
||||
}; |
||||
|
||||
// Prints a value tersely: for a reference type, the referenced value
|
||||
// (but not the address) is printed; for a (const) char pointer, the
|
||||
// NUL-terminated string (but not the pointer) is printed.
|
||||
template <typename T> |
||||
void UniversalTersePrint(const T& value, ::std::ostream* os) { |
||||
UniversalPrint(value, os); |
||||
} |
||||
inline void UniversalTersePrint(const char* str, ::std::ostream* os) { |
||||
if (str == NULL) { |
||||
*os << "NULL"; |
||||
} else { |
||||
UniversalPrint(string(str), os); |
||||
} |
||||
} |
||||
inline void UniversalTersePrint(char* str, ::std::ostream* os) { |
||||
UniversalTersePrint(static_cast<const char*>(str), os); |
||||
} |
||||
|
||||
// Prints a value using the type inferred by the compiler. The
|
||||
// difference between this and UniversalTersePrint() is that for a
|
||||
// (const) char pointer, this prints both the pointer and the
|
||||
// NUL-terminated string.
|
||||
template <typename T> |
||||
void UniversalPrint(const T& value, ::std::ostream* os) { |
||||
UniversalPrinter<T>::Print(value, os); |
||||
} |
||||
|
||||
#if GTEST_HAS_TR1_TUPLE |
||||
typedef ::std::vector<string> Strings; |
||||
|
||||
// This helper template allows PrintTo() for tuples and
|
||||
// UniversalTersePrintTupleFieldsToStrings() to be defined by
|
||||
// induction on the number of tuple fields. The idea is that
|
||||
// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
|
||||
// fields in tuple t, and can be defined in terms of
|
||||
// TuplePrefixPrinter<N - 1>.
|
||||
|
||||
// The inductive case.
|
||||
template <size_t N> |
||||
struct TuplePrefixPrinter { |
||||
// Prints the first N fields of a tuple.
|
||||
template <typename Tuple> |
||||
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { |
||||
TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os); |
||||
*os << ", "; |
||||
UniversalPrinter<typename ::std::tr1::tuple_element<N - 1, Tuple>::type> |
||||
::Print(::std::tr1::get<N - 1>(t), os); |
||||
} |
||||
|
||||
// Tersely prints the first N fields of a tuple to a string vector,
|
||||
// one element for each field.
|
||||
template <typename Tuple> |
||||
static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { |
||||
TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings); |
||||
::std::stringstream ss; |
||||
UniversalTersePrint(::std::tr1::get<N - 1>(t), &ss); |
||||
strings->push_back(ss.str()); |
||||
} |
||||
}; |
||||
|
||||
// Base cases.
|
||||
template <> |
||||
struct TuplePrefixPrinter<0> { |
||||
template <typename Tuple> |
||||
static void PrintPrefixTo(const Tuple&, ::std::ostream*) {} |
||||
|
||||
template <typename Tuple> |
||||
static void TersePrintPrefixToStrings(const Tuple&, Strings*) {} |
||||
}; |
||||
// We have to specialize the entire TuplePrefixPrinter<> class
|
||||
// template here, even though the definition of
|
||||
// TersePrintPrefixToStrings() is the same as the generic version, as
|
||||
// Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't
|
||||
// support specializing a method template of a class template.
|
||||
template <> |
||||
struct TuplePrefixPrinter<1> { |
||||
template <typename Tuple> |
||||
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { |
||||
UniversalPrinter<typename ::std::tr1::tuple_element<0, Tuple>::type>:: |
||||
Print(::std::tr1::get<0>(t), os); |
||||
} |
||||
|
||||
template <typename Tuple> |
||||
static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { |
||||
::std::stringstream ss; |
||||
UniversalTersePrint(::std::tr1::get<0>(t), &ss); |
||||
strings->push_back(ss.str()); |
||||
} |
||||
}; |
||||
|
||||
// Helper function for printing a tuple. T must be instantiated with
|
||||
// a tuple type.
|
||||
template <typename T> |
||||
void PrintTupleTo(const T& t, ::std::ostream* os) { |
||||
*os << "("; |
||||
TuplePrefixPrinter< ::std::tr1::tuple_size<T>::value>:: |
||||
PrintPrefixTo(t, os); |
||||
*os << ")"; |
||||
} |
||||
|
||||
// Prints the fields of a tuple tersely to a string vector, one
|
||||
// element for each field. See the comment before
|
||||
// UniversalTersePrint() for how we define "tersely".
|
||||
template <typename Tuple> |
||||
Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) { |
||||
Strings result; |
||||
TuplePrefixPrinter< ::std::tr1::tuple_size<Tuple>::value>:: |
||||
TersePrintPrefixToStrings(value, &result); |
||||
return result; |
||||
} |
||||
#endif // GTEST_HAS_TR1_TUPLE
|
||||
|
||||
} // namespace internal
|
||||
|
||||
template <typename T> |
||||
::std::string PrintToString(const T& value) { |
||||
::std::stringstream ss; |
||||
internal::UniversalTersePrint(value, &ss); |
||||
return ss.str(); |
||||
} |
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
|
@ -0,0 +1,232 @@
|
||||
// Copyright 2007, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// Utilities for testing Google Test itself and code that uses Google Test
|
||||
// (e.g. frameworks built on top of Google Test).
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_ |
||||
|
||||
#include "gtest/gtest.h" |
||||
|
||||
namespace testing { |
||||
|
||||
// This helper class can be used to mock out Google Test failure reporting
|
||||
// so that we can test Google Test or code that builds on Google Test.
|
||||
//
|
||||
// An object of this class appends a TestPartResult object to the
|
||||
// TestPartResultArray object given in the constructor whenever a Google Test
|
||||
// failure is reported. It can either intercept only failures that are
|
||||
// generated in the same thread that created this object or it can intercept
|
||||
// all generated failures. The scope of this mock object can be controlled with
|
||||
// the second argument to the two arguments constructor.
|
||||
class GTEST_API_ ScopedFakeTestPartResultReporter |
||||
: public TestPartResultReporterInterface { |
||||
public: |
||||
// The two possible mocking modes of this object.
|
||||
enum InterceptMode { |
||||
INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures.
|
||||
INTERCEPT_ALL_THREADS // Intercepts all failures.
|
||||
}; |
||||
|
||||
// The c'tor sets this object as the test part result reporter used
|
||||
// by Google Test. The 'result' parameter specifies where to report the
|
||||
// results. This reporter will only catch failures generated in the current
|
||||
// thread. DEPRECATED
|
||||
explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); |
||||
|
||||
// Same as above, but you can choose the interception scope of this object.
|
||||
ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, |
||||
TestPartResultArray* result); |
||||
|
||||
// The d'tor restores the previous test part result reporter.
|
||||
virtual ~ScopedFakeTestPartResultReporter(); |
||||
|
||||
// Appends the TestPartResult object to the TestPartResultArray
|
||||
// received in the constructor.
|
||||
//
|
||||
// This method is from the TestPartResultReporterInterface
|
||||
// interface.
|
||||
virtual void ReportTestPartResult(const TestPartResult& result); |
||||
private: |
||||
void Init(); |
||||
|
||||
const InterceptMode intercept_mode_; |
||||
TestPartResultReporterInterface* old_reporter_; |
||||
TestPartResultArray* const result_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); |
||||
}; |
||||
|
||||
namespace internal { |
||||
|
||||
// A helper class for implementing EXPECT_FATAL_FAILURE() and
|
||||
// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given
|
||||
// TestPartResultArray contains exactly one failure that has the given
|
||||
// type and contains the given substring. If that's not the case, a
|
||||
// non-fatal failure will be generated.
|
||||
class GTEST_API_ SingleFailureChecker { |
||||
public: |
||||
// The constructor remembers the arguments.
|
||||
SingleFailureChecker(const TestPartResultArray* results, |
||||
TestPartResult::Type type, |
||||
const string& substr); |
||||
~SingleFailureChecker(); |
||||
private: |
||||
const TestPartResultArray* const results_; |
||||
const TestPartResult::Type type_; |
||||
const string substr_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); |
||||
}; |
||||
|
||||
} // namespace internal
|
||||
|
||||
} // namespace testing
|
||||
|
||||
// A set of macros for testing Google Test assertions or code that's expected
|
||||
// to generate Google Test fatal failures. It verifies that the given
|
||||
// statement will cause exactly one fatal Google Test failure with 'substr'
|
||||
// being part of the failure message.
|
||||
//
|
||||
// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
|
||||
// affects and considers failures generated in the current thread and
|
||||
// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
|
||||
//
|
||||
// The verification of the assertion is done correctly even when the statement
|
||||
// throws an exception or aborts the current function.
|
||||
//
|
||||
// Known restrictions:
|
||||
// - 'statement' cannot reference local non-static variables or
|
||||
// non-static members of the current object.
|
||||
// - 'statement' cannot return a value.
|
||||
// - You cannot stream a failure message to this macro.
|
||||
//
|
||||
// Note that even though the implementations of the following two
|
||||
// macros are much alike, we cannot refactor them to use a common
|
||||
// helper macro, due to some peculiarity in how the preprocessor
|
||||
// works. The AcceptsMacroThatExpandsToUnprotectedComma test in
|
||||
// gtest_unittest.cc will fail to compile if we do that.
|
||||
#define EXPECT_FATAL_FAILURE(statement, substr) \ |
||||
do { \
|
||||
class GTestExpectFatalFailureHelper {\
|
||||
public:\
|
||||
static void Execute() { statement; }\
|
||||
};\
|
||||
::testing::TestPartResultArray gtest_failures;\
|
||||
::testing::internal::SingleFailureChecker gtest_checker(\
|
||||
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
|
||||
{\
|
||||
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
|
||||
::testing::ScopedFakeTestPartResultReporter:: \
|
||||
INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\
|
||||
GTestExpectFatalFailureHelper::Execute();\
|
||||
}\
|
||||
} while (::testing::internal::AlwaysFalse()) |
||||
|
||||
#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ |
||||
do { \
|
||||
class GTestExpectFatalFailureHelper {\
|
||||
public:\
|
||||
static void Execute() { statement; }\
|
||||
};\
|
||||
::testing::TestPartResultArray gtest_failures;\
|
||||
::testing::internal::SingleFailureChecker gtest_checker(\
|
||||
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
|
||||
{\
|
||||
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
|
||||
::testing::ScopedFakeTestPartResultReporter:: \
|
||||
INTERCEPT_ALL_THREADS, >est_failures);\
|
||||
GTestExpectFatalFailureHelper::Execute();\
|
||||
}\
|
||||
} while (::testing::internal::AlwaysFalse()) |
||||
|
||||
// A macro for testing Google Test assertions or code that's expected to
|
||||
// generate Google Test non-fatal failures. It asserts that the given
|
||||
// statement will cause exactly one non-fatal Google Test failure with 'substr'
|
||||
// being part of the failure message.
|
||||
//
|
||||
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
|
||||
// affects and considers failures generated in the current thread and
|
||||
// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
|
||||
//
|
||||
// 'statement' is allowed to reference local variables and members of
|
||||
// the current object.
|
||||
//
|
||||
// The verification of the assertion is done correctly even when the statement
|
||||
// throws an exception or aborts the current function.
|
||||
//
|
||||
// Known restrictions:
|
||||
// - You cannot stream a failure message to this macro.
|
||||
//
|
||||
// Note that even though the implementations of the following two
|
||||
// macros are much alike, we cannot refactor them to use a common
|
||||
// helper macro, due to some peculiarity in how the preprocessor
|
||||
// works. If we do that, the code won't compile when the user gives
|
||||
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
|
||||
// expands to code containing an unprotected comma. The
|
||||
// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
|
||||
// catches that.
|
||||
//
|
||||
// For the same reason, we have to write
|
||||
// if (::testing::internal::AlwaysTrue()) { statement; }
|
||||
// instead of
|
||||
// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
|
||||
// to avoid an MSVC warning on unreachable code.
|
||||
#define EXPECT_NONFATAL_FAILURE(statement, substr) \ |
||||
do {\
|
||||
::testing::TestPartResultArray gtest_failures;\
|
||||
::testing::internal::SingleFailureChecker gtest_checker(\
|
||||
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \
|
||||
(substr));\
|
||||
{\
|
||||
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
|
||||
::testing::ScopedFakeTestPartResultReporter:: \
|
||||
INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\
|
||||
if (::testing::internal::AlwaysTrue()) { statement; }\
|
||||
}\
|
||||
} while (::testing::internal::AlwaysFalse()) |
||||
|
||||
#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ |
||||
do {\
|
||||
::testing::TestPartResultArray gtest_failures;\
|
||||
::testing::internal::SingleFailureChecker gtest_checker(\
|
||||
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \
|
||||
(substr));\
|
||||
{\
|
||||
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
|
||||
::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS,\
|
||||
>est_failures);\
|
||||
if (::testing::internal::AlwaysTrue()) { statement; }\
|
||||
}\
|
||||
} while (::testing::internal::AlwaysFalse()) |
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
|
@ -0,0 +1,176 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: mheule@google.com (Markus Heule)
|
||||
//
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ |
||||
|
||||
#include <iosfwd> |
||||
#include <vector> |
||||
#include "gtest/internal/gtest-internal.h" |
||||
#include "gtest/internal/gtest-string.h" |
||||
|
||||
namespace testing { |
||||
|
||||
// A copyable object representing the result of a test part (i.e. an
|
||||
// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
|
||||
//
|
||||
// Don't inherit from TestPartResult as its destructor is not virtual.
|
||||
class GTEST_API_ TestPartResult { |
||||
public: |
||||
// The possible outcomes of a test part (i.e. an assertion or an
|
||||
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
|
||||
enum Type { |
||||
kSuccess, // Succeeded.
|
||||
kNonFatalFailure, // Failed but the test can continue.
|
||||
kFatalFailure // Failed and the test should be terminated.
|
||||
}; |
||||
|
||||
// C'tor. TestPartResult does NOT have a default constructor.
|
||||
// Always use this constructor (with parameters) to create a
|
||||
// TestPartResult object.
|
||||
TestPartResult(Type a_type, |
||||
const char* a_file_name, |
||||
int a_line_number, |
||||
const char* a_message) |
||||
: type_(a_type), |
||||
file_name_(a_file_name), |
||||
line_number_(a_line_number), |
||||
summary_(ExtractSummary(a_message)), |
||||
message_(a_message) { |
||||
} |
||||
|
||||
// Gets the outcome of the test part.
|
||||
Type type() const { return type_; } |
||||
|
||||
// Gets the name of the source file where the test part took place, or
|
||||
// NULL if it's unknown.
|
||||
const char* file_name() const { return file_name_.c_str(); } |
||||
|
||||
// Gets the line in the source file where the test part took place,
|
||||
// or -1 if it's unknown.
|
||||
int line_number() const { return line_number_; } |
||||
|
||||
// Gets the summary of the failure message.
|
||||
const char* summary() const { return summary_.c_str(); } |
||||
|
||||
// Gets the message associated with the test part.
|
||||
const char* message() const { return message_.c_str(); } |
||||
|
||||
// Returns true iff the test part passed.
|
||||
bool passed() const { return type_ == kSuccess; } |
||||
|
||||
// Returns true iff the test part failed.
|
||||
bool failed() const { return type_ != kSuccess; } |
||||
|
||||
// Returns true iff the test part non-fatally failed.
|
||||
bool nonfatally_failed() const { return type_ == kNonFatalFailure; } |
||||
|
||||
// Returns true iff the test part fatally failed.
|
||||
bool fatally_failed() const { return type_ == kFatalFailure; } |
||||
private: |
||||
Type type_; |
||||
|
||||
// Gets the summary of the failure message by omitting the stack
|
||||
// trace in it.
|
||||
static internal::String ExtractSummary(const char* message); |
||||
|
||||
// The name of the source file where the test part took place, or
|
||||
// NULL if the source file is unknown.
|
||||
internal::String file_name_; |
||||
// The line in the source file where the test part took place, or -1
|
||||
// if the line number is unknown.
|
||||
int line_number_; |
||||
internal::String summary_; // The test failure summary.
|
||||
internal::String message_; // The test failure message.
|
||||
}; |
||||
|
||||
// Prints a TestPartResult object.
|
||||
std::ostream& operator<<(std::ostream& os, const TestPartResult& result); |
||||
|
||||
// An array of TestPartResult objects.
|
||||
//
|
||||
// Don't inherit from TestPartResultArray as its destructor is not
|
||||
// virtual.
|
||||
class GTEST_API_ TestPartResultArray { |
||||
public: |
||||
TestPartResultArray() {} |
||||
|
||||
// Appends the given TestPartResult to the array.
|
||||
void Append(const TestPartResult& result); |
||||
|
||||
// Returns the TestPartResult at the given index (0-based).
|
||||
const TestPartResult& GetTestPartResult(int index) const; |
||||
|
||||
// Returns the number of TestPartResult objects in the array.
|
||||
int size() const; |
||||
|
||||
private: |
||||
std::vector<TestPartResult> array_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray); |
||||
}; |
||||
|
||||
// This interface knows how to report a test part result.
|
||||
class TestPartResultReporterInterface { |
||||
public: |
||||
virtual ~TestPartResultReporterInterface() {} |
||||
|
||||
virtual void ReportTestPartResult(const TestPartResult& result) = 0; |
||||
}; |
||||
|
||||
namespace internal { |
||||
|
||||
// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
|
||||
// statement generates new fatal failures. To do so it registers itself as the
|
||||
// current test part result reporter. Besides checking if fatal failures were
|
||||
// reported, it only delegates the reporting to the former result reporter.
|
||||
// The original result reporter is restored in the destructor.
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
|
||||
class GTEST_API_ HasNewFatalFailureHelper |
||||
: public TestPartResultReporterInterface { |
||||
public: |
||||
HasNewFatalFailureHelper(); |
||||
virtual ~HasNewFatalFailureHelper(); |
||||
virtual void ReportTestPartResult(const TestPartResult& result); |
||||
bool has_new_fatal_failure() const { return has_new_fatal_failure_; } |
||||
private: |
||||
bool has_new_fatal_failure_; |
||||
TestPartResultReporterInterface* original_reporter_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper); |
||||
}; |
||||
|
||||
} // namespace internal
|
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
|
@ -0,0 +1,259 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ |
||||
|
||||
// This header implements typed tests and type-parameterized tests.
|
||||
|
||||
// Typed (aka type-driven) tests repeat the same test for types in a
|
||||
// list. You must know which types you want to test with when writing
|
||||
// typed tests. Here's how you do it:
|
||||
|
||||
#if 0 |
||||
|
||||
// First, define a fixture class template. It should be parameterized
|
||||
// by a type. Remember to derive it from testing::Test.
|
||||
template <typename T> |
||||
class FooTest : public testing::Test { |
||||
public: |
||||
... |
||||
typedef std::list<T> List; |
||||
static T shared_; |
||||
T value_; |
||||
}; |
||||
|
||||
// Next, associate a list of types with the test case, which will be
|
||||
// repeated for each type in the list. The typedef is necessary for
|
||||
// the macro to parse correctly.
|
||||
typedef testing::Types<char, int, unsigned int> MyTypes; |
||||
TYPED_TEST_CASE(FooTest, MyTypes); |
||||
|
||||
// If the type list contains only one type, you can write that type
|
||||
// directly without Types<...>:
|
||||
// TYPED_TEST_CASE(FooTest, int);
|
||||
|
||||
// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
|
||||
// tests for this test case as you want.
|
||||
TYPED_TEST(FooTest, DoesBlah) { |
||||
// Inside a test, refer to TypeParam to get the type parameter.
|
||||
// Since we are inside a derived class template, C++ requires use to
|
||||
// visit the members of FooTest via 'this'.
|
||||
TypeParam n = this->value_; |
||||
|
||||
// To visit static members of the fixture, add the TestFixture::
|
||||
// prefix.
|
||||
n += TestFixture::shared_; |
||||
|
||||
// To refer to typedefs in the fixture, add the "typename
|
||||
// TestFixture::" prefix.
|
||||
typename TestFixture::List values; |
||||
values.push_back(n); |
||||
... |
||||
} |
||||
|
||||
TYPED_TEST(FooTest, HasPropertyA) { ... } |
||||
|
||||
#endif // 0
|
||||
|
||||
// Type-parameterized tests are abstract test patterns parameterized
|
||||
// by a type. Compared with typed tests, type-parameterized tests
|
||||
// allow you to define the test pattern without knowing what the type
|
||||
// parameters are. The defined pattern can be instantiated with
|
||||
// different types any number of times, in any number of translation
|
||||
// units.
|
||||
//
|
||||
// If you are designing an interface or concept, you can define a
|
||||
// suite of type-parameterized tests to verify properties that any
|
||||
// valid implementation of the interface/concept should have. Then,
|
||||
// each implementation can easily instantiate the test suite to verify
|
||||
// that it conforms to the requirements, without having to write
|
||||
// similar tests repeatedly. Here's an example:
|
||||
|
||||
#if 0 |
||||
|
||||
// First, define a fixture class template. It should be parameterized
|
||||
// by a type. Remember to derive it from testing::Test.
|
||||
template <typename T> |
||||
class FooTest : public testing::Test { |
||||
... |
||||
}; |
||||
|
||||
// Next, declare that you will define a type-parameterized test case
|
||||
// (the _P suffix is for "parameterized" or "pattern", whichever you
|
||||
// prefer):
|
||||
TYPED_TEST_CASE_P(FooTest); |
||||
|
||||
// Then, use TYPED_TEST_P() to define as many type-parameterized tests
|
||||
// for this type-parameterized test case as you want.
|
||||
TYPED_TEST_P(FooTest, DoesBlah) { |
||||
// Inside a test, refer to TypeParam to get the type parameter.
|
||||
TypeParam n = 0; |
||||
... |
||||
} |
||||
|
||||
TYPED_TEST_P(FooTest, HasPropertyA) { ... } |
||||
|
||||
// Now the tricky part: you need to register all test patterns before
|
||||
// you can instantiate them. The first argument of the macro is the
|
||||
// test case name; the rest are the names of the tests in this test
|
||||
// case.
|
||||
REGISTER_TYPED_TEST_CASE_P(FooTest, |
||||
DoesBlah, HasPropertyA); |
||||
|
||||
// Finally, you are free to instantiate the pattern with the types you
|
||||
// want. If you put the above code in a header file, you can #include
|
||||
// it in multiple C++ source files and instantiate it multiple times.
|
||||
//
|
||||
// To distinguish different instances of the pattern, the first
|
||||
// argument to the INSTANTIATE_* macro is a prefix that will be added
|
||||
// to the actual test case name. Remember to pick unique prefixes for
|
||||
// different instances.
|
||||
typedef testing::Types<char, int, unsigned int> MyTypes; |
||||
INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes); |
||||
|
||||
// If the type list contains only one type, you can write that type
|
||||
// directly without Types<...>:
|
||||
// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
|
||||
|
||||
#endif // 0
|
||||
|
||||
#include "gtest/internal/gtest-port.h" |
||||
#include "gtest/internal/gtest-type-util.h" |
||||
|
||||
// Implements typed tests.
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Expands to the name of the typedef for the type parameters of the
|
||||
// given test case.
|
||||
# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_ |
||||
|
||||
// The 'Types' template argument below must have spaces around it
|
||||
// since some compilers may choke on '>>' when passing a template
|
||||
// instance (e.g. Types<int>)
|
||||
# define TYPED_TEST_CASE(CaseName, Types) \ |
||||
typedef ::testing::internal::TypeList< Types >::type \
|
||||
GTEST_TYPE_PARAMS_(CaseName) |
||||
|
||||
# define TYPED_TEST(CaseName, TestName) \ |
||||
template <typename gtest_TypeParam_> \
|
||||
class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \
|
||||
: public CaseName<gtest_TypeParam_> { \
|
||||
private: \
|
||||
typedef CaseName<gtest_TypeParam_> TestFixture; \
|
||||
typedef gtest_TypeParam_ TypeParam; \
|
||||
virtual void TestBody(); \
|
||||
}; \
|
||||
bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \
|
||||
::testing::internal::TypeParameterizedTest< \
|
||||
CaseName, \
|
||||
::testing::internal::TemplateSel< \
|
||||
GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \
|
||||
GTEST_TYPE_PARAMS_(CaseName)>::Register(\
|
||||
"", #CaseName, #TestName, 0); \
|
||||
template <typename gtest_TypeParam_> \
|
||||
void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody() |
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST
|
||||
|
||||
// Implements type-parameterized tests.
|
||||
|
||||
#if GTEST_HAS_TYPED_TEST_P |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Expands to the namespace name that the type-parameterized tests for
|
||||
// the given type-parameterized test case are defined in. The exact
|
||||
// name of the namespace is subject to change without notice.
|
||||
# define GTEST_CASE_NAMESPACE_(TestCaseName) \ |
||||
gtest_case_##TestCaseName##_ |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Expands to the name of the variable used to remember the names of
|
||||
// the defined tests in the given test case.
|
||||
# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \ |
||||
gtest_typed_test_case_p_state_##TestCaseName##_ |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
|
||||
//
|
||||
// Expands to the name of the variable used to remember the names of
|
||||
// the registered tests in the given test case.
|
||||
# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \ |
||||
gtest_registered_test_names_##TestCaseName##_ |
||||
|
||||
// The variables defined in the type-parameterized test macros are
|
||||
// static as typically these macros are used in a .h file that can be
|
||||
// #included in multiple translation units linked together.
|
||||
# define TYPED_TEST_CASE_P(CaseName) \ |
||||
static ::testing::internal::TypedTestCasePState \
|
||||
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName) |
||||
|
||||
# define TYPED_TEST_P(CaseName, TestName) \ |
||||
namespace GTEST_CASE_NAMESPACE_(CaseName) { \
|
||||
template <typename gtest_TypeParam_> \
|
||||
class TestName : public CaseName<gtest_TypeParam_> { \
|
||||
private: \
|
||||
typedef CaseName<gtest_TypeParam_> TestFixture; \
|
||||
typedef gtest_TypeParam_ TypeParam; \
|
||||
virtual void TestBody(); \
|
||||
}; \
|
||||
static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
|
||||
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
|
||||
__FILE__, __LINE__, #CaseName, #TestName); \
|
||||
} \
|
||||
template <typename gtest_TypeParam_> \
|
||||
void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody() |
||||
|
||||
# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \ |
||||
namespace GTEST_CASE_NAMESPACE_(CaseName) { \
|
||||
typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
|
||||
} \
|
||||
static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
|
||||
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
|
||||
__FILE__, __LINE__, #__VA_ARGS__) |
||||
|
||||
// The 'Types' template argument below must have spaces around it
|
||||
// since some compilers may choke on '>>' when passing a template
|
||||
// instance (e.g. Types<int>)
|
||||
# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \ |
||||
bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
|
||||
::testing::internal::TypeParameterizedTestCase<CaseName, \
|
||||
GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
|
||||
::testing::internal::TypeList< Types >::type>::Register(\
|
||||
#Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName)) |
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST_P
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,358 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// This file is AUTOMATICALLY GENERATED on 09/24/2010 by command
|
||||
// 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND!
|
||||
//
|
||||
// Implements a family of generic predicate assertion macros.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ |
||||
|
||||
// Makes sure this header is not included before gtest.h.
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_H_ |
||||
# error Do not include gtest_pred_impl.h directly. Include gtest.h instead. |
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_H_
|
||||
|
||||
// This header implements a family of generic predicate assertion
|
||||
// macros:
|
||||
//
|
||||
// ASSERT_PRED_FORMAT1(pred_format, v1)
|
||||
// ASSERT_PRED_FORMAT2(pred_format, v1, v2)
|
||||
// ...
|
||||
//
|
||||
// where pred_format is a function or functor that takes n (in the
|
||||
// case of ASSERT_PRED_FORMATn) values and their source expression
|
||||
// text, and returns a testing::AssertionResult. See the definition
|
||||
// of ASSERT_EQ in gtest.h for an example.
|
||||
//
|
||||
// If you don't care about formatting, you can use the more
|
||||
// restrictive version:
|
||||
//
|
||||
// ASSERT_PRED1(pred, v1)
|
||||
// ASSERT_PRED2(pred, v1, v2)
|
||||
// ...
|
||||
//
|
||||
// where pred is an n-ary function or functor that returns bool,
|
||||
// and the values v1, v2, ..., must support the << operator for
|
||||
// streaming to std::ostream.
|
||||
//
|
||||
// We also define the EXPECT_* variations.
|
||||
//
|
||||
// For now we only support predicates whose arity is at most 5.
|
||||
// Please email googletestframework@googlegroups.com if you need
|
||||
// support for higher arities.
|
||||
|
||||
// GTEST_ASSERT_ is the basic statement to which all of the assertions
|
||||
// in this file reduce. Don't use this in your code.
|
||||
|
||||
#define GTEST_ASSERT_(expression, on_failure) \ |
||||
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
|
||||
if (const ::testing::AssertionResult gtest_ar = (expression)) \
|
||||
; \
|
||||
else \
|
||||
on_failure(gtest_ar.failure_message()) |
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred, |
||||
typename T1> |
||||
AssertionResult AssertPred1Helper(const char* pred_text, |
||||
const char* e1, |
||||
Pred pred, |
||||
const T1& v1) { |
||||
if (pred(v1)) return AssertionSuccess(); |
||||
|
||||
return AssertionFailure() << pred_text << "(" |
||||
<< e1 << ") evaluates to false, where" |
||||
<< "\n" << e1 << " evaluates to " << v1; |
||||
} |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\ |
||||
GTEST_ASSERT_(pred_format(#v1, v1),\
|
||||
on_failure) |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED1_(pred, v1, on_failure)\ |
||||
GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
|
||||
#v1, \ |
||||
pred, \
|
||||
v1), on_failure) |
||||
|
||||
// Unary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT1(pred_format, v1) \ |
||||
GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) |
||||
#define EXPECT_PRED1(pred, v1) \ |
||||
GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_) |
||||
#define ASSERT_PRED_FORMAT1(pred_format, v1) \ |
||||
GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) |
||||
#define ASSERT_PRED1(pred, v1) \ |
||||
GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_) |
||||
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred, |
||||
typename T1, |
||||
typename T2> |
||||
AssertionResult AssertPred2Helper(const char* pred_text, |
||||
const char* e1, |
||||
const char* e2, |
||||
Pred pred, |
||||
const T1& v1, |
||||
const T2& v2) { |
||||
if (pred(v1, v2)) return AssertionSuccess(); |
||||
|
||||
return AssertionFailure() << pred_text << "(" |
||||
<< e1 << ", " |
||||
<< e2 << ") evaluates to false, where" |
||||
<< "\n" << e1 << " evaluates to " << v1 |
||||
<< "\n" << e2 << " evaluates to " << v2; |
||||
} |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\ |
||||
GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2),\
|
||||
on_failure) |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED2_(pred, v1, v2, on_failure)\ |
||||
GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
|
||||
#v1, \ |
||||
#v2, \ |
||||
pred, \
|
||||
v1, \
|
||||
v2), on_failure) |
||||
|
||||
// Binary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ |
||||
GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) |
||||
#define EXPECT_PRED2(pred, v1, v2) \ |
||||
GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_) |
||||
#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ |
||||
GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) |
||||
#define ASSERT_PRED2(pred, v1, v2) \ |
||||
GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_) |
||||
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred, |
||||
typename T1, |
||||
typename T2, |
||||
typename T3> |
||||
AssertionResult AssertPred3Helper(const char* pred_text, |
||||
const char* e1, |
||||
const char* e2, |
||||
const char* e3, |
||||
Pred pred, |
||||
const T1& v1, |
||||
const T2& v2, |
||||
const T3& v3) { |
||||
if (pred(v1, v2, v3)) return AssertionSuccess(); |
||||
|
||||
return AssertionFailure() << pred_text << "(" |
||||
<< e1 << ", " |
||||
<< e2 << ", " |
||||
<< e3 << ") evaluates to false, where" |
||||
<< "\n" << e1 << " evaluates to " << v1 |
||||
<< "\n" << e2 << " evaluates to " << v2 |
||||
<< "\n" << e3 << " evaluates to " << v3; |
||||
} |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\ |
||||
GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3),\
|
||||
on_failure) |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\ |
||||
GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
|
||||
#v1, \ |
||||
#v2, \ |
||||
#v3, \ |
||||
pred, \
|
||||
v1, \
|
||||
v2, \
|
||||
v3), on_failure) |
||||
|
||||
// Ternary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \ |
||||
GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_) |
||||
#define EXPECT_PRED3(pred, v1, v2, v3) \ |
||||
GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_) |
||||
#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \ |
||||
GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_) |
||||
#define ASSERT_PRED3(pred, v1, v2, v3) \ |
||||
GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_) |
||||
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred, |
||||
typename T1, |
||||
typename T2, |
||||
typename T3, |
||||
typename T4> |
||||
AssertionResult AssertPred4Helper(const char* pred_text, |
||||
const char* e1, |
||||
const char* e2, |
||||
const char* e3, |
||||
const char* e4, |
||||
Pred pred, |
||||
const T1& v1, |
||||
const T2& v2, |
||||
const T3& v3, |
||||
const T4& v4) { |
||||
if (pred(v1, v2, v3, v4)) return AssertionSuccess(); |
||||
|
||||
return AssertionFailure() << pred_text << "(" |
||||
<< e1 << ", " |
||||
<< e2 << ", " |
||||
<< e3 << ", " |
||||
<< e4 << ") evaluates to false, where" |
||||
<< "\n" << e1 << " evaluates to " << v1 |
||||
<< "\n" << e2 << " evaluates to " << v2 |
||||
<< "\n" << e3 << " evaluates to " << v3 |
||||
<< "\n" << e4 << " evaluates to " << v4; |
||||
} |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\ |
||||
GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4),\
|
||||
on_failure) |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\ |
||||
GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
|
||||
#v1, \ |
||||
#v2, \ |
||||
#v3, \ |
||||
#v4, \ |
||||
pred, \
|
||||
v1, \
|
||||
v2, \
|
||||
v3, \
|
||||
v4), on_failure) |
||||
|
||||
// 4-ary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ |
||||
GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) |
||||
#define EXPECT_PRED4(pred, v1, v2, v3, v4) \ |
||||
GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) |
||||
#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ |
||||
GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) |
||||
#define ASSERT_PRED4(pred, v1, v2, v3, v4) \ |
||||
GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) |
||||
|
||||
|
||||
|
||||
// Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use
|
||||
// this in your code.
|
||||
template <typename Pred, |
||||
typename T1, |
||||
typename T2, |
||||
typename T3, |
||||
typename T4, |
||||
typename T5> |
||||
AssertionResult AssertPred5Helper(const char* pred_text, |
||||
const char* e1, |
||||
const char* e2, |
||||
const char* e3, |
||||
const char* e4, |
||||
const char* e5, |
||||
Pred pred, |
||||
const T1& v1, |
||||
const T2& v2, |
||||
const T3& v3, |
||||
const T4& v4, |
||||
const T5& v5) { |
||||
if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess(); |
||||
|
||||
return AssertionFailure() << pred_text << "(" |
||||
<< e1 << ", " |
||||
<< e2 << ", " |
||||
<< e3 << ", " |
||||
<< e4 << ", " |
||||
<< e5 << ") evaluates to false, where" |
||||
<< "\n" << e1 << " evaluates to " << v1 |
||||
<< "\n" << e2 << " evaluates to " << v2 |
||||
<< "\n" << e3 << " evaluates to " << v3 |
||||
<< "\n" << e4 << " evaluates to " << v4 |
||||
<< "\n" << e5 << " evaluates to " << v5; |
||||
} |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
|
||||
// Don't use this in your code.
|
||||
#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\ |
||||
GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5),\
|
||||
on_failure) |
||||
|
||||
// Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use
|
||||
// this in your code.
|
||||
#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\ |
||||
GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
|
||||
#v1, \ |
||||
#v2, \ |
||||
#v3, \ |
||||
#v4, \ |
||||
#v5, \ |
||||
pred, \
|
||||
v1, \
|
||||
v2, \
|
||||
v3, \
|
||||
v4, \
|
||||
v5), on_failure) |
||||
|
||||
// 5-ary predicate assertion macros.
|
||||
#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ |
||||
GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) |
||||
#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \ |
||||
GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) |
||||
#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ |
||||
GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) |
||||
#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \ |
||||
GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) |
||||
|
||||
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
|
@ -0,0 +1,58 @@
|
||||
// Copyright 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
//
|
||||
// Google C++ Testing Framework definitions useful in production code.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_ |
||||
#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_ |
||||
|
||||
// When you need to test the private or protected members of a class,
|
||||
// use the FRIEND_TEST macro to declare your tests as friends of the
|
||||
// class. For example:
|
||||
//
|
||||
// class MyClass {
|
||||
// private:
|
||||
// void MyMethod();
|
||||
// FRIEND_TEST(MyClassTest, MyMethod);
|
||||
// };
|
||||
//
|
||||
// class MyClassTest : public testing::Test {
|
||||
// // ...
|
||||
// };
|
||||
//
|
||||
// TEST_F(MyClassTest, MyMethod) {
|
||||
// // Can call MyClass::MyMethod() here.
|
||||
// }
|
||||
|
||||
#define FRIEND_TEST(test_case_name, test_name)\ |
||||
friend class test_case_name##_##test_name##_Test |
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
|
@ -0,0 +1,308 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
|
||||
//
|
||||
// The Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// This header file defines internal utilities needed for implementing
|
||||
// death tests. They are subject to change without notice.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ |
||||
|
||||
#include "gtest/internal/gtest-internal.h" |
||||
|
||||
#include <stdio.h> |
||||
|
||||
namespace testing { |
||||
namespace internal { |
||||
|
||||
GTEST_DECLARE_string_(internal_run_death_test); |
||||
|
||||
// Names of the flags (needed for parsing Google Test flags).
|
||||
const char kDeathTestStyleFlag[] = "death_test_style"; |
||||
const char kDeathTestUseFork[] = "death_test_use_fork"; |
||||
const char kInternalRunDeathTestFlag[] = "internal_run_death_test"; |
||||
|
||||
#if GTEST_HAS_DEATH_TEST |
||||
|
||||
// DeathTest is a class that hides much of the complexity of the
|
||||
// GTEST_DEATH_TEST_ macro. It is abstract; its static Create method
|
||||
// returns a concrete class that depends on the prevailing death test
|
||||
// style, as defined by the --gtest_death_test_style and/or
|
||||
// --gtest_internal_run_death_test flags.
|
||||
|
||||
// In describing the results of death tests, these terms are used with
|
||||
// the corresponding definitions:
|
||||
//
|
||||
// exit status: The integer exit information in the format specified
|
||||
// by wait(2)
|
||||
// exit code: The integer code passed to exit(3), _exit(2), or
|
||||
// returned from main()
|
||||
class GTEST_API_ DeathTest { |
||||
public: |
||||
// Create returns false if there was an error determining the
|
||||
// appropriate action to take for the current death test; for example,
|
||||
// if the gtest_death_test_style flag is set to an invalid value.
|
||||
// The LastMessage method will return a more detailed message in that
|
||||
// case. Otherwise, the DeathTest pointer pointed to by the "test"
|
||||
// argument is set. If the death test should be skipped, the pointer
|
||||
// is set to NULL; otherwise, it is set to the address of a new concrete
|
||||
// DeathTest object that controls the execution of the current test.
|
||||
static bool Create(const char* statement, const RE* regex, |
||||
const char* file, int line, DeathTest** test); |
||||
DeathTest(); |
||||
virtual ~DeathTest() { } |
||||
|
||||
// A helper class that aborts a death test when it's deleted.
|
||||
class ReturnSentinel { |
||||
public: |
||||
explicit ReturnSentinel(DeathTest* test) : test_(test) { } |
||||
~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); } |
||||
private: |
||||
DeathTest* const test_; |
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel); |
||||
} GTEST_ATTRIBUTE_UNUSED_; |
||||
|
||||
// An enumeration of possible roles that may be taken when a death
|
||||
// test is encountered. EXECUTE means that the death test logic should
|
||||
// be executed immediately. OVERSEE means that the program should prepare
|
||||
// the appropriate environment for a child process to execute the death
|
||||
// test, then wait for it to complete.
|
||||
enum TestRole { OVERSEE_TEST, EXECUTE_TEST }; |
||||
|
||||
// An enumeration of the three reasons that a test might be aborted.
|
||||
enum AbortReason { |
||||
TEST_ENCOUNTERED_RETURN_STATEMENT, |
||||
TEST_THREW_EXCEPTION, |
||||
TEST_DID_NOT_DIE |
||||
}; |
||||
|
||||
// Assumes one of the above roles.
|
||||
virtual TestRole AssumeRole() = 0; |
||||
|
||||
// Waits for the death test to finish and returns its status.
|
||||
virtual int Wait() = 0; |
||||
|
||||
// Returns true if the death test passed; that is, the test process
|
||||
// exited during the test, its exit status matches a user-supplied
|
||||
// predicate, and its stderr output matches a user-supplied regular
|
||||
// expression.
|
||||
// The user-supplied predicate may be a macro expression rather
|
||||
// than a function pointer or functor, or else Wait and Passed could
|
||||
// be combined.
|
||||
virtual bool Passed(bool exit_status_ok) = 0; |
||||
|
||||
// Signals that the death test did not die as expected.
|
||||
virtual void Abort(AbortReason reason) = 0; |
||||
|
||||
// Returns a human-readable outcome message regarding the outcome of
|
||||
// the last death test.
|
||||
static const char* LastMessage(); |
||||
|
||||
static void set_last_death_test_message(const String& message); |
||||
|
||||
private: |
||||
// A string containing a description of the outcome of the last death test.
|
||||
static String last_death_test_message_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest); |
||||
}; |
||||
|
||||
// Factory interface for death tests. May be mocked out for testing.
|
||||
class DeathTestFactory { |
||||
public: |
||||
virtual ~DeathTestFactory() { } |
||||
virtual bool Create(const char* statement, const RE* regex, |
||||
const char* file, int line, DeathTest** test) = 0; |
||||
}; |
||||
|
||||
// A concrete DeathTestFactory implementation for normal use.
|
||||
class DefaultDeathTestFactory : public DeathTestFactory { |
||||
public: |
||||
virtual bool Create(const char* statement, const RE* regex, |
||||
const char* file, int line, DeathTest** test); |
||||
}; |
||||
|
||||
// Returns true if exit_status describes a process that was terminated
|
||||
// by a signal, or exited normally with a nonzero exit code.
|
||||
GTEST_API_ bool ExitedUnsuccessfully(int exit_status); |
||||
|
||||
// Traps C++ exceptions escaping statement and reports them as test
|
||||
// failures. Note that trapping SEH exceptions is not implemented here.
|
||||
# if GTEST_HAS_EXCEPTIONS |
||||
# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ |
||||
try { \
|
||||
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
|
||||
} catch (const ::std::exception& gtest_exception) { \
|
||||
fprintf(\
|
||||
stderr, \
|
||||
"\n%s: Caught std::exception-derived exception escaping the " \
|
||||
"death test statement. Exception message: %s\n", \
|
||||
::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
|
||||
gtest_exception.what()); \
|
||||
fflush(stderr); \
|
||||
death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
|
||||
} catch (...) { \
|
||||
death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
|
||||
} |
||||
|
||||
# else |
||||
# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ |
||||
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) |
||||
|
||||
# endif |
||||
|
||||
// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
|
||||
// ASSERT_EXIT*, and EXPECT_EXIT*.
|
||||
# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \ |
||||
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
|
||||
if (::testing::internal::AlwaysTrue()) { \
|
||||
const ::testing::internal::RE& gtest_regex = (regex); \
|
||||
::testing::internal::DeathTest* gtest_dt; \
|
||||
if (!::testing::internal::DeathTest::Create(#statement, >est_regex, \
|
||||
__FILE__, __LINE__, >est_dt)) { \
|
||||
goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
|
||||
} \
|
||||
if (gtest_dt != NULL) { \
|
||||
::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \
|
||||
gtest_dt_ptr(gtest_dt); \
|
||||
switch (gtest_dt->AssumeRole()) { \
|
||||
case ::testing::internal::DeathTest::OVERSEE_TEST: \
|
||||
if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \
|
||||
goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
|
||||
} \
|
||||
break; \
|
||||
case ::testing::internal::DeathTest::EXECUTE_TEST: { \
|
||||
::testing::internal::DeathTest::ReturnSentinel \
|
||||
gtest_sentinel(gtest_dt); \
|
||||
GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \
|
||||
gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
|
||||
break; \
|
||||
} \
|
||||
default: \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
} else \
|
||||
GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \
|
||||
fail(::testing::internal::DeathTest::LastMessage()) |
||||
// The symbol "fail" here expands to something into which a message
|
||||
// can be streamed.
|
||||
|
||||
// A class representing the parsed contents of the
|
||||
// --gtest_internal_run_death_test flag, as it existed when
|
||||
// RUN_ALL_TESTS was called.
|
||||
class InternalRunDeathTestFlag { |
||||
public: |
||||
InternalRunDeathTestFlag(const String& a_file, |
||||
int a_line, |
||||
int an_index, |
||||
int a_write_fd) |
||||
: file_(a_file), line_(a_line), index_(an_index), |
||||
write_fd_(a_write_fd) {} |
||||
|
||||
~InternalRunDeathTestFlag() { |
||||
if (write_fd_ >= 0) |
||||
posix::Close(write_fd_); |
||||
} |
||||
|
||||
String file() const { return file_; } |
||||
int line() const { return line_; } |
||||
int index() const { return index_; } |
||||
int write_fd() const { return write_fd_; } |
||||
|
||||
private: |
||||
String file_; |
||||
int line_; |
||||
int index_; |
||||
int write_fd_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag); |
||||
}; |
||||
|
||||
// Returns a newly created InternalRunDeathTestFlag object with fields
|
||||
// initialized from the GTEST_FLAG(internal_run_death_test) flag if
|
||||
// the flag is specified; otherwise returns NULL.
|
||||
InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag(); |
||||
|
||||
#else // GTEST_HAS_DEATH_TEST
|
||||
|
||||
// This macro is used for implementing macros such as
|
||||
// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
|
||||
// death tests are not supported. Those macros must compile on such systems
|
||||
// iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on
|
||||
// systems that support death tests. This allows one to write such a macro
|
||||
// on a system that does not support death tests and be sure that it will
|
||||
// compile on a death-test supporting system.
|
||||
//
|
||||
// Parameters:
|
||||
// statement - A statement that a macro such as EXPECT_DEATH would test
|
||||
// for program termination. This macro has to make sure this
|
||||
// statement is compiled but not executed, to ensure that
|
||||
// EXPECT_DEATH_IF_SUPPORTED compiles with a certain
|
||||
// parameter iff EXPECT_DEATH compiles with it.
|
||||
// regex - A regex that a macro such as EXPECT_DEATH would use to test
|
||||
// the output of statement. This parameter has to be
|
||||
// compiled but not evaluated by this macro, to ensure that
|
||||
// this macro only accepts expressions that a macro such as
|
||||
// EXPECT_DEATH would accept.
|
||||
// terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
|
||||
// and a return statement for ASSERT_DEATH_IF_SUPPORTED.
|
||||
// This ensures that ASSERT_DEATH_IF_SUPPORTED will not
|
||||
// compile inside functions where ASSERT_DEATH doesn't
|
||||
// compile.
|
||||
//
|
||||
// The branch that has an always false condition is used to ensure that
|
||||
// statement and regex are compiled (and thus syntactically correct) but
|
||||
// never executed. The unreachable code macro protects the terminator
|
||||
// statement from generating an 'unreachable code' warning in case
|
||||
// statement unconditionally returns or throws. The Message constructor at
|
||||
// the end allows the syntax of streaming additional messages into the
|
||||
// macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
|
||||
# define GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, terminator) \ |
||||
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
|
||||
if (::testing::internal::AlwaysTrue()) { \
|
||||
GTEST_LOG_(WARNING) \
|
||||
<< "Death tests are not supported on this platform.\n" \
|
||||
<< "Statement '" #statement "' cannot be verified."; \
|
||||
} else if (::testing::internal::AlwaysFalse()) { \
|
||||
::testing::internal::RE::PartialMatch(".*", (regex)); \
|
||||
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
|
||||
terminator; \
|
||||
} else \
|
||||
::testing::Message() |
||||
|
||||
#endif // GTEST_HAS_DEATH_TEST
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
|
@ -0,0 +1,210 @@
|
||||
// Copyright 2008, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: keith.ray@gmail.com (Keith Ray)
|
||||
//
|
||||
// Google Test filepath utilities
|
||||
//
|
||||
// This header file declares classes and functions used internally by
|
||||
// Google Test. They are subject to change without notice.
|
||||
//
|
||||
// This file is #included in <gtest/internal/gtest-internal.h>.
|
||||
// Do not include this header file separately!
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ |
||||
|
||||
#include "gtest/internal/gtest-string.h" |
||||
|
||||
namespace testing { |
||||
namespace internal { |
||||
|
||||
// FilePath - a class for file and directory pathname manipulation which
|
||||
// handles platform-specific conventions (like the pathname separator).
|
||||
// Used for helper functions for naming files in a directory for xml output.
|
||||
// Except for Set methods, all methods are const or static, which provides an
|
||||
// "immutable value object" -- useful for peace of mind.
|
||||
// A FilePath with a value ending in a path separator ("like/this/") represents
|
||||
// a directory, otherwise it is assumed to represent a file. In either case,
|
||||
// it may or may not represent an actual file or directory in the file system.
|
||||
// Names are NOT checked for syntax correctness -- no checking for illegal
|
||||
// characters, malformed paths, etc.
|
||||
|
||||
class GTEST_API_ FilePath { |
||||
public: |
||||
FilePath() : pathname_("") { } |
||||
FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { } |
||||
|
||||
explicit FilePath(const char* pathname) : pathname_(pathname) { |
||||
Normalize(); |
||||
} |
||||
|
||||
explicit FilePath(const String& pathname) : pathname_(pathname) { |
||||
Normalize(); |
||||
} |
||||
|
||||
FilePath& operator=(const FilePath& rhs) { |
||||
Set(rhs); |
||||
return *this; |
||||
} |
||||
|
||||
void Set(const FilePath& rhs) { |
||||
pathname_ = rhs.pathname_; |
||||
} |
||||
|
||||
String ToString() const { return pathname_; } |
||||
const char* c_str() const { return pathname_.c_str(); } |
||||
|
||||
// Returns the current working directory, or "" if unsuccessful.
|
||||
static FilePath GetCurrentDir(); |
||||
|
||||
// Given directory = "dir", base_name = "test", number = 0,
|
||||
// extension = "xml", returns "dir/test.xml". If number is greater
|
||||
// than zero (e.g., 12), returns "dir/test_12.xml".
|
||||
// On Windows platform, uses \ as the separator rather than /.
|
||||
static FilePath MakeFileName(const FilePath& directory, |
||||
const FilePath& base_name, |
||||
int number, |
||||
const char* extension); |
||||
|
||||
// Given directory = "dir", relative_path = "test.xml",
|
||||
// returns "dir/test.xml".
|
||||
// On Windows, uses \ as the separator rather than /.
|
||||
static FilePath ConcatPaths(const FilePath& directory, |
||||
const FilePath& relative_path); |
||||
|
||||
// Returns a pathname for a file that does not currently exist. The pathname
|
||||
// will be directory/base_name.extension or
|
||||
// directory/base_name_<number>.extension if directory/base_name.extension
|
||||
// already exists. The number will be incremented until a pathname is found
|
||||
// that does not already exist.
|
||||
// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
|
||||
// There could be a race condition if two or more processes are calling this
|
||||
// function at the same time -- they could both pick the same filename.
|
||||
static FilePath GenerateUniqueFileName(const FilePath& directory, |
||||
const FilePath& base_name, |
||||
const char* extension); |
||||
|
||||
// Returns true iff the path is NULL or "".
|
||||
bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; } |
||||
|
||||
// If input name has a trailing separator character, removes it and returns
|
||||
// the name, otherwise return the name string unmodified.
|
||||
// On Windows platform, uses \ as the separator, other platforms use /.
|
||||
FilePath RemoveTrailingPathSeparator() const; |
||||
|
||||
// Returns a copy of the FilePath with the directory part removed.
|
||||
// Example: FilePath("path/to/file").RemoveDirectoryName() returns
|
||||
// FilePath("file"). If there is no directory part ("just_a_file"), it returns
|
||||
// the FilePath unmodified. If there is no file part ("just_a_dir/") it
|
||||
// returns an empty FilePath ("").
|
||||
// On Windows platform, '\' is the path separator, otherwise it is '/'.
|
||||
FilePath RemoveDirectoryName() const; |
||||
|
||||
// RemoveFileName returns the directory path with the filename removed.
|
||||
// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
|
||||
// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
|
||||
// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
|
||||
// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
|
||||
// On Windows platform, '\' is the path separator, otherwise it is '/'.
|
||||
FilePath RemoveFileName() const; |
||||
|
||||
// Returns a copy of the FilePath with the case-insensitive extension removed.
|
||||
// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
|
||||
// FilePath("dir/file"). If a case-insensitive extension is not
|
||||
// found, returns a copy of the original FilePath.
|
||||
FilePath RemoveExtension(const char* extension) const; |
||||
|
||||
// Creates directories so that path exists. Returns true if successful or if
|
||||
// the directories already exist; returns false if unable to create
|
||||
// directories for any reason. Will also return false if the FilePath does
|
||||
// not represent a directory (that is, it doesn't end with a path separator).
|
||||
bool CreateDirectoriesRecursively() const; |
||||
|
||||
// Create the directory so that path exists. Returns true if successful or
|
||||
// if the directory already exists; returns false if unable to create the
|
||||
// directory for any reason, including if the parent directory does not
|
||||
// exist. Not named "CreateDirectory" because that's a macro on Windows.
|
||||
bool CreateFolder() const; |
||||
|
||||
// Returns true if FilePath describes something in the file-system,
|
||||
// either a file, directory, or whatever, and that something exists.
|
||||
bool FileOrDirectoryExists() const; |
||||
|
||||
// Returns true if pathname describes a directory in the file-system
|
||||
// that exists.
|
||||
bool DirectoryExists() const; |
||||
|
||||
// Returns true if FilePath ends with a path separator, which indicates that
|
||||
// it is intended to represent a directory. Returns false otherwise.
|
||||
// This does NOT check that a directory (or file) actually exists.
|
||||
bool IsDirectory() const; |
||||
|
||||
// Returns true if pathname describes a root directory. (Windows has one
|
||||
// root directory per disk drive.)
|
||||
bool IsRootDirectory() const; |
||||
|
||||
// Returns true if pathname describes an absolute path.
|
||||
bool IsAbsolutePath() const; |
||||
|
||||
private: |
||||
// Replaces multiple consecutive separators with a single separator.
|
||||
// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
|
||||
// redundancies that might be in a pathname involving "." or "..".
|
||||
//
|
||||
// A pathname with multiple consecutive separators may occur either through
|
||||
// user error or as a result of some scripts or APIs that generate a pathname
|
||||
// with a trailing separator. On other platforms the same API or script
|
||||
// may NOT generate a pathname with a trailing "/". Then elsewhere that
|
||||
// pathname may have another "/" and pathname components added to it,
|
||||
// without checking for the separator already being there.
|
||||
// The script language and operating system may allow paths like "foo//bar"
|
||||
// but some of the functions in FilePath will not handle that correctly. In
|
||||
// particular, RemoveTrailingPathSeparator() only removes one separator, and
|
||||
// it is called in CreateDirectoriesRecursively() assuming that it will change
|
||||
// a pathname from directory syntax (trailing separator) to filename syntax.
|
||||
//
|
||||
// On Windows this method also replaces the alternate path separator '/' with
|
||||
// the primary path separator '\\', so that for example "bar\\/\\foo" becomes
|
||||
// "bar\\foo".
|
||||
|
||||
void Normalize(); |
||||
|
||||
// Returns a pointer to the last occurence of a valid path separator in
|
||||
// the FilePath. On Windows, for example, both '/' and '\' are valid path
|
||||
// separators. Returns NULL if no path separator was found.
|
||||
const char* FindLastPathSeparator() const; |
||||
|
||||
String pathname_; |
||||
}; // class FilePath
|
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,233 @@
|
||||
// Copyright 2003 Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: Dan Egnor (egnor@google.com)
|
||||
//
|
||||
// A "smart" pointer type with reference tracking. Every pointer to a
|
||||
// particular object is kept on a circular linked list. When the last pointer
|
||||
// to an object is destroyed or reassigned, the object is deleted.
|
||||
//
|
||||
// Used properly, this deletes the object when the last reference goes away.
|
||||
// There are several caveats:
|
||||
// - Like all reference counting schemes, cycles lead to leaks.
|
||||
// - Each smart pointer is actually two pointers (8 bytes instead of 4).
|
||||
// - Every time a pointer is assigned, the entire list of pointers to that
|
||||
// object is traversed. This class is therefore NOT SUITABLE when there
|
||||
// will often be more than two or three pointers to a particular object.
|
||||
// - References are only tracked as long as linked_ptr<> objects are copied.
|
||||
// If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
|
||||
// will happen (double deletion).
|
||||
//
|
||||
// A good use of this class is storing object references in STL containers.
|
||||
// You can safely put linked_ptr<> in a vector<>.
|
||||
// Other uses may not be as good.
|
||||
//
|
||||
// Note: If you use an incomplete type with linked_ptr<>, the class
|
||||
// *containing* linked_ptr<> must have a constructor and destructor (even
|
||||
// if they do nothing!).
|
||||
//
|
||||
// Bill Gibbons suggested we use something like this.
|
||||
//
|
||||
// Thread Safety:
|
||||
// Unlike other linked_ptr implementations, in this implementation
|
||||
// a linked_ptr object is thread-safe in the sense that:
|
||||
// - it's safe to copy linked_ptr objects concurrently,
|
||||
// - it's safe to copy *from* a linked_ptr and read its underlying
|
||||
// raw pointer (e.g. via get()) concurrently, and
|
||||
// - it's safe to write to two linked_ptrs that point to the same
|
||||
// shared object concurrently.
|
||||
// TODO(wan@google.com): rename this to safe_linked_ptr to avoid
|
||||
// confusion with normal linked_ptr.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ |
||||
|
||||
#include <stdlib.h> |
||||
#include <assert.h> |
||||
|
||||
#include "gtest/internal/gtest-port.h" |
||||
|
||||
namespace testing { |
||||
namespace internal { |
||||
|
||||
// Protects copying of all linked_ptr objects.
|
||||
GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex); |
||||
|
||||
// This is used internally by all instances of linked_ptr<>. It needs to be
|
||||
// a non-template class because different types of linked_ptr<> can refer to
|
||||
// the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
|
||||
// So, it needs to be possible for different types of linked_ptr to participate
|
||||
// in the same circular linked list, so we need a single class type here.
|
||||
//
|
||||
// DO NOT USE THIS CLASS DIRECTLY YOURSELF. Use linked_ptr<T>.
|
||||
class linked_ptr_internal { |
||||
public: |
||||
// Create a new circle that includes only this instance.
|
||||
void join_new() { |
||||
next_ = this; |
||||
} |
||||
|
||||
// Many linked_ptr operations may change p.link_ for some linked_ptr
|
||||
// variable p in the same circle as this object. Therefore we need
|
||||
// to prevent two such operations from occurring concurrently.
|
||||
//
|
||||
// Note that different types of linked_ptr objects can coexist in a
|
||||
// circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and
|
||||
// linked_ptr<Derived2>). Therefore we must use a single mutex to
|
||||
// protect all linked_ptr objects. This can create serious
|
||||
// contention in production code, but is acceptable in a testing
|
||||
// framework.
|
||||
|
||||
// Join an existing circle.
|
||||
// L < g_linked_ptr_mutex
|
||||
void join(linked_ptr_internal const* ptr) { |
||||
MutexLock lock(&g_linked_ptr_mutex); |
||||
|
||||
linked_ptr_internal const* p = ptr; |
||||
while (p->next_ != ptr) p = p->next_; |
||||
p->next_ = this; |
||||
next_ = ptr; |
||||
} |
||||
|
||||
// Leave whatever circle we're part of. Returns true if we were the
|
||||
// last member of the circle. Once this is done, you can join() another.
|
||||
// L < g_linked_ptr_mutex
|
||||
bool depart() { |
||||
MutexLock lock(&g_linked_ptr_mutex); |
||||
|
||||
if (next_ == this) return true; |
||||
linked_ptr_internal const* p = next_; |
||||
while (p->next_ != this) p = p->next_; |
||||
p->next_ = next_; |
||||
return false; |
||||
} |
||||
|
||||
private: |
||||
mutable linked_ptr_internal const* next_; |
||||
}; |
||||
|
||||
template <typename T> |
||||
class linked_ptr { |
||||
public: |
||||
typedef T element_type; |
||||
|
||||
// Take over ownership of a raw pointer. This should happen as soon as
|
||||
// possible after the object is created.
|
||||
explicit linked_ptr(T* ptr = NULL) { capture(ptr); } |
||||
~linked_ptr() { depart(); } |
||||
|
||||
// Copy an existing linked_ptr<>, adding ourselves to the list of references.
|
||||
template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } |
||||
linked_ptr(linked_ptr const& ptr) { // NOLINT
|
||||
assert(&ptr != this); |
||||
copy(&ptr); |
||||
} |
||||
|
||||
// Assignment releases the old value and acquires the new.
|
||||
template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) { |
||||
depart(); |
||||
copy(&ptr); |
||||
return *this; |
||||
} |
||||
|
||||
linked_ptr& operator=(linked_ptr const& ptr) { |
||||
if (&ptr != this) { |
||||
depart(); |
||||
copy(&ptr); |
||||
} |
||||
return *this; |
||||
} |
||||
|
||||
// Smart pointer members.
|
||||
void reset(T* ptr = NULL) { |
||||
depart(); |
||||
capture(ptr); |
||||
} |
||||
T* get() const { return value_; } |
||||
T* operator->() const { return value_; } |
||||
T& operator*() const { return *value_; } |
||||
|
||||
bool operator==(T* p) const { return value_ == p; } |
||||
bool operator!=(T* p) const { return value_ != p; } |
||||
template <typename U> |
||||
bool operator==(linked_ptr<U> const& ptr) const { |
||||
return value_ == ptr.get(); |
||||
} |
||||
template <typename U> |
||||
bool operator!=(linked_ptr<U> const& ptr) const { |
||||
return value_ != ptr.get(); |
||||
} |
||||
|
||||
private: |
||||
template <typename U> |
||||
friend class linked_ptr; |
||||
|
||||
T* value_; |
||||
linked_ptr_internal link_; |
||||
|
||||
void depart() { |
||||
if (link_.depart()) delete value_; |
||||
} |
||||
|
||||
void capture(T* ptr) { |
||||
value_ = ptr; |
||||
link_.join_new(); |
||||
} |
||||
|
||||
template <typename U> void copy(linked_ptr<U> const* ptr) { |
||||
value_ = ptr->get(); |
||||
if (value_) |
||||
link_.join(&ptr->link_); |
||||
else |
||||
link_.join_new(); |
||||
} |
||||
}; |
||||
|
||||
template<typename T> inline |
||||
bool operator==(T* ptr, const linked_ptr<T>& x) { |
||||
return ptr == x.get(); |
||||
} |
||||
|
||||
template<typename T> inline |
||||
bool operator!=(T* ptr, const linked_ptr<T>& x) { |
||||
return ptr != x.get(); |
||||
} |
||||
|
||||
// A function to convert T* into linked_ptr<T>
|
||||
// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation
|
||||
// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
|
||||
template <typename T> |
||||
linked_ptr<T> make_linked_ptr(T* ptr) { |
||||
return linked_ptr<T>(ptr); |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,301 @@
|
||||
$$ -*- mode: c++; -*- |
||||
$var n = 50 $$ Maximum length of Values arguments we want to support. |
||||
$var maxtuple = 10 $$ Maximum number of Combine arguments we want to support. |
||||
// Copyright 2008 Google Inc. |
||||
// All Rights Reserved. |
||||
// |
||||
// Redistribution and use in source and binary forms, with or without |
||||
// modification, are permitted provided that the following conditions are |
||||
// met: |
||||
// |
||||
// * Redistributions of source code must retain the above copyright |
||||
// notice, this list of conditions and the following disclaimer. |
||||
// * Redistributions in binary form must reproduce the above |
||||
// copyright notice, this list of conditions and the following disclaimer |
||||
// in the documentation and/or other materials provided with the |
||||
// distribution. |
||||
// * Neither the name of Google Inc. nor the names of its |
||||
// contributors may be used to endorse or promote products derived from |
||||
// this software without specific prior written permission. |
||||
// |
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
// |
||||
// Author: vladl@google.com (Vlad Losev) |
||||
|
||||
// Type and function utilities for implementing parameterized tests. |
||||
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND! |
||||
// |
||||
// Currently Google Test supports at most $n arguments in Values, |
||||
// and at most $maxtuple arguments in Combine. Please contact |
||||
// googletestframework@googlegroups.com if you need more. |
||||
// Please note that the number of arguments to Combine is limited |
||||
// by the maximum arity of the implementation of tr1::tuple which is |
||||
// currently set at $maxtuple. |
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ |
||||
|
||||
// scripts/fuse_gtest.py depends on gtest's own header being #included |
||||
// *unconditionally*. Therefore these #includes cannot be moved |
||||
// inside #if GTEST_HAS_PARAM_TEST. |
||||
#include "gtest/internal/gtest-param-util.h" |
||||
#include "gtest/internal/gtest-port.h" |
||||
|
||||
#if GTEST_HAS_PARAM_TEST |
||||
|
||||
namespace testing { |
||||
|
||||
// Forward declarations of ValuesIn(), which is implemented in |
||||
// include/gtest/gtest-param-test.h. |
||||
template <typename ForwardIterator> |
||||
internal::ParamGenerator< |
||||
typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type> |
||||
ValuesIn(ForwardIterator begin, ForwardIterator end); |
||||
|
||||
template <typename T, size_t N> |
||||
internal::ParamGenerator<T> ValuesIn(const T (&array)[N]); |
||||
|
||||
template <class Container> |
||||
internal::ParamGenerator<typename Container::value_type> ValuesIn( |
||||
const Container& container); |
||||
|
||||
namespace internal { |
||||
|
||||
// Used in the Values() function to provide polymorphic capabilities. |
||||
template <typename T1> |
||||
class ValueArray1 { |
||||
public: |
||||
explicit ValueArray1(T1 v1) : v1_(v1) {} |
||||
|
||||
template <typename T> |
||||
operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); } |
||||
|
||||
private: |
||||
// No implementation - assignment is unsupported. |
||||
void operator=(const ValueArray1& other); |
||||
|
||||
const T1 v1_; |
||||
}; |
||||
|
||||
$range i 2..n |
||||
$for i [[ |
||||
$range j 1..i |
||||
|
||||
template <$for j, [[typename T$j]]> |
||||
class ValueArray$i { |
||||
public: |
||||
ValueArray$i($for j, [[T$j v$j]]) : $for j, [[v$(j)_(v$j)]] {} |
||||
|
||||
template <typename T> |
||||
operator ParamGenerator<T>() const { |
||||
const T array[] = {$for j, [[v$(j)_]]}; |
||||
return ValuesIn(array); |
||||
} |
||||
|
||||
private: |
||||
// No implementation - assignment is unsupported. |
||||
void operator=(const ValueArray$i& other); |
||||
|
||||
$for j [[ |
||||
|
||||
const T$j v$(j)_; |
||||
]] |
||||
|
||||
}; |
||||
|
||||
]] |
||||
|
||||
# if GTEST_HAS_COMBINE |
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
||||
// |
||||
// Generates values from the Cartesian product of values produced |
||||
// by the argument generators. |
||||
// |
||||
$range i 2..maxtuple |
||||
$for i [[ |
||||
$range j 1..i |
||||
$range k 2..i |
||||
|
||||
template <$for j, [[typename T$j]]> |
||||
class CartesianProductGenerator$i |
||||
: public ParamGeneratorInterface< ::std::tr1::tuple<$for j, [[T$j]]> > { |
||||
public: |
||||
typedef ::std::tr1::tuple<$for j, [[T$j]]> ParamType; |
||||
|
||||
CartesianProductGenerator$i($for j, [[const ParamGenerator<T$j>& g$j]]) |
||||
: $for j, [[g$(j)_(g$j)]] {} |
||||
virtual ~CartesianProductGenerator$i() {} |
||||
|
||||
virtual ParamIteratorInterface<ParamType>* Begin() const { |
||||
return new Iterator(this, $for j, [[g$(j)_, g$(j)_.begin()]]); |
||||
} |
||||
virtual ParamIteratorInterface<ParamType>* End() const { |
||||
return new Iterator(this, $for j, [[g$(j)_, g$(j)_.end()]]); |
||||
} |
||||
|
||||
private: |
||||
class Iterator : public ParamIteratorInterface<ParamType> { |
||||
public: |
||||
Iterator(const ParamGeneratorInterface<ParamType>* base, $for j, [[ |
||||
|
||||
const ParamGenerator<T$j>& g$j, |
||||
const typename ParamGenerator<T$j>::iterator& current$(j)]]) |
||||
: base_(base), |
||||
$for j, [[ |
||||
|
||||
begin$(j)_(g$j.begin()), end$(j)_(g$j.end()), current$(j)_(current$j) |
||||
]] { |
||||
ComputeCurrentValue(); |
||||
} |
||||
virtual ~Iterator() {} |
||||
|
||||
virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { |
||||
return base_; |
||||
} |
||||
// Advance should not be called on beyond-of-range iterators |
||||
// so no component iterators must be beyond end of range, either. |
||||
virtual void Advance() { |
||||
assert(!AtEnd()); |
||||
++current$(i)_; |
||||
|
||||
$for k [[ |
||||
if (current$(i+2-k)_ == end$(i+2-k)_) { |
||||
current$(i+2-k)_ = begin$(i+2-k)_; |
||||
++current$(i+2-k-1)_; |
||||
} |
||||
|
||||
]] |
||||
ComputeCurrentValue(); |
||||
} |
||||
virtual ParamIteratorInterface<ParamType>* Clone() const { |
||||
return new Iterator(*this); |
||||
} |
||||
virtual const ParamType* Current() const { return ¤t_value_; } |
||||
virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { |
||||
// Having the same base generator guarantees that the other |
||||
// iterator is of the same type and we can downcast. |
||||
GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) |
||||
<< "The program attempted to compare iterators " |
||||
<< "from different generators." << std::endl; |
||||
const Iterator* typed_other = |
||||
CheckedDowncastToActualType<const Iterator>(&other); |
||||
// We must report iterators equal if they both point beyond their |
||||
// respective ranges. That can happen in a variety of fashions, |
||||
// so we have to consult AtEnd(). |
||||
return (AtEnd() && typed_other->AtEnd()) || |
||||
($for j && [[ |
||||
|
||||
current$(j)_ == typed_other->current$(j)_ |
||||
]]); |
||||
} |
||||
|
||||
private: |
||||
Iterator(const Iterator& other) |
||||
: base_(other.base_), $for j, [[ |
||||
|
||||
begin$(j)_(other.begin$(j)_), |
||||
end$(j)_(other.end$(j)_), |
||||
current$(j)_(other.current$(j)_) |
||||
]] { |
||||
ComputeCurrentValue(); |
||||
} |
||||
|
||||
void ComputeCurrentValue() { |
||||
if (!AtEnd()) |
||||
current_value_ = ParamType($for j, [[*current$(j)_]]); |
||||
} |
||||
bool AtEnd() const { |
||||
// We must report iterator past the end of the range when either of the |
||||
// component iterators has reached the end of its range. |
||||
return |
||||
$for j || [[ |
||||
|
||||
current$(j)_ == end$(j)_ |
||||
]]; |
||||
} |
||||
|
||||
// No implementation - assignment is unsupported. |
||||
void operator=(const Iterator& other); |
||||
|
||||
const ParamGeneratorInterface<ParamType>* const base_; |
||||
// begin[i]_ and end[i]_ define the i-th range that Iterator traverses. |
||||
// current[i]_ is the actual traversing iterator. |
||||
$for j [[ |
||||
|
||||
const typename ParamGenerator<T$j>::iterator begin$(j)_; |
||||
const typename ParamGenerator<T$j>::iterator end$(j)_; |
||||
typename ParamGenerator<T$j>::iterator current$(j)_; |
||||
]] |
||||
|
||||
ParamType current_value_; |
||||
}; // class CartesianProductGenerator$i::Iterator |
||||
|
||||
// No implementation - assignment is unsupported. |
||||
void operator=(const CartesianProductGenerator$i& other); |
||||
|
||||
|
||||
$for j [[ |
||||
const ParamGenerator<T$j> g$(j)_; |
||||
|
||||
]] |
||||
}; // class CartesianProductGenerator$i |
||||
|
||||
|
||||
]] |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
||||
// |
||||
// Helper classes providing Combine() with polymorphic features. They allow |
||||
// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is |
||||
// convertible to U. |
||||
// |
||||
$range i 2..maxtuple |
||||
$for i [[ |
||||
$range j 1..i |
||||
|
||||
template <$for j, [[class Generator$j]]> |
||||
class CartesianProductHolder$i { |
||||
public: |
||||
CartesianProductHolder$i($for j, [[const Generator$j& g$j]]) |
||||
: $for j, [[g$(j)_(g$j)]] {} |
||||
template <$for j, [[typename T$j]]> |
||||
operator ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >() const { |
||||
return ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >( |
||||
new CartesianProductGenerator$i<$for j, [[T$j]]>( |
||||
$for j,[[ |
||||
|
||||
static_cast<ParamGenerator<T$j> >(g$(j)_) |
||||
]])); |
||||
} |
||||
|
||||
private: |
||||
// No implementation - assignment is unsupported. |
||||
void operator=(const CartesianProductHolder$i& other); |
||||
|
||||
|
||||
$for j [[ |
||||
const Generator$j g$(j)_; |
||||
|
||||
]] |
||||
}; // class CartesianProductHolder$i |
||||
|
||||
]] |
||||
|
||||
# endif // GTEST_HAS_COMBINE |
||||
|
||||
} // namespace internal |
||||
} // namespace testing |
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST |
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ |
@ -0,0 +1,619 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
|
||||
// Type and function utilities for implementing parameterized tests.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ |
||||
|
||||
#include <iterator> |
||||
#include <utility> |
||||
#include <vector> |
||||
|
||||
// scripts/fuse_gtest.py depends on gtest's own header being #included
|
||||
// *unconditionally*. Therefore these #includes cannot be moved
|
||||
// inside #if GTEST_HAS_PARAM_TEST.
|
||||
#include "gtest/internal/gtest-internal.h" |
||||
#include "gtest/internal/gtest-linked_ptr.h" |
||||
#include "gtest/internal/gtest-port.h" |
||||
#include "gtest/gtest-printers.h" |
||||
|
||||
#if GTEST_HAS_PARAM_TEST |
||||
|
||||
namespace testing { |
||||
namespace internal { |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Outputs a message explaining invalid registration of different
|
||||
// fixture class for the same test case. This may happen when
|
||||
// TEST_P macro is used to define two tests with the same name
|
||||
// but in different namespaces.
|
||||
GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name, |
||||
const char* file, int line); |
||||
|
||||
template <typename> class ParamGeneratorInterface; |
||||
template <typename> class ParamGenerator; |
||||
|
||||
// Interface for iterating over elements provided by an implementation
|
||||
// of ParamGeneratorInterface<T>.
|
||||
template <typename T> |
||||
class ParamIteratorInterface { |
||||
public: |
||||
virtual ~ParamIteratorInterface() {} |
||||
// A pointer to the base generator instance.
|
||||
// Used only for the purposes of iterator comparison
|
||||
// to make sure that two iterators belong to the same generator.
|
||||
virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0; |
||||
// Advances iterator to point to the next element
|
||||
// provided by the generator. The caller is responsible
|
||||
// for not calling Advance() on an iterator equal to
|
||||
// BaseGenerator()->End().
|
||||
virtual void Advance() = 0; |
||||
// Clones the iterator object. Used for implementing copy semantics
|
||||
// of ParamIterator<T>.
|
||||
virtual ParamIteratorInterface* Clone() const = 0; |
||||
// Dereferences the current iterator and provides (read-only) access
|
||||
// to the pointed value. It is the caller's responsibility not to call
|
||||
// Current() on an iterator equal to BaseGenerator()->End().
|
||||
// Used for implementing ParamGenerator<T>::operator*().
|
||||
virtual const T* Current() const = 0; |
||||
// Determines whether the given iterator and other point to the same
|
||||
// element in the sequence generated by the generator.
|
||||
// Used for implementing ParamGenerator<T>::operator==().
|
||||
virtual bool Equals(const ParamIteratorInterface& other) const = 0; |
||||
}; |
||||
|
||||
// Class iterating over elements provided by an implementation of
|
||||
// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
|
||||
// and implements the const forward iterator concept.
|
||||
template <typename T> |
||||
class ParamIterator { |
||||
public: |
||||
typedef T value_type; |
||||
typedef const T& reference; |
||||
typedef ptrdiff_t difference_type; |
||||
|
||||
// ParamIterator assumes ownership of the impl_ pointer.
|
||||
ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {} |
||||
ParamIterator& operator=(const ParamIterator& other) { |
||||
if (this != &other) |
||||
impl_.reset(other.impl_->Clone()); |
||||
return *this; |
||||
} |
||||
|
||||
const T& operator*() const { return *impl_->Current(); } |
||||
const T* operator->() const { return impl_->Current(); } |
||||
// Prefix version of operator++.
|
||||
ParamIterator& operator++() { |
||||
impl_->Advance(); |
||||
return *this; |
||||
} |
||||
// Postfix version of operator++.
|
||||
ParamIterator operator++(int /*unused*/) { |
||||
ParamIteratorInterface<T>* clone = impl_->Clone(); |
||||
impl_->Advance(); |
||||
return ParamIterator(clone); |
||||
} |
||||
bool operator==(const ParamIterator& other) const { |
||||
return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_); |
||||
} |
||||
bool operator!=(const ParamIterator& other) const { |
||||
return !(*this == other); |
||||
} |
||||
|
||||
private: |
||||
friend class ParamGenerator<T>; |
||||
explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {} |
||||
scoped_ptr<ParamIteratorInterface<T> > impl_; |
||||
}; |
||||
|
||||
// ParamGeneratorInterface<T> is the binary interface to access generators
|
||||
// defined in other translation units.
|
||||
template <typename T> |
||||
class ParamGeneratorInterface { |
||||
public: |
||||
typedef T ParamType; |
||||
|
||||
virtual ~ParamGeneratorInterface() {} |
||||
|
||||
// Generator interface definition
|
||||
virtual ParamIteratorInterface<T>* Begin() const = 0; |
||||
virtual ParamIteratorInterface<T>* End() const = 0; |
||||
}; |
||||
|
||||
// Wraps ParamGeneratorInterface<T> and provides general generator syntax
|
||||
// compatible with the STL Container concept.
|
||||
// This class implements copy initialization semantics and the contained
|
||||
// ParamGeneratorInterface<T> instance is shared among all copies
|
||||
// of the original object. This is possible because that instance is immutable.
|
||||
template<typename T> |
||||
class ParamGenerator { |
||||
public: |
||||
typedef ParamIterator<T> iterator; |
||||
|
||||
explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {} |
||||
ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {} |
||||
|
||||
ParamGenerator& operator=(const ParamGenerator& other) { |
||||
impl_ = other.impl_; |
||||
return *this; |
||||
} |
||||
|
||||
iterator begin() const { return iterator(impl_->Begin()); } |
||||
iterator end() const { return iterator(impl_->End()); } |
||||
|
||||
private: |
||||
linked_ptr<const ParamGeneratorInterface<T> > impl_; |
||||
}; |
||||
|
||||
// Generates values from a range of two comparable values. Can be used to
|
||||
// generate sequences of user-defined types that implement operator+() and
|
||||
// operator<().
|
||||
// This class is used in the Range() function.
|
||||
template <typename T, typename IncrementT> |
||||
class RangeGenerator : public ParamGeneratorInterface<T> { |
||||
public: |
||||
RangeGenerator(T begin, T end, IncrementT step) |
||||
: begin_(begin), end_(end), |
||||
step_(step), end_index_(CalculateEndIndex(begin, end, step)) {} |
||||
virtual ~RangeGenerator() {} |
||||
|
||||
virtual ParamIteratorInterface<T>* Begin() const { |
||||
return new Iterator(this, begin_, 0, step_); |
||||
} |
||||
virtual ParamIteratorInterface<T>* End() const { |
||||
return new Iterator(this, end_, end_index_, step_); |
||||
} |
||||
|
||||
private: |
||||
class Iterator : public ParamIteratorInterface<T> { |
||||
public: |
||||
Iterator(const ParamGeneratorInterface<T>* base, T value, int index, |
||||
IncrementT step) |
||||
: base_(base), value_(value), index_(index), step_(step) {} |
||||
virtual ~Iterator() {} |
||||
|
||||
virtual const ParamGeneratorInterface<T>* BaseGenerator() const { |
||||
return base_; |
||||
} |
||||
virtual void Advance() { |
||||
value_ = value_ + step_; |
||||
index_++; |
||||
} |
||||
virtual ParamIteratorInterface<T>* Clone() const { |
||||
return new Iterator(*this); |
||||
} |
||||
virtual const T* Current() const { return &value_; } |
||||
virtual bool Equals(const ParamIteratorInterface<T>& other) const { |
||||
// Having the same base generator guarantees that the other
|
||||
// iterator is of the same type and we can downcast.
|
||||
GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) |
||||
<< "The program attempted to compare iterators " |
||||
<< "from different generators." << std::endl; |
||||
const int other_index = |
||||
CheckedDowncastToActualType<const Iterator>(&other)->index_; |
||||
return index_ == other_index; |
||||
} |
||||
|
||||
private: |
||||
Iterator(const Iterator& other) |
||||
: ParamIteratorInterface<T>(), |
||||
base_(other.base_), value_(other.value_), index_(other.index_), |
||||
step_(other.step_) {} |
||||
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const Iterator& other); |
||||
|
||||
const ParamGeneratorInterface<T>* const base_; |
||||
T value_; |
||||
int index_; |
||||
const IncrementT step_; |
||||
}; // class RangeGenerator::Iterator
|
||||
|
||||
static int CalculateEndIndex(const T& begin, |
||||
const T& end, |
||||
const IncrementT& step) { |
||||
int end_index = 0; |
||||
for (T i = begin; i < end; i = i + step) |
||||
end_index++; |
||||
return end_index; |
||||
} |
||||
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const RangeGenerator& other); |
||||
|
||||
const T begin_; |
||||
const T end_; |
||||
const IncrementT step_; |
||||
// The index for the end() iterator. All the elements in the generated
|
||||
// sequence are indexed (0-based) to aid iterator comparison.
|
||||
const int end_index_; |
||||
}; // class RangeGenerator
|
||||
|
||||
|
||||
// Generates values from a pair of STL-style iterators. Used in the
|
||||
// ValuesIn() function. The elements are copied from the source range
|
||||
// since the source can be located on the stack, and the generator
|
||||
// is likely to persist beyond that stack frame.
|
||||
template <typename T> |
||||
class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> { |
||||
public: |
||||
template <typename ForwardIterator> |
||||
ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end) |
||||
: container_(begin, end) {} |
||||
virtual ~ValuesInIteratorRangeGenerator() {} |
||||
|
||||
virtual ParamIteratorInterface<T>* Begin() const { |
||||
return new Iterator(this, container_.begin()); |
||||
} |
||||
virtual ParamIteratorInterface<T>* End() const { |
||||
return new Iterator(this, container_.end()); |
||||
} |
||||
|
||||
private: |
||||
typedef typename ::std::vector<T> ContainerType; |
||||
|
||||
class Iterator : public ParamIteratorInterface<T> { |
||||
public: |
||||
Iterator(const ParamGeneratorInterface<T>* base, |
||||
typename ContainerType::const_iterator iterator) |
||||
: base_(base), iterator_(iterator) {} |
||||
virtual ~Iterator() {} |
||||
|
||||
virtual const ParamGeneratorInterface<T>* BaseGenerator() const { |
||||
return base_; |
||||
} |
||||
virtual void Advance() { |
||||
++iterator_; |
||||
value_.reset(); |
||||
} |
||||
virtual ParamIteratorInterface<T>* Clone() const { |
||||
return new Iterator(*this); |
||||
} |
||||
// We need to use cached value referenced by iterator_ because *iterator_
|
||||
// can return a temporary object (and of type other then T), so just
|
||||
// having "return &*iterator_;" doesn't work.
|
||||
// value_ is updated here and not in Advance() because Advance()
|
||||
// can advance iterator_ beyond the end of the range, and we cannot
|
||||
// detect that fact. The client code, on the other hand, is
|
||||
// responsible for not calling Current() on an out-of-range iterator.
|
||||
virtual const T* Current() const { |
||||
if (value_.get() == NULL) |
||||
value_.reset(new T(*iterator_)); |
||||
return value_.get(); |
||||
} |
||||
virtual bool Equals(const ParamIteratorInterface<T>& other) const { |
||||
// Having the same base generator guarantees that the other
|
||||
// iterator is of the same type and we can downcast.
|
||||
GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) |
||||
<< "The program attempted to compare iterators " |
||||
<< "from different generators." << std::endl; |
||||
return iterator_ == |
||||
CheckedDowncastToActualType<const Iterator>(&other)->iterator_; |
||||
} |
||||
|
||||
private: |
||||
Iterator(const Iterator& other) |
||||
// The explicit constructor call suppresses a false warning
|
||||
// emitted by gcc when supplied with the -Wextra option.
|
||||
: ParamIteratorInterface<T>(), |
||||
base_(other.base_), |
||||
iterator_(other.iterator_) {} |
||||
|
||||
const ParamGeneratorInterface<T>* const base_; |
||||
typename ContainerType::const_iterator iterator_; |
||||
// A cached value of *iterator_. We keep it here to allow access by
|
||||
// pointer in the wrapping iterator's operator->().
|
||||
// value_ needs to be mutable to be accessed in Current().
|
||||
// Use of scoped_ptr helps manage cached value's lifetime,
|
||||
// which is bound by the lifespan of the iterator itself.
|
||||
mutable scoped_ptr<const T> value_; |
||||
}; // class ValuesInIteratorRangeGenerator::Iterator
|
||||
|
||||
// No implementation - assignment is unsupported.
|
||||
void operator=(const ValuesInIteratorRangeGenerator& other); |
||||
|
||||
const ContainerType container_; |
||||
}; // class ValuesInIteratorRangeGenerator
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// Stores a parameter value and later creates tests parameterized with that
|
||||
// value.
|
||||
template <class TestClass> |
||||
class ParameterizedTestFactory : public TestFactoryBase { |
||||
public: |
||||
typedef typename TestClass::ParamType ParamType; |
||||
explicit ParameterizedTestFactory(ParamType parameter) : |
||||
parameter_(parameter) {} |
||||
virtual Test* CreateTest() { |
||||
TestClass::SetParam(¶meter_); |
||||
return new TestClass(); |
||||
} |
||||
|
||||
private: |
||||
const ParamType parameter_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory); |
||||
}; |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// TestMetaFactoryBase is a base class for meta-factories that create
|
||||
// test factories for passing into MakeAndRegisterTestInfo function.
|
||||
template <class ParamType> |
||||
class TestMetaFactoryBase { |
||||
public: |
||||
virtual ~TestMetaFactoryBase() {} |
||||
|
||||
virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0; |
||||
}; |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// TestMetaFactory creates test factories for passing into
|
||||
// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
|
||||
// ownership of test factory pointer, same factory object cannot be passed
|
||||
// into that method twice. But ParameterizedTestCaseInfo is going to call
|
||||
// it for each Test/Parameter value combination. Thus it needs meta factory
|
||||
// creator class.
|
||||
template <class TestCase> |
||||
class TestMetaFactory |
||||
: public TestMetaFactoryBase<typename TestCase::ParamType> { |
||||
public: |
||||
typedef typename TestCase::ParamType ParamType; |
||||
|
||||
TestMetaFactory() {} |
||||
|
||||
virtual TestFactoryBase* CreateTestFactory(ParamType parameter) { |
||||
return new ParameterizedTestFactory<TestCase>(parameter); |
||||
} |
||||
|
||||
private: |
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory); |
||||
}; |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// ParameterizedTestCaseInfoBase is a generic interface
|
||||
// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
|
||||
// accumulates test information provided by TEST_P macro invocations
|
||||
// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
|
||||
// and uses that information to register all resulting test instances
|
||||
// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
|
||||
// a collection of pointers to the ParameterizedTestCaseInfo objects
|
||||
// and calls RegisterTests() on each of them when asked.
|
||||
class ParameterizedTestCaseInfoBase { |
||||
public: |
||||
virtual ~ParameterizedTestCaseInfoBase() {} |
||||
|
||||
// Base part of test case name for display purposes.
|
||||
virtual const string& GetTestCaseName() const = 0; |
||||
// Test case id to verify identity.
|
||||
virtual TypeId GetTestCaseTypeId() const = 0; |
||||
// UnitTest class invokes this method to register tests in this
|
||||
// test case right before running them in RUN_ALL_TESTS macro.
|
||||
// This method should not be called more then once on any single
|
||||
// instance of a ParameterizedTestCaseInfoBase derived class.
|
||||
virtual void RegisterTests() = 0; |
||||
|
||||
protected: |
||||
ParameterizedTestCaseInfoBase() {} |
||||
|
||||
private: |
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase); |
||||
}; |
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
|
||||
// macro invocations for a particular test case and generators
|
||||
// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
|
||||
// test case. It registers tests with all values generated by all
|
||||
// generators when asked.
|
||||
template <class TestCase> |
||||
class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase { |
||||
public: |
||||
// ParamType and GeneratorCreationFunc are private types but are required
|
||||
// for declarations of public methods AddTestPattern() and
|
||||
// AddTestCaseInstantiation().
|
||||
typedef typename TestCase::ParamType ParamType; |
||||
// A function that returns an instance of appropriate generator type.
|
||||
typedef ParamGenerator<ParamType>(GeneratorCreationFunc)(); |
||||
|
||||
explicit ParameterizedTestCaseInfo(const char* name) |
||||
: test_case_name_(name) {} |
||||
|
||||
// Test case base name for display purposes.
|
||||
virtual const string& GetTestCaseName() const { return test_case_name_; } |
||||
// Test case id to verify identity.
|
||||
virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); } |
||||
// TEST_P macro uses AddTestPattern() to record information
|
||||
// about a single test in a LocalTestInfo structure.
|
||||
// test_case_name is the base name of the test case (without invocation
|
||||
// prefix). test_base_name is the name of an individual test without
|
||||
// parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
|
||||
// test case base name and DoBar is test base name.
|
||||
void AddTestPattern(const char* test_case_name, |
||||
const char* test_base_name, |
||||
TestMetaFactoryBase<ParamType>* meta_factory) { |
||||
tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name, |
||||
test_base_name, |
||||
meta_factory))); |
||||
} |
||||
// INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
|
||||
// about a generator.
|
||||
int AddTestCaseInstantiation(const string& instantiation_name, |
||||
GeneratorCreationFunc* func, |
||||
const char* /* file */, |
||||
int /* line */) { |
||||
instantiations_.push_back(::std::make_pair(instantiation_name, func)); |
||||
return 0; // Return value used only to run this method in namespace scope.
|
||||
} |
||||
// UnitTest class invokes this method to register tests in this test case
|
||||
// test cases right before running tests in RUN_ALL_TESTS macro.
|
||||
// This method should not be called more then once on any single
|
||||
// instance of a ParameterizedTestCaseInfoBase derived class.
|
||||
// UnitTest has a guard to prevent from calling this method more then once.
|
||||
virtual void RegisterTests() { |
||||
for (typename TestInfoContainer::iterator test_it = tests_.begin(); |
||||
test_it != tests_.end(); ++test_it) { |
||||
linked_ptr<TestInfo> test_info = *test_it; |
||||
for (typename InstantiationContainer::iterator gen_it = |
||||
instantiations_.begin(); gen_it != instantiations_.end(); |
||||
++gen_it) { |
||||
const string& instantiation_name = gen_it->first; |
||||
ParamGenerator<ParamType> generator((*gen_it->second)()); |
||||
|
||||
Message test_case_name_stream; |
||||
if ( !instantiation_name.empty() ) |
||||
test_case_name_stream << instantiation_name << "/"; |
||||
test_case_name_stream << test_info->test_case_base_name; |
||||
|
||||
int i = 0; |
||||
for (typename ParamGenerator<ParamType>::iterator param_it = |
||||
generator.begin(); |
||||
param_it != generator.end(); ++param_it, ++i) { |
||||
Message test_name_stream; |
||||
test_name_stream << test_info->test_base_name << "/" << i; |
||||
MakeAndRegisterTestInfo( |
||||
test_case_name_stream.GetString().c_str(), |
||||
test_name_stream.GetString().c_str(), |
||||
NULL, // No type parameter.
|
||||
PrintToString(*param_it).c_str(), |
||||
GetTestCaseTypeId(), |
||||
TestCase::SetUpTestCase, |
||||
TestCase::TearDownTestCase, |
||||
test_info->test_meta_factory->CreateTestFactory(*param_it)); |
||||
} // for param_it
|
||||
} // for gen_it
|
||||
} // for test_it
|
||||
} // RegisterTests
|
||||
|
||||
private: |
||||
// LocalTestInfo structure keeps information about a single test registered
|
||||
// with TEST_P macro.
|
||||
struct TestInfo { |
||||
TestInfo(const char* a_test_case_base_name, |
||||
const char* a_test_base_name, |
||||
TestMetaFactoryBase<ParamType>* a_test_meta_factory) : |
||||
test_case_base_name(a_test_case_base_name), |
||||
test_base_name(a_test_base_name), |
||||
test_meta_factory(a_test_meta_factory) {} |
||||
|
||||
const string test_case_base_name; |
||||
const string test_base_name; |
||||
const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory; |
||||
}; |
||||
typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer; |
||||
// Keeps pairs of <Instantiation name, Sequence generator creation function>
|
||||
// received from INSTANTIATE_TEST_CASE_P macros.
|
||||
typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> > |
||||
InstantiationContainer; |
||||
|
||||
const string test_case_name_; |
||||
TestInfoContainer tests_; |
||||
InstantiationContainer instantiations_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo); |
||||
}; // class ParameterizedTestCaseInfo
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
//
|
||||
// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
|
||||
// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
|
||||
// macros use it to locate their corresponding ParameterizedTestCaseInfo
|
||||
// descriptors.
|
||||
class ParameterizedTestCaseRegistry { |
||||
public: |
||||
ParameterizedTestCaseRegistry() {} |
||||
~ParameterizedTestCaseRegistry() { |
||||
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); |
||||
it != test_case_infos_.end(); ++it) { |
||||
delete *it; |
||||
} |
||||
} |
||||
|
||||
// Looks up or creates and returns a structure containing information about
|
||||
// tests and instantiations of a particular test case.
|
||||
template <class TestCase> |
||||
ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder( |
||||
const char* test_case_name, |
||||
const char* file, |
||||
int line) { |
||||
ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL; |
||||
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); |
||||
it != test_case_infos_.end(); ++it) { |
||||
if ((*it)->GetTestCaseName() == test_case_name) { |
||||
if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) { |
||||
// Complain about incorrect usage of Google Test facilities
|
||||
// and terminate the program since we cannot guaranty correct
|
||||
// test case setup and tear-down in this case.
|
||||
ReportInvalidTestCaseType(test_case_name, file, line); |
||||
posix::Abort(); |
||||
} else { |
||||
// At this point we are sure that the object we found is of the same
|
||||
// type we are looking for, so we downcast it to that type
|
||||
// without further checks.
|
||||
typed_test_info = CheckedDowncastToActualType< |
||||
ParameterizedTestCaseInfo<TestCase> >(*it); |
||||
} |
||||
break; |
||||
} |
||||
} |
||||
if (typed_test_info == NULL) { |
||||
typed_test_info = new ParameterizedTestCaseInfo<TestCase>(test_case_name); |
||||
test_case_infos_.push_back(typed_test_info); |
||||
} |
||||
return typed_test_info; |
||||
} |
||||
void RegisterTests() { |
||||
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); |
||||
it != test_case_infos_.end(); ++it) { |
||||
(*it)->RegisterTests(); |
||||
} |
||||
} |
||||
|
||||
private: |
||||
typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer; |
||||
|
||||
TestCaseInfoContainer test_case_infos_; |
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry); |
||||
}; |
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,350 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
|
||||
//
|
||||
// The Google C++ Testing Framework (Google Test)
|
||||
//
|
||||
// This header file declares the String class and functions used internally by
|
||||
// Google Test. They are subject to change without notice. They should not used
|
||||
// by code external to Google Test.
|
||||
//
|
||||
// This header file is #included by <gtest/internal/gtest-internal.h>.
|
||||
// It should not be #included by other files.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ |
||||
|
||||
#ifdef __BORLANDC__ |
||||
// string.h is not guaranteed to provide strcpy on C++ Builder.
|
||||
# include <mem.h> |
||||
#endif |
||||
|
||||
#include <string.h> |
||||
#include "gtest/internal/gtest-port.h" |
||||
|
||||
#include <string> |
||||
|
||||
namespace testing { |
||||
namespace internal { |
||||
|
||||
// String - a UTF-8 string class.
|
||||
//
|
||||
// For historic reasons, we don't use std::string.
|
||||
//
|
||||
// TODO(wan@google.com): replace this class with std::string or
|
||||
// implement it in terms of the latter.
|
||||
//
|
||||
// Note that String can represent both NULL and the empty string,
|
||||
// while std::string cannot represent NULL.
|
||||
//
|
||||
// NULL and the empty string are considered different. NULL is less
|
||||
// than anything (including the empty string) except itself.
|
||||
//
|
||||
// This class only provides minimum functionality necessary for
|
||||
// implementing Google Test. We do not intend to implement a full-fledged
|
||||
// string class here.
|
||||
//
|
||||
// Since the purpose of this class is to provide a substitute for
|
||||
// std::string on platforms where it cannot be used, we define a copy
|
||||
// constructor and assignment operators such that we don't need
|
||||
// conditional compilation in a lot of places.
|
||||
//
|
||||
// In order to make the representation efficient, the d'tor of String
|
||||
// is not virtual. Therefore DO NOT INHERIT FROM String.
|
||||
class GTEST_API_ String { |
||||
public: |
||||
// Static utility methods
|
||||
|
||||
// Returns the input enclosed in double quotes if it's not NULL;
|
||||
// otherwise returns "(null)". For example, "\"Hello\"" is returned
|
||||
// for input "Hello".
|
||||
//
|
||||
// This is useful for printing a C string in the syntax of a literal.
|
||||
//
|
||||
// Known issue: escape sequences are not handled yet.
|
||||
static String ShowCStringQuoted(const char* c_str); |
||||
|
||||
// Clones a 0-terminated C string, allocating memory using new. The
|
||||
// caller is responsible for deleting the return value using
|
||||
// delete[]. Returns the cloned string, or NULL if the input is
|
||||
// NULL.
|
||||
//
|
||||
// This is different from strdup() in string.h, which allocates
|
||||
// memory using malloc().
|
||||
static const char* CloneCString(const char* c_str); |
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE |
||||
// Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
|
||||
// able to pass strings to Win32 APIs on CE we need to convert them
|
||||
// to 'Unicode', UTF-16.
|
||||
|
||||
// Creates a UTF-16 wide string from the given ANSI string, allocating
|
||||
// memory using new. The caller is responsible for deleting the return
|
||||
// value using delete[]. Returns the wide string, or NULL if the
|
||||
// input is NULL.
|
||||
//
|
||||
// The wide string is created using the ANSI codepage (CP_ACP) to
|
||||
// match the behaviour of the ANSI versions of Win32 calls and the
|
||||
// C runtime.
|
||||
static LPCWSTR AnsiToUtf16(const char* c_str); |
||||
|
||||
// Creates an ANSI string from the given wide string, allocating
|
||||
// memory using new. The caller is responsible for deleting the return
|
||||
// value using delete[]. Returns the ANSI string, or NULL if the
|
||||
// input is NULL.
|
||||
//
|
||||
// The returned string is created using the ANSI codepage (CP_ACP) to
|
||||
// match the behaviour of the ANSI versions of Win32 calls and the
|
||||
// C runtime.
|
||||
static const char* Utf16ToAnsi(LPCWSTR utf16_str); |
||||
#endif |
||||
|
||||
// Compares two C strings. Returns true iff they have the same content.
|
||||
//
|
||||
// Unlike strcmp(), this function can handle NULL argument(s). A
|
||||
// NULL C string is considered different to any non-NULL C string,
|
||||
// including the empty string.
|
||||
static bool CStringEquals(const char* lhs, const char* rhs); |
||||
|
||||
// Converts a wide C string to a String using the UTF-8 encoding.
|
||||
// NULL will be converted to "(null)". If an error occurred during
|
||||
// the conversion, "(failed to convert from wide string)" is
|
||||
// returned.
|
||||
static String ShowWideCString(const wchar_t* wide_c_str); |
||||
|
||||
// Similar to ShowWideCString(), except that this function encloses
|
||||
// the converted string in double quotes.
|
||||
static String ShowWideCStringQuoted(const wchar_t* wide_c_str); |
||||
|
||||
// Compares two wide C strings. Returns true iff they have the same
|
||||
// content.
|
||||
//
|
||||
// Unlike wcscmp(), this function can handle NULL argument(s). A
|
||||
// NULL C string is considered different to any non-NULL C string,
|
||||
// including the empty string.
|
||||
static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs); |
||||
|
||||
// Compares two C strings, ignoring case. Returns true iff they
|
||||
// have the same content.
|
||||
//
|
||||
// Unlike strcasecmp(), this function can handle NULL argument(s).
|
||||
// A NULL C string is considered different to any non-NULL C string,
|
||||
// including the empty string.
|
||||
static bool CaseInsensitiveCStringEquals(const char* lhs, |
||||
const char* rhs); |
||||
|
||||
// Compares two wide C strings, ignoring case. Returns true iff they
|
||||
// have the same content.
|
||||
//
|
||||
// Unlike wcscasecmp(), this function can handle NULL argument(s).
|
||||
// A NULL C string is considered different to any non-NULL wide C string,
|
||||
// including the empty string.
|
||||
// NB: The implementations on different platforms slightly differ.
|
||||
// On windows, this method uses _wcsicmp which compares according to LC_CTYPE
|
||||
// environment variable. On GNU platform this method uses wcscasecmp
|
||||
// which compares according to LC_CTYPE category of the current locale.
|
||||
// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
|
||||
// current locale.
|
||||
static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs, |
||||
const wchar_t* rhs); |
||||
|
||||
// Formats a list of arguments to a String, using the same format
|
||||
// spec string as for printf.
|
||||
//
|
||||
// We do not use the StringPrintf class as it is not universally
|
||||
// available.
|
||||
//
|
||||
// The result is limited to 4096 characters (including the tailing
|
||||
// 0). If 4096 characters are not enough to format the input,
|
||||
// "<buffer exceeded>" is returned.
|
||||
static String Format(const char* format, ...); |
||||
|
||||
// C'tors
|
||||
|
||||
// The default c'tor constructs a NULL string.
|
||||
String() : c_str_(NULL), length_(0) {} |
||||
|
||||
// Constructs a String by cloning a 0-terminated C string.
|
||||
String(const char* a_c_str) { // NOLINT
|
||||
if (a_c_str == NULL) { |
||||
c_str_ = NULL; |
||||
length_ = 0; |
||||
} else { |
||||
ConstructNonNull(a_c_str, strlen(a_c_str)); |
||||
} |
||||
} |
||||
|
||||
// Constructs a String by copying a given number of chars from a
|
||||
// buffer. E.g. String("hello", 3) creates the string "hel",
|
||||
// String("a\0bcd", 4) creates "a\0bc", String(NULL, 0) creates "",
|
||||
// and String(NULL, 1) results in access violation.
|
||||
String(const char* buffer, size_t a_length) { |
||||
ConstructNonNull(buffer, a_length); |
||||
} |
||||
|
||||
// The copy c'tor creates a new copy of the string. The two
|
||||
// String objects do not share content.
|
||||
String(const String& str) : c_str_(NULL), length_(0) { *this = str; } |
||||
|
||||
// D'tor. String is intended to be a final class, so the d'tor
|
||||
// doesn't need to be virtual.
|
||||
~String() { delete[] c_str_; } |
||||
|
||||
// Allows a String to be implicitly converted to an ::std::string or
|
||||
// ::string, and vice versa. Converting a String containing a NULL
|
||||
// pointer to ::std::string or ::string is undefined behavior.
|
||||
// Converting a ::std::string or ::string containing an embedded NUL
|
||||
// character to a String will result in the prefix up to the first
|
||||
// NUL character.
|
||||
String(const ::std::string& str) { |
||||
ConstructNonNull(str.c_str(), str.length()); |
||||
} |
||||
|
||||
operator ::std::string() const { return ::std::string(c_str(), length()); } |
||||
|
||||
#if GTEST_HAS_GLOBAL_STRING |
||||
String(const ::string& str) { |
||||
ConstructNonNull(str.c_str(), str.length()); |
||||
} |
||||
|
||||
operator ::string() const { return ::string(c_str(), length()); } |
||||
#endif // GTEST_HAS_GLOBAL_STRING
|
||||
|
||||
// Returns true iff this is an empty string (i.e. "").
|
||||
bool empty() const { return (c_str() != NULL) && (length() == 0); } |
||||
|
||||
// Compares this with another String.
|
||||
// Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
|
||||
// if this is greater than rhs.
|
||||
int Compare(const String& rhs) const; |
||||
|
||||
// Returns true iff this String equals the given C string. A NULL
|
||||
// string and a non-NULL string are considered not equal.
|
||||
bool operator==(const char* a_c_str) const { return Compare(a_c_str) == 0; } |
||||
|
||||
// Returns true iff this String is less than the given String. A
|
||||
// NULL string is considered less than "".
|
||||
bool operator<(const String& rhs) const { return Compare(rhs) < 0; } |
||||
|
||||
// Returns true iff this String doesn't equal the given C string. A NULL
|
||||
// string and a non-NULL string are considered not equal.
|
||||
bool operator!=(const char* a_c_str) const { return !(*this == a_c_str); } |
||||
|
||||
// Returns true iff this String ends with the given suffix. *Any*
|
||||
// String is considered to end with a NULL or empty suffix.
|
||||
bool EndsWith(const char* suffix) const; |
||||
|
||||
// Returns true iff this String ends with the given suffix, not considering
|
||||
// case. Any String is considered to end with a NULL or empty suffix.
|
||||
bool EndsWithCaseInsensitive(const char* suffix) const; |
||||
|
||||
// Returns the length of the encapsulated string, or 0 if the
|
||||
// string is NULL.
|
||||
size_t length() const { return length_; } |
||||
|
||||
// Gets the 0-terminated C string this String object represents.
|
||||
// The String object still owns the string. Therefore the caller
|
||||
// should NOT delete the return value.
|
||||
const char* c_str() const { return c_str_; } |
||||
|
||||
// Assigns a C string to this object. Self-assignment works.
|
||||
const String& operator=(const char* a_c_str) { |
||||
return *this = String(a_c_str); |
||||
} |
||||
|
||||
// Assigns a String object to this object. Self-assignment works.
|
||||
const String& operator=(const String& rhs) { |
||||
if (this != &rhs) { |
||||
delete[] c_str_; |
||||
if (rhs.c_str() == NULL) { |
||||
c_str_ = NULL; |
||||
length_ = 0; |
||||
} else { |
||||
ConstructNonNull(rhs.c_str(), rhs.length()); |
||||
} |
||||
} |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
private: |
||||
// Constructs a non-NULL String from the given content. This
|
||||
// function can only be called when c_str_ has not been allocated.
|
||||
// ConstructNonNull(NULL, 0) results in an empty string ("").
|
||||
// ConstructNonNull(NULL, non_zero) is undefined behavior.
|
||||
void ConstructNonNull(const char* buffer, size_t a_length) { |
||||
char* const str = new char[a_length + 1]; |
||||
memcpy(str, buffer, a_length); |
||||
str[a_length] = '\0'; |
||||
c_str_ = str; |
||||
length_ = a_length; |
||||
} |
||||
|
||||
const char* c_str_; |
||||
size_t length_; |
||||
}; // class String
|
||||
|
||||
// Streams a String to an ostream. Each '\0' character in the String
|
||||
// is replaced with "\\0".
|
||||
inline ::std::ostream& operator<<(::std::ostream& os, const String& str) { |
||||
if (str.c_str() == NULL) { |
||||
os << "(null)"; |
||||
} else { |
||||
const char* const c_str = str.c_str(); |
||||
for (size_t i = 0; i != str.length(); i++) { |
||||
if (c_str[i] == '\0') { |
||||
os << "\\0"; |
||||
} else { |
||||
os << c_str[i]; |
||||
} |
||||
} |
||||
} |
||||
return os; |
||||
} |
||||
|
||||
// Gets the content of the stringstream's buffer as a String. Each '\0'
|
||||
// character in the buffer is replaced with "\\0".
|
||||
GTEST_API_ String StringStreamToString(::std::stringstream* stream); |
||||
|
||||
// Converts a streamable value to a String. A NULL pointer is
|
||||
// converted to "(null)". When the input value is a ::string,
|
||||
// ::std::string, ::wstring, or ::std::wstring object, each NUL
|
||||
// character in it is replaced with "\\0".
|
||||
|
||||
// Declared here but defined in gtest.h, so that it has access
|
||||
// to the definition of the Message class, required by the ARM
|
||||
// compiler.
|
||||
template <typename T> |
||||
String StreamableToString(const T& streamable); |
||||
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
|
@ -0,0 +1,968 @@
|
||||
// This file was GENERATED by a script. DO NOT EDIT BY HAND!!!
|
||||
|
||||
// Copyright 2009 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
|
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ |
||||
|
||||
#include <utility> // For ::std::pair. |
||||
|
||||
// The compiler used in Symbian has a bug that prevents us from declaring the
|
||||
// tuple template as a friend (it complains that tuple is redefined). This
|
||||
// hack bypasses the bug by declaring the members that should otherwise be
|
||||
// private as public.
|
||||
// Sun Studio versions < 12 also have the above bug.
|
||||
#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) |
||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: |
||||
#else |
||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ |
||||
template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
|
||||
private: |
||||
#endif |
||||
|
||||
// GTEST_n_TUPLE_(T) is the type of an n-tuple.
|
||||
#define GTEST_0_TUPLE_(T) tuple<> |
||||
#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \ |
||||
void, void, void> |
||||
#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \ |
||||
void, void, void> |
||||
#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \ |
||||
void, void, void> |
||||
#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \ |
||||
void, void, void> |
||||
#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \ |
||||
void, void, void> |
||||
#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \ |
||||
void, void, void> |
||||
#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ |
||||
void, void, void> |
||||
#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ |
||||
T##7, void, void> |
||||
#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ |
||||
T##7, T##8, void> |
||||
#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ |
||||
T##7, T##8, T##9> |
||||
|
||||
// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
|
||||
#define GTEST_0_TYPENAMES_(T) |
||||
#define GTEST_1_TYPENAMES_(T) typename T##0 |
||||
#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1 |
||||
#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2 |
||||
#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ |
||||
typename T##3 |
||||
#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ |
||||
typename T##3, typename T##4 |
||||
#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ |
||||
typename T##3, typename T##4, typename T##5 |
||||
#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ |
||||
typename T##3, typename T##4, typename T##5, typename T##6 |
||||
#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ |
||||
typename T##3, typename T##4, typename T##5, typename T##6, typename T##7 |
||||
#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ |
||||
typename T##3, typename T##4, typename T##5, typename T##6, \
|
||||
typename T##7, typename T##8 |
||||
#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ |
||||
typename T##3, typename T##4, typename T##5, typename T##6, \
|
||||
typename T##7, typename T##8, typename T##9 |
||||
|
||||
// In theory, defining stuff in the ::std namespace is undefined
|
||||
// behavior. We can do this as we are playing the role of a standard
|
||||
// library vendor.
|
||||
namespace std { |
||||
namespace tr1 { |
||||
|
||||
template <typename T0 = void, typename T1 = void, typename T2 = void, |
||||
typename T3 = void, typename T4 = void, typename T5 = void, |
||||
typename T6 = void, typename T7 = void, typename T8 = void, |
||||
typename T9 = void> |
||||
class tuple; |
||||
|
||||
// Anything in namespace gtest_internal is Google Test's INTERNAL
|
||||
// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
|
||||
namespace gtest_internal { |
||||
|
||||
// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
|
||||
template <typename T> |
||||
struct ByRef { typedef const T& type; }; // NOLINT
|
||||
template <typename T> |
||||
struct ByRef<T&> { typedef T& type; }; // NOLINT
|
||||
|
||||
// A handy wrapper for ByRef.
|
||||
#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type |
||||
|
||||
// AddRef<T>::type is T if T is a reference; otherwise it's T&. This
|
||||
// is the same as tr1::add_reference<T>::type.
|
||||
template <typename T> |
||||
struct AddRef { typedef T& type; }; // NOLINT
|
||||
template <typename T> |
||||
struct AddRef<T&> { typedef T& type; }; // NOLINT
|
||||
|
||||
// A handy wrapper for AddRef.
|
||||
#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type |
||||
|
||||
// A helper for implementing get<k>().
|
||||
template <int k> class Get; |
||||
|
||||
// A helper for implementing tuple_element<k, T>. kIndexValid is true
|
||||
// iff k < the number of fields in tuple type T.
|
||||
template <bool kIndexValid, int kIndex, class Tuple> |
||||
struct TupleElement; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 0, GTEST_10_TUPLE_(T)> { typedef T0 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 1, GTEST_10_TUPLE_(T)> { typedef T1 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 2, GTEST_10_TUPLE_(T)> { typedef T2 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 3, GTEST_10_TUPLE_(T)> { typedef T3 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 4, GTEST_10_TUPLE_(T)> { typedef T4 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 5, GTEST_10_TUPLE_(T)> { typedef T5 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 6, GTEST_10_TUPLE_(T)> { typedef T6 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 7, GTEST_10_TUPLE_(T)> { typedef T7 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 8, GTEST_10_TUPLE_(T)> { typedef T8 type; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> { typedef T9 type; }; |
||||
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <> |
||||
class tuple<> { |
||||
public: |
||||
tuple() {} |
||||
tuple(const tuple& /* t */) {} |
||||
tuple& operator=(const tuple& /* t */) { return *this; } |
||||
}; |
||||
|
||||
template <GTEST_1_TYPENAMES_(T)> |
||||
class GTEST_1_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_) {} |
||||
|
||||
template <GTEST_1_TYPENAMES_(U)> |
||||
tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_1_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_1_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_1_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
}; |
||||
|
||||
template <GTEST_2_TYPENAMES_(T)> |
||||
class GTEST_2_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0), |
||||
f1_(f1) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {} |
||||
|
||||
template <GTEST_2_TYPENAMES_(U)> |
||||
tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {} |
||||
template <typename U0, typename U1> |
||||
tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_2_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_2_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
template <typename U0, typename U1> |
||||
tuple& operator=(const ::std::pair<U0, U1>& p) { |
||||
f0_ = p.first; |
||||
f1_ = p.second; |
||||
return *this; |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_2_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
}; |
||||
|
||||
template <GTEST_3_TYPENAMES_(T)> |
||||
class GTEST_3_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_(), f2_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, |
||||
GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} |
||||
|
||||
template <GTEST_3_TYPENAMES_(U)> |
||||
tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_3_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_3_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_3_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
f2_ = t.f2_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
T2 f2_; |
||||
}; |
||||
|
||||
template <GTEST_4_TYPENAMES_(T)> |
||||
class GTEST_4_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, |
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2), |
||||
f3_(f3) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {} |
||||
|
||||
template <GTEST_4_TYPENAMES_(U)> |
||||
tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), |
||||
f3_(t.f3_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_4_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_4_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_4_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
f2_ = t.f2_; |
||||
f3_ = t.f3_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
T2 f2_; |
||||
T3 f3_; |
||||
}; |
||||
|
||||
template <GTEST_5_TYPENAMES_(T)> |
||||
class GTEST_5_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, |
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, |
||||
GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), |
||||
f4_(t.f4_) {} |
||||
|
||||
template <GTEST_5_TYPENAMES_(U)> |
||||
tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), |
||||
f3_(t.f3_), f4_(t.f4_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_5_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_5_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_5_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
f2_ = t.f2_; |
||||
f3_ = t.f3_; |
||||
f4_ = t.f4_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
T2 f2_; |
||||
T3 f3_; |
||||
T4 f4_; |
||||
}; |
||||
|
||||
template <GTEST_6_TYPENAMES_(T)> |
||||
class GTEST_6_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, |
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, |
||||
GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), |
||||
f5_(f5) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), |
||||
f4_(t.f4_), f5_(t.f5_) {} |
||||
|
||||
template <GTEST_6_TYPENAMES_(U)> |
||||
tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), |
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_6_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_6_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_6_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
f2_ = t.f2_; |
||||
f3_ = t.f3_; |
||||
f4_ = t.f4_; |
||||
f5_ = t.f5_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
T2 f2_; |
||||
T3 f3_; |
||||
T4 f4_; |
||||
T5 f5_; |
||||
}; |
||||
|
||||
template <GTEST_7_TYPENAMES_(T)> |
||||
class GTEST_7_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, |
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, |
||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2), |
||||
f3_(f3), f4_(f4), f5_(f5), f6_(f6) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), |
||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} |
||||
|
||||
template <GTEST_7_TYPENAMES_(U)> |
||||
tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), |
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_7_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_7_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_7_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
f2_ = t.f2_; |
||||
f3_ = t.f3_; |
||||
f4_ = t.f4_; |
||||
f5_ = t.f5_; |
||||
f6_ = t.f6_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
T2 f2_; |
||||
T3 f3_; |
||||
T4 f4_; |
||||
T5 f5_; |
||||
T6 f6_; |
||||
}; |
||||
|
||||
template <GTEST_8_TYPENAMES_(T)> |
||||
class GTEST_8_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, |
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, |
||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, |
||||
GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), |
||||
f5_(f5), f6_(f6), f7_(f7) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), |
||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} |
||||
|
||||
template <GTEST_8_TYPENAMES_(U)> |
||||
tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), |
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_8_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_8_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_8_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
f2_ = t.f2_; |
||||
f3_ = t.f3_; |
||||
f4_ = t.f4_; |
||||
f5_ = t.f5_; |
||||
f6_ = t.f6_; |
||||
f7_ = t.f7_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
T2 f2_; |
||||
T3 f3_; |
||||
T4 f4_; |
||||
T5 f5_; |
||||
T6 f6_; |
||||
T7 f7_; |
||||
}; |
||||
|
||||
template <GTEST_9_TYPENAMES_(T)> |
||||
class GTEST_9_TUPLE_(T) { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, |
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, |
||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, |
||||
GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), |
||||
f5_(f5), f6_(f6), f7_(f7), f8_(f8) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), |
||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} |
||||
|
||||
template <GTEST_9_TYPENAMES_(U)> |
||||
tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), |
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_9_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_9_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_9_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
f2_ = t.f2_; |
||||
f3_ = t.f3_; |
||||
f4_ = t.f4_; |
||||
f5_ = t.f5_; |
||||
f6_ = t.f6_; |
||||
f7_ = t.f7_; |
||||
f8_ = t.f8_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
T2 f2_; |
||||
T3 f3_; |
||||
T4 f4_; |
||||
T5 f5_; |
||||
T6 f6_; |
||||
T7 f7_; |
||||
T8 f8_; |
||||
}; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
class tuple { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(), |
||||
f9_() {} |
||||
|
||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, |
||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, |
||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, |
||||
GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2), |
||||
f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {} |
||||
|
||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), |
||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {} |
||||
|
||||
template <GTEST_10_TYPENAMES_(U)> |
||||
tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), |
||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), |
||||
f9_(t.f9_) {} |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_10_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_10_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_10_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) { |
||||
f0_ = t.f0_; |
||||
f1_ = t.f1_; |
||||
f2_ = t.f2_; |
||||
f3_ = t.f3_; |
||||
f4_ = t.f4_; |
||||
f5_ = t.f5_; |
||||
f6_ = t.f6_; |
||||
f7_ = t.f7_; |
||||
f8_ = t.f8_; |
||||
f9_ = t.f9_; |
||||
return *this; |
||||
} |
||||
|
||||
T0 f0_; |
||||
T1 f1_; |
||||
T2 f2_; |
||||
T3 f3_; |
||||
T4 f4_; |
||||
T5 f5_; |
||||
T6 f6_; |
||||
T7 f7_; |
||||
T8 f8_; |
||||
T9 f9_; |
||||
}; |
||||
|
||||
// 6.1.3.2 Tuple creation functions.
|
||||
|
||||
// Known limitations: we don't support passing an
|
||||
// std::tr1::reference_wrapper<T> to make_tuple(). And we don't
|
||||
// implement tie().
|
||||
|
||||
inline tuple<> make_tuple() { return tuple<>(); } |
||||
|
||||
template <GTEST_1_TYPENAMES_(T)> |
||||
inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { |
||||
return GTEST_1_TUPLE_(T)(f0); |
||||
} |
||||
|
||||
template <GTEST_2_TYPENAMES_(T)> |
||||
inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { |
||||
return GTEST_2_TUPLE_(T)(f0, f1); |
||||
} |
||||
|
||||
template <GTEST_3_TYPENAMES_(T)> |
||||
inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) { |
||||
return GTEST_3_TUPLE_(T)(f0, f1, f2); |
||||
} |
||||
|
||||
template <GTEST_4_TYPENAMES_(T)> |
||||
inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, |
||||
const T3& f3) { |
||||
return GTEST_4_TUPLE_(T)(f0, f1, f2, f3); |
||||
} |
||||
|
||||
template <GTEST_5_TYPENAMES_(T)> |
||||
inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, |
||||
const T3& f3, const T4& f4) { |
||||
return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4); |
||||
} |
||||
|
||||
template <GTEST_6_TYPENAMES_(T)> |
||||
inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, |
||||
const T3& f3, const T4& f4, const T5& f5) { |
||||
return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5); |
||||
} |
||||
|
||||
template <GTEST_7_TYPENAMES_(T)> |
||||
inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, |
||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6) { |
||||
return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6); |
||||
} |
||||
|
||||
template <GTEST_8_TYPENAMES_(T)> |
||||
inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, |
||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) { |
||||
return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7); |
||||
} |
||||
|
||||
template <GTEST_9_TYPENAMES_(T)> |
||||
inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, |
||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, |
||||
const T8& f8) { |
||||
return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8); |
||||
} |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, |
||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, |
||||
const T8& f8, const T9& f9) { |
||||
return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9); |
||||
} |
||||
|
||||
// 6.1.3.3 Tuple helper classes.
|
||||
|
||||
template <typename Tuple> struct tuple_size; |
||||
|
||||
template <GTEST_0_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_0_TUPLE_(T)> { static const int value = 0; }; |
||||
|
||||
template <GTEST_1_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_1_TUPLE_(T)> { static const int value = 1; }; |
||||
|
||||
template <GTEST_2_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_2_TUPLE_(T)> { static const int value = 2; }; |
||||
|
||||
template <GTEST_3_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_3_TUPLE_(T)> { static const int value = 3; }; |
||||
|
||||
template <GTEST_4_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_4_TUPLE_(T)> { static const int value = 4; }; |
||||
|
||||
template <GTEST_5_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_5_TUPLE_(T)> { static const int value = 5; }; |
||||
|
||||
template <GTEST_6_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_6_TUPLE_(T)> { static const int value = 6; }; |
||||
|
||||
template <GTEST_7_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_7_TUPLE_(T)> { static const int value = 7; }; |
||||
|
||||
template <GTEST_8_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_8_TUPLE_(T)> { static const int value = 8; }; |
||||
|
||||
template <GTEST_9_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_9_TUPLE_(T)> { static const int value = 9; }; |
||||
|
||||
template <GTEST_10_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_10_TUPLE_(T)> { static const int value = 10; }; |
||||
|
||||
template <int k, class Tuple> |
||||
struct tuple_element { |
||||
typedef typename gtest_internal::TupleElement< |
||||
k < (tuple_size<Tuple>::value), k, Tuple>::type type; |
||||
}; |
||||
|
||||
#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type |
||||
|
||||
// 6.1.3.4 Element access.
|
||||
|
||||
namespace gtest_internal { |
||||
|
||||
template <> |
||||
class Get<0> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) |
||||
Field(Tuple& t) { return t.f0_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f0_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<1> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) |
||||
Field(Tuple& t) { return t.f1_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f1_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<2> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) |
||||
Field(Tuple& t) { return t.f2_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f2_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<3> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) |
||||
Field(Tuple& t) { return t.f3_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f3_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<4> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) |
||||
Field(Tuple& t) { return t.f4_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f4_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<5> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) |
||||
Field(Tuple& t) { return t.f5_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f5_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<6> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) |
||||
Field(Tuple& t) { return t.f6_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f6_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<7> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) |
||||
Field(Tuple& t) { return t.f7_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f7_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<8> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) |
||||
Field(Tuple& t) { return t.f8_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f8_; } |
||||
}; |
||||
|
||||
template <> |
||||
class Get<9> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) |
||||
Field(Tuple& t) { return t.f9_; } // NOLINT
|
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f9_; } |
||||
}; |
||||
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <int k, GTEST_10_TYPENAMES_(T)> |
||||
GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) |
||||
get(GTEST_10_TUPLE_(T)& t) { |
||||
return gtest_internal::Get<k>::Field(t); |
||||
} |
||||
|
||||
template <int k, GTEST_10_TYPENAMES_(T)> |
||||
GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) |
||||
get(const GTEST_10_TUPLE_(T)& t) { |
||||
return gtest_internal::Get<k>::ConstField(t); |
||||
} |
||||
|
||||
// 6.1.3.5 Relational operators
|
||||
|
||||
// We only implement == and !=, as we don't have a need for the rest yet.
|
||||
|
||||
namespace gtest_internal { |
||||
|
||||
// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
|
||||
// first k fields of t1 equals the first k fields of t2.
|
||||
// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
|
||||
// k1 != k2.
|
||||
template <int kSize1, int kSize2> |
||||
struct SameSizeTuplePrefixComparator; |
||||
|
||||
template <> |
||||
struct SameSizeTuplePrefixComparator<0, 0> { |
||||
template <class Tuple1, class Tuple2> |
||||
static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { |
||||
return true; |
||||
} |
||||
}; |
||||
|
||||
template <int k> |
||||
struct SameSizeTuplePrefixComparator<k, k> { |
||||
template <class Tuple1, class Tuple2> |
||||
static bool Eq(const Tuple1& t1, const Tuple2& t2) { |
||||
return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) && |
||||
::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2); |
||||
} |
||||
}; |
||||
|
||||
} // namespace gtest_internal
|
||||
|
||||
template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> |
||||
inline bool operator==(const GTEST_10_TUPLE_(T)& t, |
||||
const GTEST_10_TUPLE_(U)& u) { |
||||
return gtest_internal::SameSizeTuplePrefixComparator< |
||||
tuple_size<GTEST_10_TUPLE_(T)>::value, |
||||
tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u); |
||||
} |
||||
|
||||
template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> |
||||
inline bool operator!=(const GTEST_10_TUPLE_(T)& t, |
||||
const GTEST_10_TUPLE_(U)& u) { return !(t == u); } |
||||
|
||||
// 6.1.4 Pairs.
|
||||
// Unimplemented.
|
||||
|
||||
} // namespace tr1
|
||||
} // namespace std
|
||||
|
||||
#undef GTEST_0_TUPLE_ |
||||
#undef GTEST_1_TUPLE_ |
||||
#undef GTEST_2_TUPLE_ |
||||
#undef GTEST_3_TUPLE_ |
||||
#undef GTEST_4_TUPLE_ |
||||
#undef GTEST_5_TUPLE_ |
||||
#undef GTEST_6_TUPLE_ |
||||
#undef GTEST_7_TUPLE_ |
||||
#undef GTEST_8_TUPLE_ |
||||
#undef GTEST_9_TUPLE_ |
||||
#undef GTEST_10_TUPLE_ |
||||
|
||||
#undef GTEST_0_TYPENAMES_ |
||||
#undef GTEST_1_TYPENAMES_ |
||||
#undef GTEST_2_TYPENAMES_ |
||||
#undef GTEST_3_TYPENAMES_ |
||||
#undef GTEST_4_TYPENAMES_ |
||||
#undef GTEST_5_TYPENAMES_ |
||||
#undef GTEST_6_TYPENAMES_ |
||||
#undef GTEST_7_TYPENAMES_ |
||||
#undef GTEST_8_TYPENAMES_ |
||||
#undef GTEST_9_TYPENAMES_ |
||||
#undef GTEST_10_TYPENAMES_ |
||||
|
||||
#undef GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
#undef GTEST_BY_REF_ |
||||
#undef GTEST_ADD_REF_ |
||||
#undef GTEST_TUPLE_ELEMENT_ |
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
|
@ -0,0 +1,336 @@
|
||||
$$ -*- mode: c++; -*- |
||||
$var n = 10 $$ Maximum number of tuple fields we want to support. |
||||
$$ This meta comment fixes auto-indentation in Emacs. }} |
||||
// Copyright 2009 Google Inc. |
||||
// All Rights Reserved. |
||||
// |
||||
// Redistribution and use in source and binary forms, with or without |
||||
// modification, are permitted provided that the following conditions are |
||||
// met: |
||||
// |
||||
// * Redistributions of source code must retain the above copyright |
||||
// notice, this list of conditions and the following disclaimer. |
||||
// * Redistributions in binary form must reproduce the above |
||||
// copyright notice, this list of conditions and the following disclaimer |
||||
// in the documentation and/or other materials provided with the |
||||
// distribution. |
||||
// * Neither the name of Google Inc. nor the names of its |
||||
// contributors may be used to endorse or promote products derived from |
||||
// this software without specific prior written permission. |
||||
// |
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
// |
||||
// Author: wan@google.com (Zhanyong Wan) |
||||
|
||||
// Implements a subset of TR1 tuple needed by Google Test and Google Mock. |
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ |
||||
|
||||
#include <utility> // For ::std::pair. |
||||
|
||||
// The compiler used in Symbian has a bug that prevents us from declaring the |
||||
// tuple template as a friend (it complains that tuple is redefined). This |
||||
// hack bypasses the bug by declaring the members that should otherwise be |
||||
// private as public. |
||||
// Sun Studio versions < 12 also have the above bug. |
||||
#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) |
||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: |
||||
#else |
||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ |
||||
template <GTEST_$(n)_TYPENAMES_(U)> friend class tuple; \ |
||||
private: |
||||
#endif |
||||
|
||||
|
||||
$range i 0..n-1 |
||||
$range j 0..n |
||||
$range k 1..n |
||||
// GTEST_n_TUPLE_(T) is the type of an n-tuple. |
||||
#define GTEST_0_TUPLE_(T) tuple<> |
||||
|
||||
$for k [[ |
||||
$range m 0..k-1 |
||||
$range m2 k..n-1 |
||||
#define GTEST_$(k)_TUPLE_(T) tuple<$for m, [[T##$m]]$for m2 [[, void]]> |
||||
|
||||
]] |
||||
|
||||
// GTEST_n_TYPENAMES_(T) declares a list of n typenames. |
||||
|
||||
$for j [[ |
||||
$range m 0..j-1 |
||||
#define GTEST_$(j)_TYPENAMES_(T) $for m, [[typename T##$m]] |
||||
|
||||
|
||||
]] |
||||
|
||||
// In theory, defining stuff in the ::std namespace is undefined |
||||
// behavior. We can do this as we are playing the role of a standard |
||||
// library vendor. |
||||
namespace std { |
||||
namespace tr1 { |
||||
|
||||
template <$for i, [[typename T$i = void]]> |
||||
class tuple; |
||||
|
||||
// Anything in namespace gtest_internal is Google Test's INTERNAL |
||||
// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code. |
||||
namespace gtest_internal { |
||||
|
||||
// ByRef<T>::type is T if T is a reference; otherwise it's const T&. |
||||
template <typename T> |
||||
struct ByRef { typedef const T& type; }; // NOLINT |
||||
template <typename T> |
||||
struct ByRef<T&> { typedef T& type; }; // NOLINT |
||||
|
||||
// A handy wrapper for ByRef. |
||||
#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type |
||||
|
||||
// AddRef<T>::type is T if T is a reference; otherwise it's T&. This |
||||
// is the same as tr1::add_reference<T>::type. |
||||
template <typename T> |
||||
struct AddRef { typedef T& type; }; // NOLINT |
||||
template <typename T> |
||||
struct AddRef<T&> { typedef T& type; }; // NOLINT |
||||
|
||||
// A handy wrapper for AddRef. |
||||
#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type |
||||
|
||||
// A helper for implementing get<k>(). |
||||
template <int k> class Get; |
||||
|
||||
// A helper for implementing tuple_element<k, T>. kIndexValid is true |
||||
// iff k < the number of fields in tuple type T. |
||||
template <bool kIndexValid, int kIndex, class Tuple> |
||||
struct TupleElement; |
||||
|
||||
|
||||
$for i [[ |
||||
template <GTEST_$(n)_TYPENAMES_(T)> |
||||
struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T)> [[]] |
||||
{ typedef T$i type; }; |
||||
|
||||
|
||||
]] |
||||
} // namespace gtest_internal |
||||
|
||||
template <> |
||||
class tuple<> { |
||||
public: |
||||
tuple() {} |
||||
tuple(const tuple& /* t */) {} |
||||
tuple& operator=(const tuple& /* t */) { return *this; } |
||||
}; |
||||
|
||||
|
||||
$for k [[ |
||||
$range m 0..k-1 |
||||
template <GTEST_$(k)_TYPENAMES_(T)> |
||||
class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] { |
||||
public: |
||||
template <int k> friend class gtest_internal::Get; |
||||
|
||||
tuple() : $for m, [[f$(m)_()]] {} |
||||
|
||||
explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]] |
||||
$for m, [[f$(m)_(f$m)]] {} |
||||
|
||||
tuple(const tuple& t) : $for m, [[f$(m)_(t.f$(m)_)]] {} |
||||
|
||||
template <GTEST_$(k)_TYPENAMES_(U)> |
||||
tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {} |
||||
|
||||
$if k == 2 [[ |
||||
template <typename U0, typename U1> |
||||
tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {} |
||||
|
||||
]] |
||||
|
||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } |
||||
|
||||
template <GTEST_$(k)_TYPENAMES_(U)> |
||||
tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) { |
||||
return CopyFrom(t); |
||||
} |
||||
|
||||
$if k == 2 [[ |
||||
template <typename U0, typename U1> |
||||
tuple& operator=(const ::std::pair<U0, U1>& p) { |
||||
f0_ = p.first; |
||||
f1_ = p.second; |
||||
return *this; |
||||
} |
||||
|
||||
]] |
||||
|
||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
|
||||
template <GTEST_$(k)_TYPENAMES_(U)> |
||||
tuple& CopyFrom(const GTEST_$(k)_TUPLE_(U)& t) { |
||||
|
||||
$for m [[ |
||||
f$(m)_ = t.f$(m)_; |
||||
|
||||
]] |
||||
return *this; |
||||
} |
||||
|
||||
|
||||
$for m [[ |
||||
T$m f$(m)_; |
||||
|
||||
]] |
||||
}; |
||||
|
||||
|
||||
]] |
||||
// 6.1.3.2 Tuple creation functions. |
||||
|
||||
// Known limitations: we don't support passing an |
||||
// std::tr1::reference_wrapper<T> to make_tuple(). And we don't |
||||
// implement tie(). |
||||
|
||||
inline tuple<> make_tuple() { return tuple<>(); } |
||||
|
||||
$for k [[ |
||||
$range m 0..k-1 |
||||
|
||||
template <GTEST_$(k)_TYPENAMES_(T)> |
||||
inline GTEST_$(k)_TUPLE_(T) make_tuple($for m, [[const T$m& f$m]]) { |
||||
return GTEST_$(k)_TUPLE_(T)($for m, [[f$m]]); |
||||
} |
||||
|
||||
]] |
||||
|
||||
// 6.1.3.3 Tuple helper classes. |
||||
|
||||
template <typename Tuple> struct tuple_size; |
||||
|
||||
|
||||
$for j [[ |
||||
template <GTEST_$(j)_TYPENAMES_(T)> |
||||
struct tuple_size<GTEST_$(j)_TUPLE_(T)> { static const int value = $j; }; |
||||
|
||||
|
||||
]] |
||||
template <int k, class Tuple> |
||||
struct tuple_element { |
||||
typedef typename gtest_internal::TupleElement< |
||||
k < (tuple_size<Tuple>::value), k, Tuple>::type type; |
||||
}; |
||||
|
||||
#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type |
||||
|
||||
// 6.1.3.4 Element access. |
||||
|
||||
namespace gtest_internal { |
||||
|
||||
|
||||
$for i [[ |
||||
template <> |
||||
class Get<$i> { |
||||
public: |
||||
template <class Tuple> |
||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple)) |
||||
Field(Tuple& t) { return t.f$(i)_; } // NOLINT |
||||
|
||||
template <class Tuple> |
||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple)) |
||||
ConstField(const Tuple& t) { return t.f$(i)_; } |
||||
}; |
||||
|
||||
|
||||
]] |
||||
} // namespace gtest_internal |
||||
|
||||
template <int k, GTEST_$(n)_TYPENAMES_(T)> |
||||
GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T))) |
||||
get(GTEST_$(n)_TUPLE_(T)& t) { |
||||
return gtest_internal::Get<k>::Field(t); |
||||
} |
||||
|
||||
template <int k, GTEST_$(n)_TYPENAMES_(T)> |
||||
GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T))) |
||||
get(const GTEST_$(n)_TUPLE_(T)& t) { |
||||
return gtest_internal::Get<k>::ConstField(t); |
||||
} |
||||
|
||||
// 6.1.3.5 Relational operators |
||||
|
||||
// We only implement == and !=, as we don't have a need for the rest yet. |
||||
|
||||
namespace gtest_internal { |
||||
|
||||
// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the |
||||
// first k fields of t1 equals the first k fields of t2. |
||||
// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if |
||||
// k1 != k2. |
||||
template <int kSize1, int kSize2> |
||||
struct SameSizeTuplePrefixComparator; |
||||
|
||||
template <> |
||||
struct SameSizeTuplePrefixComparator<0, 0> { |
||||
template <class Tuple1, class Tuple2> |
||||
static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { |
||||
return true; |
||||
} |
||||
}; |
||||
|
||||
template <int k> |
||||
struct SameSizeTuplePrefixComparator<k, k> { |
||||
template <class Tuple1, class Tuple2> |
||||
static bool Eq(const Tuple1& t1, const Tuple2& t2) { |
||||
return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) && |
||||
::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2); |
||||
} |
||||
}; |
||||
|
||||
} // namespace gtest_internal |
||||
|
||||
template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)> |
||||
inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t, |
||||
const GTEST_$(n)_TUPLE_(U)& u) { |
||||
return gtest_internal::SameSizeTuplePrefixComparator< |
||||
tuple_size<GTEST_$(n)_TUPLE_(T)>::value, |
||||
tuple_size<GTEST_$(n)_TUPLE_(U)>::value>::Eq(t, u); |
||||
} |
||||
|
||||
template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)> |
||||
inline bool operator!=(const GTEST_$(n)_TUPLE_(T)& t, |
||||
const GTEST_$(n)_TUPLE_(U)& u) { return !(t == u); } |
||||
|
||||
// 6.1.4 Pairs. |
||||
// Unimplemented. |
||||
|
||||
} // namespace tr1 |
||||
} // namespace std |
||||
|
||||
|
||||
$for j [[ |
||||
#undef GTEST_$(j)_TUPLE_ |
||||
|
||||
]] |
||||
|
||||
|
||||
$for j [[ |
||||
#undef GTEST_$(j)_TYPENAMES_ |
||||
|
||||
]] |
||||
|
||||
#undef GTEST_DECLARE_TUPLE_AS_FRIEND_ |
||||
#undef GTEST_BY_REF_ |
||||
#undef GTEST_ADD_REF_ |
||||
#undef GTEST_TUPLE_ELEMENT_ |
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ |
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,296 @@
|
||||
$$ -*- mode: c++; -*- |
||||
$var n = 50 $$ Maximum length of type lists we want to support. |
||||
// Copyright 2008 Google Inc. |
||||
// All Rights Reserved. |
||||
// |
||||
// Redistribution and use in source and binary forms, with or without |
||||
// modification, are permitted provided that the following conditions are |
||||
// met: |
||||
// |
||||
// * Redistributions of source code must retain the above copyright |
||||
// notice, this list of conditions and the following disclaimer. |
||||
// * Redistributions in binary form must reproduce the above |
||||
// copyright notice, this list of conditions and the following disclaimer |
||||
// in the documentation and/or other materials provided with the |
||||
// distribution. |
||||
// * Neither the name of Google Inc. nor the names of its |
||||
// contributors may be used to endorse or promote products derived from |
||||
// this software without specific prior written permission. |
||||
// |
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
// |
||||
// Author: wan@google.com (Zhanyong Wan) |
||||
|
||||
// Type utilities needed for implementing typed and type-parameterized |
||||
// tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND! |
||||
// |
||||
// Currently we support at most $n types in a list, and at most $n |
||||
// type-parameterized tests in one type-parameterized test case. |
||||
// Please contact googletestframework@googlegroups.com if you need |
||||
// more. |
||||
|
||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ |
||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ |
||||
|
||||
#include "gtest/internal/gtest-port.h" |
||||
#include "gtest/internal/gtest-string.h" |
||||
|
||||
// #ifdef __GNUC__ is too general here. It is possible to use gcc without using |
||||
// libstdc++ (which is where cxxabi.h comes from). |
||||
# ifdef __GLIBCXX__ |
||||
# include <cxxabi.h> |
||||
# elif defined(__HP_aCC) |
||||
# include <acxx_demangle.h> |
||||
# endif // __GLIBCXX__ |
||||
|
||||
namespace testing { |
||||
namespace internal { |
||||
|
||||
// GetTypeName<T>() returns a human-readable name of type T. |
||||
// NB: This function is also used in Google Mock, so don't move it inside of |
||||
// the typed-test-only section below. |
||||
template <typename T> |
||||
String GetTypeName() { |
||||
# if GTEST_HAS_RTTI |
||||
|
||||
const char* const name = typeid(T).name(); |
||||
# if defined(__GLIBCXX__) || defined(__HP_aCC) |
||||
int status = 0; |
||||
// gcc's implementation of typeid(T).name() mangles the type name, |
||||
// so we have to demangle it. |
||||
# ifdef __GLIBCXX__ |
||||
using abi::__cxa_demangle; |
||||
# endif // __GLIBCXX__ |
||||
char* const readable_name = __cxa_demangle(name, 0, 0, &status); |
||||
const String name_str(status == 0 ? readable_name : name); |
||||
free(readable_name); |
||||
return name_str; |
||||
# else |
||||
return name; |
||||
# endif // __GLIBCXX__ || __HP_aCC |
||||
|
||||
# else |
||||
|
||||
return "<type>"; |
||||
|
||||
# endif // GTEST_HAS_RTTI |
||||
} |
||||
|
||||
#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P |
||||
|
||||
// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same |
||||
// type. This can be used as a compile-time assertion to ensure that |
||||
// two types are equal. |
||||
|
||||
template <typename T1, typename T2> |
||||
struct AssertTypeEq; |
||||
|
||||
template <typename T> |
||||
struct AssertTypeEq<T, T> { |
||||
typedef bool type; |
||||
}; |
||||
|
||||
// A unique type used as the default value for the arguments of class |
||||
// template Types. This allows us to simulate variadic templates |
||||
// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't |
||||
// support directly. |
||||
struct None {}; |
||||
|
||||
// The following family of struct and struct templates are used to |
||||
// represent type lists. In particular, TypesN<T1, T2, ..., TN> |
||||
// represents a type list with N types (T1, T2, ..., and TN) in it. |
||||
// Except for Types0, every struct in the family has two member types: |
||||
// Head for the first type in the list, and Tail for the rest of the |
||||
// list. |
||||
|
||||
// The empty type list. |
||||
struct Types0 {}; |
||||
|
||||
// Type lists of length 1, 2, 3, and so on. |
||||
|
||||
template <typename T1> |
||||
struct Types1 { |
||||
typedef T1 Head; |
||||
typedef Types0 Tail; |
||||
}; |
||||
|
||||
$range i 2..n |
||||
|
||||
$for i [[ |
||||
$range j 1..i |
||||
$range k 2..i |
||||
template <$for j, [[typename T$j]]> |
||||
struct Types$i { |
||||
typedef T1 Head; |
||||
typedef Types$(i-1)<$for k, [[T$k]]> Tail; |
||||
}; |
||||
|
||||
|
||||
]] |
||||
|
||||
} // namespace internal |
||||
|
||||
// We don't want to require the users to write TypesN<...> directly, |
||||
// as that would require them to count the length. Types<...> is much |
||||
// easier to write, but generates horrible messages when there is a |
||||
// compiler error, as gcc insists on printing out each template |
||||
// argument, even if it has the default value (this means Types<int> |
||||
// will appear as Types<int, None, None, ..., None> in the compiler |
||||
// errors). |
||||
// |
||||
// Our solution is to combine the best part of the two approaches: a |
||||
// user would write Types<T1, ..., TN>, and Google Test will translate |
||||
// that to TypesN<T1, ..., TN> internally to make error messages |
||||
// readable. The translation is done by the 'type' member of the |
||||
// Types template. |
||||
|
||||
$range i 1..n |
||||
template <$for i, [[typename T$i = internal::None]]> |
||||
struct Types { |
||||
typedef internal::Types$n<$for i, [[T$i]]> type; |
||||
}; |
||||
|
||||
template <> |
||||
struct Types<$for i, [[internal::None]]> { |
||||
typedef internal::Types0 type; |
||||
}; |
||||
|
||||
$range i 1..n-1 |
||||
$for i [[ |
||||
$range j 1..i |
||||
$range k i+1..n |
||||
template <$for j, [[typename T$j]]> |
||||
struct Types<$for j, [[T$j]]$for k[[, internal::None]]> { |
||||
typedef internal::Types$i<$for j, [[T$j]]> type; |
||||
}; |
||||
|
||||
]] |
||||
|
||||
namespace internal { |
||||
|
||||
# define GTEST_TEMPLATE_ template <typename T> class |
||||
|
||||
// The template "selector" struct TemplateSel<Tmpl> is used to |
||||
// represent Tmpl, which must be a class template with one type |
||||
// parameter, as a type. TemplateSel<Tmpl>::Bind<T>::type is defined |
||||
// as the type Tmpl<T>. This allows us to actually instantiate the |
||||
// template "selected" by TemplateSel<Tmpl>. |
||||
// |
||||
// This trick is necessary for simulating typedef for class templates, |
||||
// which C++ doesn't support directly. |
||||
template <GTEST_TEMPLATE_ Tmpl> |
||||
struct TemplateSel { |
||||
template <typename T> |
||||
struct Bind { |
||||
typedef Tmpl<T> type; |
||||
}; |
||||
}; |
||||
|
||||
# define GTEST_BIND_(TmplSel, T) \ |
||||
TmplSel::template Bind<T>::type |
||||
|
||||
// A unique struct template used as the default value for the |
||||
// arguments of class template Templates. This allows us to simulate |
||||
// variadic templates (e.g. Templates<int>, Templates<int, double>, |
||||
// and etc), which C++ doesn't support directly. |
||||
template <typename T> |
||||
struct NoneT {}; |
||||
|
||||
// The following family of struct and struct templates are used to |
||||
// represent template lists. In particular, TemplatesN<T1, T2, ..., |
||||
// TN> represents a list of N templates (T1, T2, ..., and TN). Except |
||||
// for Templates0, every struct in the family has two member types: |
||||
// Head for the selector of the first template in the list, and Tail |
||||
// for the rest of the list. |
||||
|
||||
// The empty template list. |
||||
struct Templates0 {}; |
||||
|
||||
// Template lists of length 1, 2, 3, and so on. |
||||
|
||||
template <GTEST_TEMPLATE_ T1> |
||||
struct Templates1 { |
||||
typedef TemplateSel<T1> Head; |
||||
typedef Templates0 Tail; |
||||
}; |
||||
|
||||
$range i 2..n |
||||
|
||||
$for i [[ |
||||
$range j 1..i |
||||
$range k 2..i |
||||
template <$for j, [[GTEST_TEMPLATE_ T$j]]> |
||||
struct Templates$i { |
||||
typedef TemplateSel<T1> Head; |
||||
typedef Templates$(i-1)<$for k, [[T$k]]> Tail; |
||||
}; |
||||
|
||||
|
||||
]] |
||||
|
||||
// We don't want to require the users to write TemplatesN<...> directly, |
||||
// as that would require them to count the length. Templates<...> is much |
||||
// easier to write, but generates horrible messages when there is a |
||||
// compiler error, as gcc insists on printing out each template |
||||
// argument, even if it has the default value (this means Templates<list> |
||||
// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler |
||||
// errors). |
||||
// |
||||
// Our solution is to combine the best part of the two approaches: a |
||||
// user would write Templates<T1, ..., TN>, and Google Test will translate |
||||
// that to TemplatesN<T1, ..., TN> internally to make error messages |
||||
// readable. The translation is done by the 'type' member of the |
||||
// Templates template. |
||||
|
||||
$range i 1..n |
||||
template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]> |
||||
struct Templates { |
||||
typedef Templates$n<$for i, [[T$i]]> type; |
||||
}; |
||||
|
||||
template <> |
||||
struct Templates<$for i, [[NoneT]]> { |
||||
typedef Templates0 type; |
||||
}; |
||||
|
||||
$range i 1..n-1 |
||||
$for i [[ |
||||
$range j 1..i |
||||
$range k i+1..n |
||||
template <$for j, [[GTEST_TEMPLATE_ T$j]]> |
||||
struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> { |
||||
typedef Templates$i<$for j, [[T$j]]> type; |
||||
}; |
||||
|
||||
]] |
||||
|
||||
// The TypeList template makes it possible to use either a single type |
||||
// or a Types<...> list in TYPED_TEST_CASE() and |
||||
// INSTANTIATE_TYPED_TEST_CASE_P(). |
||||
|
||||
template <typename T> |
||||
struct TypeList { typedef Types1<T> type; }; |
||||
|
||||
|
||||
$range i 1..n |
||||
template <$for i, [[typename T$i]]> |
||||
struct TypeList<Types<$for i, [[T$i]]> > { |
||||
typedef typename Types<$for i, [[T$i]]>::type type; |
||||
}; |
||||
|
||||
#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P |
||||
|
||||
} // namespace internal |
||||
} // namespace testing |
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ |
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,363 @@
|
||||
# This was retrieved from |
||||
# http://svn.0pointer.de/viewvc/trunk/common/acx_pthread.m4?revision=1277&root=avahi |
||||
# See also (perhaps for new versions?) |
||||
# http://svn.0pointer.de/viewvc/trunk/common/acx_pthread.m4?root=avahi |
||||
# |
||||
# We've rewritten the inconsistency check code (from avahi), to work |
||||
# more broadly. In particular, it no longer assumes ld accepts -zdefs. |
||||
# This caused a restructing of the code, but the functionality has only |
||||
# changed a little. |
||||
|
||||
dnl @synopsis ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) |
||||
dnl |
||||
dnl @summary figure out how to build C programs using POSIX threads |
||||
dnl |
||||
dnl This macro figures out how to build C programs using POSIX threads. |
||||
dnl It sets the PTHREAD_LIBS output variable to the threads library and |
||||
dnl linker flags, and the PTHREAD_CFLAGS output variable to any special |
||||
dnl C compiler flags that are needed. (The user can also force certain |
||||
dnl compiler flags/libs to be tested by setting these environment |
||||
dnl variables.) |
||||
dnl |
||||
dnl Also sets PTHREAD_CC to any special C compiler that is needed for |
||||
dnl multi-threaded programs (defaults to the value of CC otherwise). |
||||
dnl (This is necessary on AIX to use the special cc_r compiler alias.) |
||||
dnl |
||||
dnl NOTE: You are assumed to not only compile your program with these |
||||
dnl flags, but also link it with them as well. e.g. you should link |
||||
dnl with $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS |
||||
dnl $LIBS |
||||
dnl |
||||
dnl If you are only building threads programs, you may wish to use |
||||
dnl these variables in your default LIBS, CFLAGS, and CC: |
||||
dnl |
||||
dnl LIBS="$PTHREAD_LIBS $LIBS" |
||||
dnl CFLAGS="$CFLAGS $PTHREAD_CFLAGS" |
||||
dnl CC="$PTHREAD_CC" |
||||
dnl |
||||
dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute |
||||
dnl constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to |
||||
dnl that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX). |
||||
dnl |
||||
dnl ACTION-IF-FOUND is a list of shell commands to run if a threads |
||||
dnl library is found, and ACTION-IF-NOT-FOUND is a list of commands to |
||||
dnl run it if it is not found. If ACTION-IF-FOUND is not specified, the |
||||
dnl default action will define HAVE_PTHREAD. |
||||
dnl |
||||
dnl Please let the authors know if this macro fails on any platform, or |
||||
dnl if you have any other suggestions or comments. This macro was based |
||||
dnl on work by SGJ on autoconf scripts for FFTW (www.fftw.org) (with |
||||
dnl help from M. Frigo), as well as ac_pthread and hb_pthread macros |
||||
dnl posted by Alejandro Forero Cuervo to the autoconf macro repository. |
||||
dnl We are also grateful for the helpful feedback of numerous users. |
||||
dnl |
||||
dnl @category InstalledPackages |
||||
dnl @author Steven G. Johnson <stevenj@alum.mit.edu> |
||||
dnl @version 2006-05-29 |
||||
dnl @license GPLWithACException |
||||
dnl |
||||
dnl Checks for GCC shared/pthread inconsistency based on work by |
||||
dnl Marcin Owsiany <marcin@owsiany.pl> |
||||
|
||||
|
||||
AC_DEFUN([ACX_PTHREAD], [ |
||||
AC_REQUIRE([AC_CANONICAL_HOST]) |
||||
AC_LANG_SAVE |
||||
AC_LANG_C |
||||
acx_pthread_ok=no |
||||
|
||||
# We used to check for pthread.h first, but this fails if pthread.h |
||||
# requires special compiler flags (e.g. on True64 or Sequent). |
||||
# It gets checked for in the link test anyway. |
||||
|
||||
# First of all, check if the user has set any of the PTHREAD_LIBS, |
||||
# etcetera environment variables, and if threads linking works using |
||||
# them: |
||||
if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then |
||||
save_CFLAGS="$CFLAGS" |
||||
CFLAGS="$CFLAGS $PTHREAD_CFLAGS" |
||||
save_LIBS="$LIBS" |
||||
LIBS="$PTHREAD_LIBS $LIBS" |
||||
AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS]) |
||||
AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes) |
||||
AC_MSG_RESULT($acx_pthread_ok) |
||||
if test x"$acx_pthread_ok" = xno; then |
||||
PTHREAD_LIBS="" |
||||
PTHREAD_CFLAGS="" |
||||
fi |
||||
LIBS="$save_LIBS" |
||||
CFLAGS="$save_CFLAGS" |
||||
fi |
||||
|
||||
# We must check for the threads library under a number of different |
||||
# names; the ordering is very important because some systems |
||||
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the |
||||
# libraries is broken (non-POSIX). |
||||
|
||||
# Create a list of thread flags to try. Items starting with a "-" are |
||||
# C compiler flags, and other items are library names, except for "none" |
||||
# which indicates that we try without any flags at all, and "pthread-config" |
||||
# which is a program returning the flags for the Pth emulation library. |
||||
|
||||
acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" |
||||
|
||||
# The ordering *is* (sometimes) important. Some notes on the |
||||
# individual items follow: |
||||
|
||||
# pthreads: AIX (must check this before -lpthread) |
||||
# none: in case threads are in libc; should be tried before -Kthread and |
||||
# other compiler flags to prevent continual compiler warnings |
||||
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) |
||||
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) |
||||
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) |
||||
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) |
||||
# -pthreads: Solaris/gcc |
||||
# -mthreads: Mingw32/gcc, Lynx/gcc |
||||
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it |
||||
# doesn't hurt to check since this sometimes defines pthreads too; |
||||
# also defines -D_REENTRANT) |
||||
# ... -mt is also the pthreads flag for HP/aCC |
||||
# pthread: Linux, etcetera |
||||
# --thread-safe: KAI C++ |
||||
# pthread-config: use pthread-config program (for GNU Pth library) |
||||
|
||||
case "${host_cpu}-${host_os}" in |
||||
*solaris*) |
||||
|
||||
# On Solaris (at least, for some versions), libc contains stubbed |
||||
# (non-functional) versions of the pthreads routines, so link-based |
||||
# tests will erroneously succeed. (We need to link with -pthreads/-mt/ |
||||
# -lpthread.) (The stubs are missing pthread_cleanup_push, or rather |
||||
# a function called by this macro, so we could check for that, but |
||||
# who knows whether they'll stub that too in a future libc.) So, |
||||
# we'll just look for -pthreads and -lpthread first: |
||||
|
||||
acx_pthread_flags="-pthreads pthread -mt -pthread $acx_pthread_flags" |
||||
;; |
||||
esac |
||||
|
||||
if test x"$acx_pthread_ok" = xno; then |
||||
for flag in $acx_pthread_flags; do |
||||
|
||||
case $flag in |
||||
none) |
||||
AC_MSG_CHECKING([whether pthreads work without any flags]) |
||||
;; |
||||
|
||||
-*) |
||||
AC_MSG_CHECKING([whether pthreads work with $flag]) |
||||
PTHREAD_CFLAGS="$flag" |
||||
;; |
||||
|
||||
pthread-config) |
||||
AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no) |
||||
if test x"$acx_pthread_config" = xno; then continue; fi |
||||
PTHREAD_CFLAGS="`pthread-config --cflags`" |
||||
PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" |
||||
;; |
||||
|
||||
*) |
||||
AC_MSG_CHECKING([for the pthreads library -l$flag]) |
||||
PTHREAD_LIBS="-l$flag" |
||||
;; |
||||
esac |
||||
|
||||
save_LIBS="$LIBS" |
||||
save_CFLAGS="$CFLAGS" |
||||
LIBS="$PTHREAD_LIBS $LIBS" |
||||
CFLAGS="$CFLAGS $PTHREAD_CFLAGS" |
||||
|
||||
# Check for various functions. We must include pthread.h, |
||||
# since some functions may be macros. (On the Sequent, we |
||||
# need a special flag -Kthread to make this header compile.) |
||||
# We check for pthread_join because it is in -lpthread on IRIX |
||||
# while pthread_create is in libc. We check for pthread_attr_init |
||||
# due to DEC craziness with -lpthreads. We check for |
||||
# pthread_cleanup_push because it is one of the few pthread |
||||
# functions on Solaris that doesn't have a non-functional libc stub. |
||||
# We try pthread_create on general principles. |
||||
AC_TRY_LINK([#include <pthread.h>], |
||||
[pthread_t th; pthread_join(th, 0); |
||||
pthread_attr_init(0); pthread_cleanup_push(0, 0); |
||||
pthread_create(0,0,0,0); pthread_cleanup_pop(0); ], |
||||
[acx_pthread_ok=yes]) |
||||
|
||||
LIBS="$save_LIBS" |
||||
CFLAGS="$save_CFLAGS" |
||||
|
||||
AC_MSG_RESULT($acx_pthread_ok) |
||||
if test "x$acx_pthread_ok" = xyes; then |
||||
break; |
||||
fi |
||||
|
||||
PTHREAD_LIBS="" |
||||
PTHREAD_CFLAGS="" |
||||
done |
||||
fi |
||||
|
||||
# Various other checks: |
||||
if test "x$acx_pthread_ok" = xyes; then |
||||
save_LIBS="$LIBS" |
||||
LIBS="$PTHREAD_LIBS $LIBS" |
||||
save_CFLAGS="$CFLAGS" |
||||
CFLAGS="$CFLAGS $PTHREAD_CFLAGS" |
||||
|
||||
# Detect AIX lossage: JOINABLE attribute is called UNDETACHED. |
||||
AC_MSG_CHECKING([for joinable pthread attribute]) |
||||
attr_name=unknown |
||||
for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do |
||||
AC_TRY_LINK([#include <pthread.h>], [int attr=$attr; return attr;], |
||||
[attr_name=$attr; break]) |
||||
done |
||||
AC_MSG_RESULT($attr_name) |
||||
if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then |
||||
AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name, |
||||
[Define to necessary symbol if this constant |
||||
uses a non-standard name on your system.]) |
||||
fi |
||||
|
||||
AC_MSG_CHECKING([if more special flags are required for pthreads]) |
||||
flag=no |
||||
case "${host_cpu}-${host_os}" in |
||||
*-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";; |
||||
*solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";; |
||||
esac |
||||
AC_MSG_RESULT(${flag}) |
||||
if test "x$flag" != xno; then |
||||
PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS" |
||||
fi |
||||
|
||||
LIBS="$save_LIBS" |
||||
CFLAGS="$save_CFLAGS" |
||||
# More AIX lossage: must compile with xlc_r or cc_r |
||||
if test x"$GCC" != xyes; then |
||||
AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC}) |
||||
else |
||||
PTHREAD_CC=$CC |
||||
fi |
||||
|
||||
# The next part tries to detect GCC inconsistency with -shared on some |
||||
# architectures and systems. The problem is that in certain |
||||
# configurations, when -shared is specified, GCC "forgets" to |
||||
# internally use various flags which are still necessary. |
||||
|
||||
# |
||||
# Prepare the flags |
||||
# |
||||
save_CFLAGS="$CFLAGS" |
||||
save_LIBS="$LIBS" |
||||
save_CC="$CC" |
||||
|
||||
# Try with the flags determined by the earlier checks. |
||||
# |
||||
# -Wl,-z,defs forces link-time symbol resolution, so that the |
||||
# linking checks with -shared actually have any value |
||||
# |
||||
# FIXME: -fPIC is required for -shared on many architectures, |
||||
# so we specify it here, but the right way would probably be to |
||||
# properly detect whether it is actually required. |
||||
CFLAGS="-shared -fPIC -Wl,-z,defs $CFLAGS $PTHREAD_CFLAGS" |
||||
LIBS="$PTHREAD_LIBS $LIBS" |
||||
CC="$PTHREAD_CC" |
||||
|
||||
# In order not to create several levels of indentation, we test |
||||
# the value of "$done" until we find the cure or run out of ideas. |
||||
done="no" |
||||
|
||||
# First, make sure the CFLAGS we added are actually accepted by our |
||||
# compiler. If not (and OS X's ld, for instance, does not accept -z), |
||||
# then we can't do this test. |
||||
if test x"$done" = xno; then |
||||
AC_MSG_CHECKING([whether to check for GCC pthread/shared inconsistencies]) |
||||
AC_TRY_LINK(,, , [done=yes]) |
||||
|
||||
if test "x$done" = xyes ; then |
||||
AC_MSG_RESULT([no]) |
||||
else |
||||
AC_MSG_RESULT([yes]) |
||||
fi |
||||
fi |
||||
|
||||
if test x"$done" = xno; then |
||||
AC_MSG_CHECKING([whether -pthread is sufficient with -shared]) |
||||
AC_TRY_LINK([#include <pthread.h>], |
||||
[pthread_t th; pthread_join(th, 0); |
||||
pthread_attr_init(0); pthread_cleanup_push(0, 0); |
||||
pthread_create(0,0,0,0); pthread_cleanup_pop(0); ], |
||||
[done=yes]) |
||||
|
||||
if test "x$done" = xyes; then |
||||
AC_MSG_RESULT([yes]) |
||||
else |
||||
AC_MSG_RESULT([no]) |
||||
fi |
||||
fi |
||||
|
||||
# |
||||
# Linux gcc on some architectures such as mips/mipsel forgets |
||||
# about -lpthread |
||||
# |
||||
if test x"$done" = xno; then |
||||
AC_MSG_CHECKING([whether -lpthread fixes that]) |
||||
LIBS="-lpthread $PTHREAD_LIBS $save_LIBS" |
||||
AC_TRY_LINK([#include <pthread.h>], |
||||
[pthread_t th; pthread_join(th, 0); |
||||
pthread_attr_init(0); pthread_cleanup_push(0, 0); |
||||
pthread_create(0,0,0,0); pthread_cleanup_pop(0); ], |
||||
[done=yes]) |
||||
|
||||
if test "x$done" = xyes; then |
||||
AC_MSG_RESULT([yes]) |
||||
PTHREAD_LIBS="-lpthread $PTHREAD_LIBS" |
||||
else |
||||
AC_MSG_RESULT([no]) |
||||
fi |
||||
fi |
||||
# |
||||
# FreeBSD 4.10 gcc forgets to use -lc_r instead of -lc |
||||
# |
||||
if test x"$done" = xno; then |
||||
AC_MSG_CHECKING([whether -lc_r fixes that]) |
||||
LIBS="-lc_r $PTHREAD_LIBS $save_LIBS" |
||||
AC_TRY_LINK([#include <pthread.h>], |
||||
[pthread_t th; pthread_join(th, 0); |
||||
pthread_attr_init(0); pthread_cleanup_push(0, 0); |
||||
pthread_create(0,0,0,0); pthread_cleanup_pop(0); ], |
||||
[done=yes]) |
||||
|
||||
if test "x$done" = xyes; then |
||||
AC_MSG_RESULT([yes]) |
||||
PTHREAD_LIBS="-lc_r $PTHREAD_LIBS" |
||||
else |
||||
AC_MSG_RESULT([no]) |
||||
fi |
||||
fi |
||||
if test x"$done" = xno; then |
||||
# OK, we have run out of ideas |
||||
AC_MSG_WARN([Impossible to determine how to use pthreads with shared libraries]) |
||||
|
||||
# so it's not safe to assume that we may use pthreads |
||||
acx_pthread_ok=no |
||||
fi |
||||
|
||||
CFLAGS="$save_CFLAGS" |
||||
LIBS="$save_LIBS" |
||||
CC="$save_CC" |
||||
else |
||||
PTHREAD_CC="$CC" |
||||
fi |
||||
|
||||
AC_SUBST(PTHREAD_LIBS) |
||||
AC_SUBST(PTHREAD_CFLAGS) |
||||
AC_SUBST(PTHREAD_CC) |
||||
|
||||
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: |
||||
if test x"$acx_pthread_ok" = xyes; then |
||||
ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1]) |
||||
: |
||||
else |
||||
acx_pthread_ok=no |
||||
$2 |
||||
fi |
||||
AC_LANG_RESTORE |
||||
])dnl ACX_PTHREAD |
@ -0,0 +1,74 @@
|
||||
dnl GTEST_LIB_CHECK([minimum version [, |
||||
dnl action if found [,action if not found]]]) |
||||
dnl |
||||
dnl Check for the presence of the Google Test library, optionally at a minimum |
||||
dnl version, and indicate a viable version with the HAVE_GTEST flag. It defines |
||||
dnl standard variables for substitution including GTEST_CPPFLAGS, |
||||
dnl GTEST_CXXFLAGS, GTEST_LDFLAGS, and GTEST_LIBS. It also defines |
||||
dnl GTEST_VERSION as the version of Google Test found. Finally, it provides |
||||
dnl optional custom action slots in the event GTEST is found or not. |
||||
AC_DEFUN([GTEST_LIB_CHECK], |
||||
[ |
||||
dnl Provide a flag to enable or disable Google Test usage. |
||||
AC_ARG_ENABLE([gtest], |
||||
[AS_HELP_STRING([--enable-gtest], |
||||
[Enable tests using the Google C++ Testing Framework. |
||||
(Default is enabled.)])], |
||||
[], |
||||
[enable_gtest=]) |
||||
AC_ARG_VAR([GTEST_CONFIG], |
||||
[The exact path of Google Test's 'gtest-config' script.]) |
||||
AC_ARG_VAR([GTEST_CPPFLAGS], |
||||
[C-like preprocessor flags for Google Test.]) |
||||
AC_ARG_VAR([GTEST_CXXFLAGS], |
||||
[C++ compile flags for Google Test.]) |
||||
AC_ARG_VAR([GTEST_LDFLAGS], |
||||
[Linker path and option flags for Google Test.]) |
||||
AC_ARG_VAR([GTEST_LIBS], |
||||
[Library linking flags for Google Test.]) |
||||
AC_ARG_VAR([GTEST_VERSION], |
||||
[The version of Google Test available.]) |
||||
HAVE_GTEST="no" |
||||
AS_IF([test "x${enable_gtest}" != "xno"], |
||||
[AC_MSG_CHECKING([for 'gtest-config']) |
||||
AS_IF([test "x${enable_gtest}" != "xyes"], |
||||
[AS_IF([test -x "${enable_gtest}/scripts/gtest-config"], |
||||
[GTEST_CONFIG="${enable_gtest}/scripts/gtest-config"], |
||||
[GTEST_CONFIG="${enable_gtest}/bin/gtest-config"]) |
||||
AS_IF([test -x "${GTEST_CONFIG}"], [], |
||||
[AC_MSG_RESULT([no]) |
||||
AC_MSG_ERROR([dnl |
||||
Unable to locate either a built or installed Google Test. |
||||
The specific location '${enable_gtest}' was provided for a built or installed |
||||
Google Test, but no 'gtest-config' script could be found at this location.]) |
||||
])], |
||||
[AC_PATH_PROG([GTEST_CONFIG], [gtest-config])]) |
||||
AS_IF([test -x "${GTEST_CONFIG}"], |
||||
[AC_MSG_RESULT([${GTEST_CONFIG}]) |
||||
m4_ifval([$1], |
||||
[_gtest_min_version="--min-version=$1" |
||||
AC_MSG_CHECKING([for Google Test at least version >= $1])], |
||||
[_gtest_min_version="--min-version=0" |
||||
AC_MSG_CHECKING([for Google Test])]) |
||||
AS_IF([${GTEST_CONFIG} ${_gtest_min_version}], |
||||
[AC_MSG_RESULT([yes]) |
||||
HAVE_GTEST='yes'], |
||||
[AC_MSG_RESULT([no])])], |
||||
[AC_MSG_RESULT([no])]) |
||||
AS_IF([test "x${HAVE_GTEST}" = "xyes"], |
||||
[GTEST_CPPFLAGS=`${GTEST_CONFIG} --cppflags` |
||||
GTEST_CXXFLAGS=`${GTEST_CONFIG} --cxxflags` |
||||
GTEST_LDFLAGS=`${GTEST_CONFIG} --ldflags` |
||||
GTEST_LIBS=`${GTEST_CONFIG} --libs` |
||||
GTEST_VERSION=`${GTEST_CONFIG} --version` |
||||
AC_DEFINE([HAVE_GTEST],[1],[Defined when Google Test is available.])], |
||||
[AS_IF([test "x${enable_gtest}" = "xyes"], |
||||
[AC_MSG_ERROR([dnl |
||||
Google Test was enabled, but no viable version could be found.]) |
||||
])])]) |
||||
AC_SUBST([HAVE_GTEST]) |
||||
AM_CONDITIONAL([HAVE_GTEST],[test "x$HAVE_GTEST" = "xyes"]) |
||||
AS_IF([test "x$HAVE_GTEST" = "xyes"], |
||||
[m4_ifval([$2], [$2])], |
||||
[m4_ifval([$3], [$3])]) |
||||
]) |
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,368 @@
|
||||
# Helper functions for option handling. -*- Autoconf -*- |
||||
# |
||||
# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. |
||||
# Written by Gary V. Vaughan, 2004 |
||||
# |
||||
# This file is free software; the Free Software Foundation gives |
||||
# unlimited permission to copy and/or distribute it, with or without |
||||
# modifications, as long as this notice is preserved. |
||||
|
||||
# serial 6 ltoptions.m4 |
||||
|
||||
# This is to help aclocal find these macros, as it can't see m4_define. |
||||
AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) |
||||
|
||||
|
||||
# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME) |
||||
# ------------------------------------------ |
||||
m4_define([_LT_MANGLE_OPTION], |
||||
[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])]) |
||||
|
||||
|
||||
# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME) |
||||
# --------------------------------------- |
||||
# Set option OPTION-NAME for macro MACRO-NAME, and if there is a |
||||
# matching handler defined, dispatch to it. Other OPTION-NAMEs are |
||||
# saved as a flag. |
||||
m4_define([_LT_SET_OPTION], |
||||
[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl |
||||
m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), |
||||
_LT_MANGLE_DEFUN([$1], [$2]), |
||||
[m4_warning([Unknown $1 option `$2'])])[]dnl |
||||
]) |
||||
|
||||
|
||||
# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET]) |
||||
# ------------------------------------------------------------ |
||||
# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. |
||||
m4_define([_LT_IF_OPTION], |
||||
[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])]) |
||||
|
||||
|
||||
# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET) |
||||
# ------------------------------------------------------- |
||||
# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME |
||||
# are set. |
||||
m4_define([_LT_UNLESS_OPTIONS], |
||||
[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), |
||||
[m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option), |
||||
[m4_define([$0_found])])])[]dnl |
||||
m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3 |
||||
])[]dnl |
||||
]) |
||||
|
||||
|
||||
# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST) |
||||
# ---------------------------------------- |
||||
# OPTION-LIST is a space-separated list of Libtool options associated |
||||
# with MACRO-NAME. If any OPTION has a matching handler declared with |
||||
# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about |
||||
# the unknown option and exit. |
||||
m4_defun([_LT_SET_OPTIONS], |
||||
[# Set options |
||||
m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), |
||||
[_LT_SET_OPTION([$1], _LT_Option)]) |
||||
|
||||
m4_if([$1],[LT_INIT],[ |
||||
dnl |
||||
dnl Simply set some default values (i.e off) if boolean options were not |
||||
dnl specified: |
||||
_LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no |
||||
]) |
||||
_LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no |
||||
]) |
||||
dnl |
||||
dnl If no reference was made to various pairs of opposing options, then |
||||
dnl we run the default mode handler for the pair. For example, if neither |
||||
dnl `shared' nor `disable-shared' was passed, we enable building of shared |
||||
dnl archives by default: |
||||
_LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) |
||||
_LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) |
||||
_LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) |
||||
_LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], |
||||
[_LT_ENABLE_FAST_INSTALL]) |
||||
]) |
||||
])# _LT_SET_OPTIONS |
||||
|
||||
|
||||
## --------------------------------- ## |
||||
## Macros to handle LT_INIT options. ## |
||||
## --------------------------------- ## |
||||
|
||||
# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME) |
||||
# ----------------------------------------- |
||||
m4_define([_LT_MANGLE_DEFUN], |
||||
[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])]) |
||||
|
||||
|
||||
# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE) |
||||
# ----------------------------------------------- |
||||
m4_define([LT_OPTION_DEFINE], |
||||
[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl |
||||
])# LT_OPTION_DEFINE |
||||
|
||||
|
||||
# dlopen |
||||
# ------ |
||||
LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes |
||||
]) |
||||
|
||||
AU_DEFUN([AC_LIBTOOL_DLOPEN], |
||||
[_LT_SET_OPTION([LT_INIT], [dlopen]) |
||||
AC_DIAGNOSE([obsolete], |
||||
[$0: Remove this warning and the call to _LT_SET_OPTION when you |
||||
put the `dlopen' option into LT_INIT's first parameter.]) |
||||
]) |
||||
|
||||
dnl aclocal-1.4 backwards compatibility: |
||||
dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], []) |
||||
|
||||
|
||||
# win32-dll |
||||
# --------- |
||||
# Declare package support for building win32 dll's. |
||||
LT_OPTION_DEFINE([LT_INIT], [win32-dll], |
||||
[enable_win32_dll=yes |
||||
|
||||
case $host in |
||||
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-cegcc*) |
||||
AC_CHECK_TOOL(AS, as, false) |
||||
AC_CHECK_TOOL(DLLTOOL, dlltool, false) |
||||
AC_CHECK_TOOL(OBJDUMP, objdump, false) |
||||
;; |
||||
esac |
||||
|
||||
test -z "$AS" && AS=as |
||||
_LT_DECL([], [AS], [0], [Assembler program])dnl |
||||
|
||||
test -z "$DLLTOOL" && DLLTOOL=dlltool |
||||
_LT_DECL([], [DLLTOOL], [0], [DLL creation program])dnl |
||||
|
||||
test -z "$OBJDUMP" && OBJDUMP=objdump |
||||
_LT_DECL([], [OBJDUMP], [0], [Object dumper program])dnl |
||||
])# win32-dll |
||||
|
||||
AU_DEFUN([AC_LIBTOOL_WIN32_DLL], |
||||
[AC_REQUIRE([AC_CANONICAL_HOST])dnl |
||||
_LT_SET_OPTION([LT_INIT], [win32-dll]) |
||||
AC_DIAGNOSE([obsolete], |
||||
[$0: Remove this warning and the call to _LT_SET_OPTION when you |
||||
put the `win32-dll' option into LT_INIT's first parameter.]) |
||||
]) |
||||
|
||||
dnl aclocal-1.4 backwards compatibility: |
||||
dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) |
||||
|
||||
|
||||
# _LT_ENABLE_SHARED([DEFAULT]) |
||||
# ---------------------------- |
||||
# implement the --enable-shared flag, and supports the `shared' and |
||||
# `disable-shared' LT_INIT options. |
||||
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. |
||||
m4_define([_LT_ENABLE_SHARED], |
||||
[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl |
||||
AC_ARG_ENABLE([shared], |
||||
[AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@], |
||||
[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])], |
||||
[p=${PACKAGE-default} |
||||
case $enableval in |
||||
yes) enable_shared=yes ;; |
||||
no) enable_shared=no ;; |
||||
*) |
||||
enable_shared=no |
||||
# Look at the argument we got. We use all the common list separators. |
||||
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," |
||||
for pkg in $enableval; do |
||||
IFS="$lt_save_ifs" |
||||
if test "X$pkg" = "X$p"; then |
||||
enable_shared=yes |
||||
fi |
||||
done |
||||
IFS="$lt_save_ifs" |
||||
;; |
||||
esac], |
||||
[enable_shared=]_LT_ENABLE_SHARED_DEFAULT) |
||||
|
||||
_LT_DECL([build_libtool_libs], [enable_shared], [0], |
||||
[Whether or not to build shared libraries]) |
||||
])# _LT_ENABLE_SHARED |
||||
|
||||
LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])]) |
||||
LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])]) |
||||
|
||||
# Old names: |
||||
AC_DEFUN([AC_ENABLE_SHARED], |
||||
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) |
||||
]) |
||||
|
||||
AC_DEFUN([AC_DISABLE_SHARED], |
||||
[_LT_SET_OPTION([LT_INIT], [disable-shared]) |
||||
]) |
||||
|
||||
AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) |
||||
AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) |
||||
|
||||
dnl aclocal-1.4 backwards compatibility: |
||||
dnl AC_DEFUN([AM_ENABLE_SHARED], []) |
||||
dnl AC_DEFUN([AM_DISABLE_SHARED], []) |
||||
|
||||
|
||||
|
||||
# _LT_ENABLE_STATIC([DEFAULT]) |
||||
# ---------------------------- |
||||
# implement the --enable-static flag, and support the `static' and |
||||
# `disable-static' LT_INIT options. |
||||
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. |
||||
m4_define([_LT_ENABLE_STATIC], |
||||
[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl |
||||
AC_ARG_ENABLE([static], |
||||
[AS_HELP_STRING([--enable-static@<:@=PKGS@:>@], |
||||
[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])], |
||||
[p=${PACKAGE-default} |
||||
case $enableval in |
||||
yes) enable_static=yes ;; |
||||
no) enable_static=no ;; |
||||
*) |
||||
enable_static=no |
||||
# Look at the argument we got. We use all the common list separators. |
||||
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," |
||||
for pkg in $enableval; do |
||||
IFS="$lt_save_ifs" |
||||
if test "X$pkg" = "X$p"; then |
||||
enable_static=yes |
||||
fi |
||||
done |
||||
IFS="$lt_save_ifs" |
||||
;; |
||||
esac], |
||||
[enable_static=]_LT_ENABLE_STATIC_DEFAULT) |
||||
|
||||
_LT_DECL([build_old_libs], [enable_static], [0], |
||||
[Whether or not to build static libraries]) |
||||
])# _LT_ENABLE_STATIC |
||||
|
||||
LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])]) |
||||
LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])]) |
||||
|
||||
# Old names: |
||||
AC_DEFUN([AC_ENABLE_STATIC], |
||||
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) |
||||
]) |
||||
|
||||
AC_DEFUN([AC_DISABLE_STATIC], |
||||
[_LT_SET_OPTION([LT_INIT], [disable-static]) |
||||
]) |
||||
|
||||
AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) |
||||
AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) |
||||
|
||||
dnl aclocal-1.4 backwards compatibility: |
||||
dnl AC_DEFUN([AM_ENABLE_STATIC], []) |
||||
dnl AC_DEFUN([AM_DISABLE_STATIC], []) |
||||
|
||||
|
||||
|
||||
# _LT_ENABLE_FAST_INSTALL([DEFAULT]) |
||||
# ---------------------------------- |
||||
# implement the --enable-fast-install flag, and support the `fast-install' |
||||
# and `disable-fast-install' LT_INIT options. |
||||
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. |
||||
m4_define([_LT_ENABLE_FAST_INSTALL], |
||||
[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl |
||||
AC_ARG_ENABLE([fast-install], |
||||
[AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], |
||||
[optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], |
||||
[p=${PACKAGE-default} |
||||
case $enableval in |
||||
yes) enable_fast_install=yes ;; |
||||
no) enable_fast_install=no ;; |
||||
*) |
||||
enable_fast_install=no |
||||
# Look at the argument we got. We use all the common list separators. |
||||
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," |
||||
for pkg in $enableval; do |
||||
IFS="$lt_save_ifs" |
||||
if test "X$pkg" = "X$p"; then |
||||
enable_fast_install=yes |
||||
fi |
||||
done |
||||
IFS="$lt_save_ifs" |
||||
;; |
||||
esac], |
||||
[enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) |
||||
|
||||
_LT_DECL([fast_install], [enable_fast_install], [0], |
||||
[Whether or not to optimize for fast installation])dnl |
||||
])# _LT_ENABLE_FAST_INSTALL |
||||
|
||||
LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])]) |
||||
LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])]) |
||||
|
||||
# Old names: |
||||
AU_DEFUN([AC_ENABLE_FAST_INSTALL], |
||||
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) |
||||
AC_DIAGNOSE([obsolete], |
||||
[$0: Remove this warning and the call to _LT_SET_OPTION when you put |
||||
the `fast-install' option into LT_INIT's first parameter.]) |
||||
]) |
||||
|
||||
AU_DEFUN([AC_DISABLE_FAST_INSTALL], |
||||
[_LT_SET_OPTION([LT_INIT], [disable-fast-install]) |
||||
AC_DIAGNOSE([obsolete], |
||||
[$0: Remove this warning and the call to _LT_SET_OPTION when you put |
||||
the `disable-fast-install' option into LT_INIT's first parameter.]) |
||||
]) |
||||
|
||||
dnl aclocal-1.4 backwards compatibility: |
||||
dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) |
||||
dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) |
||||
|
||||
|
||||
# _LT_WITH_PIC([MODE]) |
||||
# -------------------- |
||||
# implement the --with-pic flag, and support the `pic-only' and `no-pic' |
||||
# LT_INIT options. |
||||
# MODE is either `yes' or `no'. If omitted, it defaults to `both'. |
||||
m4_define([_LT_WITH_PIC], |
||||
[AC_ARG_WITH([pic], |
||||
[AS_HELP_STRING([--with-pic], |
||||
[try to use only PIC/non-PIC objects @<:@default=use both@:>@])], |
||||
[pic_mode="$withval"], |
||||
[pic_mode=default]) |
||||
|
||||
test -z "$pic_mode" && pic_mode=m4_default([$1], [default]) |
||||
|
||||
_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl |
||||
])# _LT_WITH_PIC |
||||
|
||||
LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])]) |
||||
LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])]) |
||||
|
||||
# Old name: |
||||
AU_DEFUN([AC_LIBTOOL_PICMODE], |
||||
[_LT_SET_OPTION([LT_INIT], [pic-only]) |
||||
AC_DIAGNOSE([obsolete], |
||||
[$0: Remove this warning and the call to _LT_SET_OPTION when you |
||||
put the `pic-only' option into LT_INIT's first parameter.]) |
||||
]) |
||||
|
||||
dnl aclocal-1.4 backwards compatibility: |
||||
dnl AC_DEFUN([AC_LIBTOOL_PICMODE], []) |
||||
|
||||
## ----------------- ## |
||||
## LTDL_INIT Options ## |
||||
## ----------------- ## |
||||
|
||||
m4_define([_LTDL_MODE], []) |
||||
LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive], |
||||
[m4_define([_LTDL_MODE], [nonrecursive])]) |
||||
LT_OPTION_DEFINE([LTDL_INIT], [recursive], |
||||
[m4_define([_LTDL_MODE], [recursive])]) |
||||
LT_OPTION_DEFINE([LTDL_INIT], [subproject], |
||||
[m4_define([_LTDL_MODE], [subproject])]) |
||||
|
||||
m4_define([_LTDL_TYPE], []) |
||||
LT_OPTION_DEFINE([LTDL_INIT], [installable], |
||||
[m4_define([_LTDL_TYPE], [installable])]) |
||||
LT_OPTION_DEFINE([LTDL_INIT], [convenience], |
||||
[m4_define([_LTDL_TYPE], [convenience])]) |
@ -0,0 +1,123 @@
|
||||
# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- |
||||
# |
||||
# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. |
||||
# Written by Gary V. Vaughan, 2004 |
||||
# |
||||
# This file is free software; the Free Software Foundation gives |
||||
# unlimited permission to copy and/or distribute it, with or without |
||||
# modifications, as long as this notice is preserved. |
||||
|
||||
# serial 6 ltsugar.m4 |
||||
|
||||
# This is to help aclocal find these macros, as it can't see m4_define. |
||||
AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) |
||||
|
||||
|
||||
# lt_join(SEP, ARG1, [ARG2...]) |
||||
# ----------------------------- |
||||
# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their |
||||
# associated separator. |
||||
# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier |
||||
# versions in m4sugar had bugs. |
||||
m4_define([lt_join], |
||||
[m4_if([$#], [1], [], |
||||
[$#], [2], [[$2]], |
||||
[m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])]) |
||||
m4_define([_lt_join], |
||||
[m4_if([$#$2], [2], [], |
||||
[m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])]) |
||||
|
||||
|
||||
# lt_car(LIST) |
||||
# lt_cdr(LIST) |
||||
# ------------ |
||||
# Manipulate m4 lists. |
||||
# These macros are necessary as long as will still need to support |
||||
# Autoconf-2.59 which quotes differently. |
||||
m4_define([lt_car], [[$1]]) |
||||
m4_define([lt_cdr], |
||||
[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], |
||||
[$#], 1, [], |
||||
[m4_dquote(m4_shift($@))])]) |
||||
m4_define([lt_unquote], $1) |
||||
|
||||
|
||||
# lt_append(MACRO-NAME, STRING, [SEPARATOR]) |
||||
# ------------------------------------------ |
||||
# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'. |
||||
# Note that neither SEPARATOR nor STRING are expanded; they are appended |
||||
# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). |
||||
# No SEPARATOR is output if MACRO-NAME was previously undefined (different |
||||
# than defined and empty). |
||||
# |
||||
# This macro is needed until we can rely on Autoconf 2.62, since earlier |
||||
# versions of m4sugar mistakenly expanded SEPARATOR but not STRING. |
||||
m4_define([lt_append], |
||||
[m4_define([$1], |
||||
m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])]) |
||||
|
||||
|
||||
|
||||
# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...]) |
||||
# ---------------------------------------------------------- |
||||
# Produce a SEP delimited list of all paired combinations of elements of |
||||
# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list |
||||
# has the form PREFIXmINFIXSUFFIXn. |
||||
# Needed until we can rely on m4_combine added in Autoconf 2.62. |
||||
m4_define([lt_combine], |
||||
[m4_if(m4_eval([$# > 3]), [1], |
||||
[m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl |
||||
[[m4_foreach([_Lt_prefix], [$2], |
||||
[m4_foreach([_Lt_suffix], |
||||
]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[, |
||||
[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])]) |
||||
|
||||
|
||||
# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ]) |
||||
# ----------------------------------------------------------------------- |
||||
# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited |
||||
# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ. |
||||
m4_define([lt_if_append_uniq], |
||||
[m4_ifdef([$1], |
||||
[m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1], |
||||
[lt_append([$1], [$2], [$3])$4], |
||||
[$5])], |
||||
[lt_append([$1], [$2], [$3])$4])]) |
||||
|
||||
|
||||
# lt_dict_add(DICT, KEY, VALUE) |
||||
# ----------------------------- |
||||
m4_define([lt_dict_add], |
||||
[m4_define([$1($2)], [$3])]) |
||||
|
||||
|
||||
# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE) |
||||
# -------------------------------------------- |
||||
m4_define([lt_dict_add_subkey], |
||||
[m4_define([$1($2:$3)], [$4])]) |
||||
|
||||
|
||||
# lt_dict_fetch(DICT, KEY, [SUBKEY]) |
||||
# ---------------------------------- |
||||
m4_define([lt_dict_fetch], |
||||
[m4_ifval([$3], |
||||
m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]), |
||||
m4_ifdef([$1($2)], [m4_defn([$1($2)])]))]) |
||||
|
||||
|
||||
# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE]) |
||||
# ----------------------------------------------------------------- |
||||
m4_define([lt_if_dict_fetch], |
||||
[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4], |
||||
[$5], |
||||
[$6])]) |
||||
|
||||
|
||||
# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...]) |
||||
# -------------------------------------------------------------- |
||||
m4_define([lt_dict_filter], |
||||
[m4_if([$5], [], [], |
||||
[lt_join(m4_quote(m4_default([$4], [[, ]])), |
||||
lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]), |
||||
[lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl |
||||
]) |
@ -0,0 +1,23 @@
|
||||
# ltversion.m4 -- version numbers -*- Autoconf -*- |
||||
# |
||||
# Copyright (C) 2004 Free Software Foundation, Inc. |
||||
# Written by Scott James Remnant, 2004 |
||||
# |
||||
# This file is free software; the Free Software Foundation gives |
||||
# unlimited permission to copy and/or distribute it, with or without |
||||
# modifications, as long as this notice is preserved. |
||||
|
||||
# Generated from ltversion.in. |
||||
|
||||
# serial 3017 ltversion.m4 |
||||
# This file is part of GNU Libtool |
||||
|
||||
m4_define([LT_PACKAGE_VERSION], [2.2.6b]) |
||||
m4_define([LT_PACKAGE_REVISION], [1.3017]) |
||||
|
||||
AC_DEFUN([LTVERSION_VERSION], |
||||
[macro_version='2.2.6b' |
||||
macro_revision='1.3017' |
||||
_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) |
||||
_LT_DECL(, macro_revision, 0) |
||||
]) |
@ -0,0 +1,92 @@
|
||||
# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- |
||||
# |
||||
# Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc. |
||||
# Written by Scott James Remnant, 2004. |
||||
# |
||||
# This file is free software; the Free Software Foundation gives |
||||
# unlimited permission to copy and/or distribute it, with or without |
||||
# modifications, as long as this notice is preserved. |
||||
|
||||
# serial 4 lt~obsolete.m4 |
||||
|
||||
# These exist entirely to fool aclocal when bootstrapping libtool. |
||||
# |
||||
# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN) |
||||
# which have later been changed to m4_define as they aren't part of the |
||||
# exported API, or moved to Autoconf or Automake where they belong. |
||||
# |
||||
# The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN |
||||
# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us |
||||
# using a macro with the same name in our local m4/libtool.m4 it'll |
||||
# pull the old libtool.m4 in (it doesn't see our shiny new m4_define |
||||
# and doesn't know about Autoconf macros at all.) |
||||
# |
||||
# So we provide this file, which has a silly filename so it's always |
||||
# included after everything else. This provides aclocal with the |
||||
# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything |
||||
# because those macros already exist, or will be overwritten later. |
||||
# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. |
||||
# |
||||
# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. |
||||
# Yes, that means every name once taken will need to remain here until |
||||
# we give up compatibility with versions before 1.7, at which point |
||||
# we need to keep only those names which we still refer to. |
||||
|
||||
# This is to help aclocal find these macros, as it can't see m4_define. |
||||
AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) |
||||
|
||||
m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])]) |
||||
m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])]) |
||||
m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])]) |
||||
m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])]) |
||||
m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])]) |
||||
m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])]) |
||||
m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])]) |
||||
m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])]) |
||||
m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])]) |
||||
m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])]) |
||||
m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])]) |
||||
m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])]) |
||||
m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])]) |
||||
m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])]) |
||||
m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])]) |
||||
m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])]) |
||||
m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])]) |
||||
m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])]) |
||||
m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])]) |
||||
m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])]) |
||||
m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])]) |
||||
m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])]) |
||||
m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])]) |
||||
m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])]) |
||||
m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])]) |
||||
m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])]) |
||||
m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])]) |
||||
m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])]) |
||||
m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])]) |
||||
m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])]) |
||||
m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])]) |
||||
m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])]) |
||||
m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])]) |
||||
m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])]) |
||||
m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])]) |
||||
m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])]) |
||||
m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])]) |
||||
m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])]) |
||||
m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])]) |
||||
m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])]) |
||||
m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])]) |
||||
m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])]) |
||||
m4_ifndef([AC_LIBTOOL_RC], [AC_DEFUN([AC_LIBTOOL_RC])]) |
||||
m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])]) |
||||
m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])]) |
||||
m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])]) |
||||
m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])]) |
||||
m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])]) |
||||
m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])]) |
||||
m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])]) |
||||
m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])]) |
||||
m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])]) |
||||
m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])]) |
||||
m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])]) |
||||
m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])]) |
@ -0,0 +1,45 @@
|
||||
Microsoft Visual Studio Solution File, Format Version 8.00 |
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest-md", "gtest-md.vcproj", "{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}" |
||||
ProjectSection(ProjectDependencies) = postProject |
||||
EndProjectSection |
||||
EndProject |
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_main-md", "gtest_main-md.vcproj", "{3AF54C8A-10BF-4332-9147-F68ED9862033}" |
||||
ProjectSection(ProjectDependencies) = postProject |
||||
EndProjectSection |
||||
EndProject |
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_prod_test-md", "gtest_prod_test-md.vcproj", "{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}" |
||||
ProjectSection(ProjectDependencies) = postProject |
||||
EndProjectSection |
||||
EndProject |
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_unittest-md", "gtest_unittest-md.vcproj", "{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}" |
||||
ProjectSection(ProjectDependencies) = postProject |
||||
EndProjectSection |
||||
EndProject |
||||
Global |
||||
GlobalSection(SolutionConfiguration) = preSolution |
||||
Debug = Debug |
||||
Release = Release |
||||
EndGlobalSection |
||||
GlobalSection(ProjectConfiguration) = postSolution |
||||
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug.ActiveCfg = Debug|Win32 |
||||
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug.Build.0 = Debug|Win32 |
||||
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release.ActiveCfg = Release|Win32 |
||||
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release.Build.0 = Release|Win32 |
||||
{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug.ActiveCfg = Debug|Win32 |
||||
{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug.Build.0 = Debug|Win32 |
||||
{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release.ActiveCfg = Release|Win32 |
||||
{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release.Build.0 = Release|Win32 |
||||
{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Debug.ActiveCfg = Debug|Win32 |
||||
{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Debug.Build.0 = Debug|Win32 |
||||
{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Release.ActiveCfg = Release|Win32 |
||||
{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Release.Build.0 = Release|Win32 |
||||
{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Debug.ActiveCfg = Debug|Win32 |
||||
{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Debug.Build.0 = Debug|Win32 |
||||
{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Release.ActiveCfg = Release|Win32 |
||||
{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Release.Build.0 = Release|Win32 |
||||
EndGlobalSection |
||||
GlobalSection(ExtensibilityGlobals) = postSolution |
||||
EndGlobalSection |
||||
GlobalSection(ExtensibilityAddIns) = postSolution |
||||
EndGlobalSection |
||||
EndGlobal |
@ -0,0 +1,126 @@
|
||||
<?xml version="1.0" encoding="Windows-1252"?> |
||||
<VisualStudioProject |
||||
ProjectType="Visual C++" |
||||
Version="7.10" |
||||
Name="gtest-md" |
||||
ProjectGUID="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}" |
||||
Keyword="Win32Proj"> |
||||
<Platforms> |
||||
<Platform |
||||
Name="Win32"/> |
||||
</Platforms> |
||||
<Configurations> |
||||
<Configuration |
||||
Name="Debug|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="4" |
||||
CharacterSet="2" |
||||
ReferencesPath=""> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="0" |
||||
PreprocessorDefinitions="WIN32;_DEBUG;_LIB" |
||||
MinimalRebuild="TRUE" |
||||
BasicRuntimeChecks="3" |
||||
RuntimeLibrary="3" |
||||
UsePrecompiledHeader="0" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="4"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLibrarianTool" |
||||
OutputFile="$(OutDir)/gtestd.lib"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
<Configuration |
||||
Name="Release|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="4" |
||||
CharacterSet="2" |
||||
ReferencesPath=""..\include";"..""> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
PreprocessorDefinitions="WIN32;NDEBUG;_LIB" |
||||
RuntimeLibrary="2" |
||||
UsePrecompiledHeader="0" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="3"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLibrarianTool" |
||||
OutputFile="$(OutDir)/gtest.lib"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
</Configurations> |
||||
<References> |
||||
</References> |
||||
<Files> |
||||
<Filter |
||||
Name="Source Files" |
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" |
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> |
||||
<File |
||||
RelativePath="..\src\gtest-all.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include""/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include""/> |
||||
</FileConfiguration> |
||||
</File> |
||||
</Filter> |
||||
<Filter |
||||
Name="Header Files" |
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd" |
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> |
||||
</Filter> |
||||
</Files> |
||||
<Globals> |
||||
</Globals> |
||||
</VisualStudioProject> |
@ -0,0 +1,45 @@
|
||||
Microsoft Visual Studio Solution File, Format Version 8.00 |
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest", "gtest.vcproj", "{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}" |
||||
ProjectSection(ProjectDependencies) = postProject |
||||
EndProjectSection |
||||
EndProject |
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_main", "gtest_main.vcproj", "{3AF54C8A-10BF-4332-9147-F68ED9862032}" |
||||
ProjectSection(ProjectDependencies) = postProject |
||||
EndProjectSection |
||||
EndProject |
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_unittest", "gtest_unittest.vcproj", "{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}" |
||||
ProjectSection(ProjectDependencies) = postProject |
||||
EndProjectSection |
||||
EndProject |
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_prod_test", "gtest_prod_test.vcproj", "{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}" |
||||
ProjectSection(ProjectDependencies) = postProject |
||||
EndProjectSection |
||||
EndProject |
||||
Global |
||||
GlobalSection(SolutionConfiguration) = preSolution |
||||
Debug = Debug |
||||
Release = Release |
||||
EndGlobalSection |
||||
GlobalSection(ProjectConfiguration) = postSolution |
||||
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Debug.ActiveCfg = Debug|Win32 |
||||
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Debug.Build.0 = Debug|Win32 |
||||
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Release.ActiveCfg = Release|Win32 |
||||
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Release.Build.0 = Release|Win32 |
||||
{3AF54C8A-10BF-4332-9147-F68ED9862032}.Debug.ActiveCfg = Debug|Win32 |
||||
{3AF54C8A-10BF-4332-9147-F68ED9862032}.Debug.Build.0 = Debug|Win32 |
||||
{3AF54C8A-10BF-4332-9147-F68ED9862032}.Release.ActiveCfg = Release|Win32 |
||||
{3AF54C8A-10BF-4332-9147-F68ED9862032}.Release.Build.0 = Release|Win32 |
||||
{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Debug.ActiveCfg = Debug|Win32 |
||||
{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Debug.Build.0 = Debug|Win32 |
||||
{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Release.ActiveCfg = Release|Win32 |
||||
{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Release.Build.0 = Release|Win32 |
||||
{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Debug.ActiveCfg = Debug|Win32 |
||||
{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Debug.Build.0 = Debug|Win32 |
||||
{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Release.ActiveCfg = Release|Win32 |
||||
{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Release.Build.0 = Release|Win32 |
||||
EndGlobalSection |
||||
GlobalSection(ExtensibilityGlobals) = postSolution |
||||
EndGlobalSection |
||||
GlobalSection(ExtensibilityAddIns) = postSolution |
||||
EndGlobalSection |
||||
EndGlobal |
@ -0,0 +1,126 @@
|
||||
<?xml version="1.0" encoding="Windows-1252"?> |
||||
<VisualStudioProject |
||||
ProjectType="Visual C++" |
||||
Version="7.10" |
||||
Name="gtest" |
||||
ProjectGUID="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}" |
||||
Keyword="Win32Proj"> |
||||
<Platforms> |
||||
<Platform |
||||
Name="Win32"/> |
||||
</Platforms> |
||||
<Configurations> |
||||
<Configuration |
||||
Name="Debug|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="4" |
||||
CharacterSet="2" |
||||
ReferencesPath=""> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="0" |
||||
PreprocessorDefinitions="WIN32;_DEBUG;_LIB" |
||||
MinimalRebuild="TRUE" |
||||
BasicRuntimeChecks="3" |
||||
RuntimeLibrary="5" |
||||
UsePrecompiledHeader="0" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="4"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLibrarianTool" |
||||
OutputFile="$(OutDir)/gtestd.lib"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
<Configuration |
||||
Name="Release|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="4" |
||||
CharacterSet="2" |
||||
ReferencesPath=""..\include";"..""> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
PreprocessorDefinitions="WIN32;NDEBUG;_LIB" |
||||
RuntimeLibrary="4" |
||||
UsePrecompiledHeader="0" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="3"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLibrarianTool" |
||||
OutputFile="$(OutDir)/gtest.lib"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
</Configurations> |
||||
<References> |
||||
</References> |
||||
<Files> |
||||
<Filter |
||||
Name="Source Files" |
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" |
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> |
||||
<File |
||||
RelativePath="..\src\gtest-all.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include""/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include""/> |
||||
</FileConfiguration> |
||||
</File> |
||||
</Filter> |
||||
<Filter |
||||
Name="Header Files" |
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd" |
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> |
||||
</Filter> |
||||
</Files> |
||||
<Globals> |
||||
</Globals> |
||||
</VisualStudioProject> |
@ -0,0 +1,129 @@
|
||||
<?xml version="1.0" encoding="Windows-1252"?> |
||||
<VisualStudioProject |
||||
ProjectType="Visual C++" |
||||
Version="7.10" |
||||
Name="gtest_main-md" |
||||
ProjectGUID="{3AF54C8A-10BF-4332-9147-F68ED9862033}" |
||||
Keyword="Win32Proj"> |
||||
<Platforms> |
||||
<Platform |
||||
Name="Win32"/> |
||||
</Platforms> |
||||
<Configurations> |
||||
<Configuration |
||||
Name="Debug|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="4" |
||||
CharacterSet="2" |
||||
ReferencesPath=""> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="0" |
||||
PreprocessorDefinitions="WIN32;_DEBUG;_LIB" |
||||
MinimalRebuild="TRUE" |
||||
BasicRuntimeChecks="3" |
||||
RuntimeLibrary="3" |
||||
UsePrecompiledHeader="0" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="4"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLibrarianTool" |
||||
OutputFile="$(OutDir)/$(ProjectName)d.lib"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
<Configuration |
||||
Name="Release|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="4" |
||||
CharacterSet="2" |
||||
ReferencesPath=""..\include";"..""> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
PreprocessorDefinitions="WIN32;NDEBUG;_LIB" |
||||
RuntimeLibrary="2" |
||||
UsePrecompiledHeader="0" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="3"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLibrarianTool" |
||||
OutputFile="$(OutDir)/$(ProjectName).lib"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
</Configurations> |
||||
<References> |
||||
<ProjectReference |
||||
ReferencedProjectIdentifier="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}" |
||||
Name="gtest-md"/> |
||||
</References> |
||||
<Files> |
||||
<Filter |
||||
Name="Source Files" |
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" |
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> |
||||
<File |
||||
RelativePath="..\src\gtest_main.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include""/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include""/> |
||||
</FileConfiguration> |
||||
</File> |
||||
</Filter> |
||||
<Filter |
||||
Name="Header Files" |
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd" |
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> |
||||
</Filter> |
||||
</Files> |
||||
<Globals> |
||||
</Globals> |
||||
</VisualStudioProject> |
@ -0,0 +1,129 @@
|
||||
<?xml version="1.0" encoding="Windows-1252"?> |
||||
<VisualStudioProject |
||||
ProjectType="Visual C++" |
||||
Version="7.10" |
||||
Name="gtest_main" |
||||
ProjectGUID="{3AF54C8A-10BF-4332-9147-F68ED9862032}" |
||||
Keyword="Win32Proj"> |
||||
<Platforms> |
||||
<Platform |
||||
Name="Win32"/> |
||||
</Platforms> |
||||
<Configurations> |
||||
<Configuration |
||||
Name="Debug|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="4" |
||||
CharacterSet="2" |
||||
ReferencesPath=""> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="0" |
||||
PreprocessorDefinitions="WIN32;_DEBUG;_LIB" |
||||
MinimalRebuild="TRUE" |
||||
BasicRuntimeChecks="3" |
||||
RuntimeLibrary="5" |
||||
UsePrecompiledHeader="0" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="4"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLibrarianTool" |
||||
OutputFile="$(OutDir)/$(ProjectName)d.lib"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
<Configuration |
||||
Name="Release|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="4" |
||||
CharacterSet="2" |
||||
ReferencesPath=""..\include";"..""> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
PreprocessorDefinitions="WIN32;NDEBUG;_LIB" |
||||
RuntimeLibrary="4" |
||||
UsePrecompiledHeader="0" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="3"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLibrarianTool" |
||||
OutputFile="$(OutDir)/$(ProjectName).lib"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
</Configurations> |
||||
<References> |
||||
<ProjectReference |
||||
ReferencedProjectIdentifier="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}" |
||||
Name="gtest"/> |
||||
</References> |
||||
<Files> |
||||
<Filter |
||||
Name="Source Files" |
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" |
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> |
||||
<File |
||||
RelativePath="..\src\gtest_main.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include""/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include""/> |
||||
</FileConfiguration> |
||||
</File> |
||||
</Filter> |
||||
<Filter |
||||
Name="Header Files" |
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd" |
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> |
||||
</Filter> |
||||
</Files> |
||||
<Globals> |
||||
</Globals> |
||||
</VisualStudioProject> |
@ -0,0 +1,164 @@
|
||||
<?xml version="1.0" encoding="Windows-1252"?> |
||||
<VisualStudioProject |
||||
ProjectType="Visual C++" |
||||
Version="7.10" |
||||
Name="gtest_prod_test-md" |
||||
ProjectGUID="{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}" |
||||
Keyword="Win32Proj"> |
||||
<Platforms> |
||||
<Platform |
||||
Name="Win32"/> |
||||
</Platforms> |
||||
<Configurations> |
||||
<Configuration |
||||
Name="Debug|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="1" |
||||
CharacterSet="2"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="0" |
||||
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" |
||||
MinimalRebuild="TRUE" |
||||
BasicRuntimeChecks="3" |
||||
RuntimeLibrary="3" |
||||
UsePrecompiledHeader="3" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="4"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLinkerTool" |
||||
OutputFile="$(OutDir)/gtest_prod_test.exe" |
||||
LinkIncremental="2" |
||||
GenerateDebugInformation="TRUE" |
||||
ProgramDatabaseFile="$(OutDir)/gtest_prod_test.pdb" |
||||
SubSystem="1" |
||||
TargetMachine="1"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCWebDeploymentTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
<Configuration |
||||
Name="Release|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="1" |
||||
CharacterSet="2"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" |
||||
RuntimeLibrary="2" |
||||
UsePrecompiledHeader="3" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="3"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLinkerTool" |
||||
OutputFile="$(OutDir)/gtest_prod_test.exe" |
||||
LinkIncremental="1" |
||||
GenerateDebugInformation="TRUE" |
||||
SubSystem="1" |
||||
OptimizeReferences="2" |
||||
EnableCOMDATFolding="2" |
||||
TargetMachine="1"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCWebDeploymentTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
</Configurations> |
||||
<References> |
||||
<ProjectReference |
||||
ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862033}" |
||||
Name="gtest_main-md"/> |
||||
</References> |
||||
<Files> |
||||
<Filter |
||||
Name="Source Files" |
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" |
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> |
||||
<File |
||||
RelativePath="..\test\gtest_prod_test.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
</File> |
||||
<File |
||||
RelativePath="..\test\production.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
</File> |
||||
</Filter> |
||||
<Filter |
||||
Name="Header Files" |
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd" |
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> |
||||
<File |
||||
RelativePath="..\test\production.h"> |
||||
</File> |
||||
</Filter> |
||||
</Files> |
||||
<Globals> |
||||
</Globals> |
||||
</VisualStudioProject> |
@ -0,0 +1,164 @@
|
||||
<?xml version="1.0" encoding="Windows-1252"?> |
||||
<VisualStudioProject |
||||
ProjectType="Visual C++" |
||||
Version="7.10" |
||||
Name="gtest_prod_test" |
||||
ProjectGUID="{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}" |
||||
Keyword="Win32Proj"> |
||||
<Platforms> |
||||
<Platform |
||||
Name="Win32"/> |
||||
</Platforms> |
||||
<Configurations> |
||||
<Configuration |
||||
Name="Debug|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="1" |
||||
CharacterSet="2"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="0" |
||||
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" |
||||
MinimalRebuild="TRUE" |
||||
BasicRuntimeChecks="3" |
||||
RuntimeLibrary="5" |
||||
UsePrecompiledHeader="3" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="4"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLinkerTool" |
||||
OutputFile="$(OutDir)/gtest_prod_test.exe" |
||||
LinkIncremental="2" |
||||
GenerateDebugInformation="TRUE" |
||||
ProgramDatabaseFile="$(OutDir)/gtest_prod_test.pdb" |
||||
SubSystem="1" |
||||
TargetMachine="1"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCWebDeploymentTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
<Configuration |
||||
Name="Release|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="1" |
||||
CharacterSet="2"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" |
||||
RuntimeLibrary="4" |
||||
UsePrecompiledHeader="3" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="3"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLinkerTool" |
||||
OutputFile="$(OutDir)/gtest_prod_test.exe" |
||||
LinkIncremental="1" |
||||
GenerateDebugInformation="TRUE" |
||||
SubSystem="1" |
||||
OptimizeReferences="2" |
||||
EnableCOMDATFolding="2" |
||||
TargetMachine="1"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCWebDeploymentTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
</Configurations> |
||||
<References> |
||||
<ProjectReference |
||||
ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862032}" |
||||
Name="gtest_main"/> |
||||
</References> |
||||
<Files> |
||||
<Filter |
||||
Name="Source Files" |
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" |
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> |
||||
<File |
||||
RelativePath="..\test\gtest_prod_test.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
</File> |
||||
<File |
||||
RelativePath="..\test\production.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
</File> |
||||
</Filter> |
||||
<Filter |
||||
Name="Header Files" |
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd" |
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> |
||||
<File |
||||
RelativePath="..\test\production.h"> |
||||
</File> |
||||
</Filter> |
||||
</Files> |
||||
<Globals> |
||||
</Globals> |
||||
</VisualStudioProject> |
@ -0,0 +1,147 @@
|
||||
<?xml version="1.0" encoding="Windows-1252"?> |
||||
<VisualStudioProject |
||||
ProjectType="Visual C++" |
||||
Version="7.10" |
||||
Name="gtest_unittest-md" |
||||
ProjectGUID="{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}" |
||||
Keyword="Win32Proj"> |
||||
<Platforms> |
||||
<Platform |
||||
Name="Win32"/> |
||||
</Platforms> |
||||
<Configurations> |
||||
<Configuration |
||||
Name="Debug|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="1" |
||||
CharacterSet="2"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="0" |
||||
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" |
||||
MinimalRebuild="TRUE" |
||||
BasicRuntimeChecks="3" |
||||
RuntimeLibrary="3" |
||||
UsePrecompiledHeader="3" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="4"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLinkerTool" |
||||
OutputFile="$(OutDir)/gtest_unittest.exe" |
||||
LinkIncremental="2" |
||||
GenerateDebugInformation="TRUE" |
||||
ProgramDatabaseFile="$(OutDir)/gtest_unittest.pdb" |
||||
SubSystem="1" |
||||
TargetMachine="1"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCWebDeploymentTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
<Configuration |
||||
Name="Release|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="1" |
||||
CharacterSet="2"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" |
||||
RuntimeLibrary="2" |
||||
UsePrecompiledHeader="3" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="3"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLinkerTool" |
||||
OutputFile="$(OutDir)/gtest_unittest.exe" |
||||
LinkIncremental="1" |
||||
GenerateDebugInformation="TRUE" |
||||
SubSystem="1" |
||||
OptimizeReferences="2" |
||||
EnableCOMDATFolding="2" |
||||
TargetMachine="1"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCWebDeploymentTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
</Configurations> |
||||
<References> |
||||
<ProjectReference |
||||
ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862033}" |
||||
Name="gtest_main-md"/> |
||||
</References> |
||||
<Files> |
||||
<Filter |
||||
Name="Source Files" |
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" |
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> |
||||
<File |
||||
RelativePath="..\test\gtest_unittest.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="1" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
BasicRuntimeChecks="0" |
||||
UsePrecompiledHeader="0" |
||||
DebugInformationFormat="3"/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
</File> |
||||
</Filter> |
||||
<Filter |
||||
Name="Header Files" |
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd" |
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> |
||||
</Filter> |
||||
</Files> |
||||
<Globals> |
||||
</Globals> |
||||
</VisualStudioProject> |
@ -0,0 +1,147 @@
|
||||
<?xml version="1.0" encoding="Windows-1252"?> |
||||
<VisualStudioProject |
||||
ProjectType="Visual C++" |
||||
Version="7.10" |
||||
Name="gtest_unittest" |
||||
ProjectGUID="{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}" |
||||
Keyword="Win32Proj"> |
||||
<Platforms> |
||||
<Platform |
||||
Name="Win32"/> |
||||
</Platforms> |
||||
<Configurations> |
||||
<Configuration |
||||
Name="Debug|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="1" |
||||
CharacterSet="2"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="0" |
||||
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" |
||||
MinimalRebuild="TRUE" |
||||
BasicRuntimeChecks="3" |
||||
RuntimeLibrary="5" |
||||
UsePrecompiledHeader="3" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="4"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLinkerTool" |
||||
OutputFile="$(OutDir)/gtest_unittest.exe" |
||||
LinkIncremental="2" |
||||
GenerateDebugInformation="TRUE" |
||||
ProgramDatabaseFile="$(OutDir)/gtest_unittest.pdb" |
||||
SubSystem="1" |
||||
TargetMachine="1"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCWebDeploymentTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
<Configuration |
||||
Name="Release|Win32" |
||||
OutputDirectory="$(SolutionName)/$(ConfigurationName)" |
||||
IntermediateDirectory="$(OutDir)/$(ProjectName)" |
||||
ConfigurationType="1" |
||||
CharacterSet="2"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" |
||||
RuntimeLibrary="4" |
||||
UsePrecompiledHeader="3" |
||||
WarningLevel="3" |
||||
Detect64BitPortabilityProblems="FALSE" |
||||
DebugInformationFormat="3"/> |
||||
<Tool |
||||
Name="VCCustomBuildTool"/> |
||||
<Tool |
||||
Name="VCLinkerTool" |
||||
OutputFile="$(OutDir)/gtest_unittest.exe" |
||||
LinkIncremental="1" |
||||
GenerateDebugInformation="TRUE" |
||||
SubSystem="1" |
||||
OptimizeReferences="2" |
||||
EnableCOMDATFolding="2" |
||||
TargetMachine="1"/> |
||||
<Tool |
||||
Name="VCMIDLTool"/> |
||||
<Tool |
||||
Name="VCPostBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreBuildEventTool"/> |
||||
<Tool |
||||
Name="VCPreLinkEventTool"/> |
||||
<Tool |
||||
Name="VCResourceCompilerTool"/> |
||||
<Tool |
||||
Name="VCWebServiceProxyGeneratorTool"/> |
||||
<Tool |
||||
Name="VCXMLDataGeneratorTool"/> |
||||
<Tool |
||||
Name="VCWebDeploymentTool"/> |
||||
<Tool |
||||
Name="VCManagedWrapperGeneratorTool"/> |
||||
<Tool |
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> |
||||
</Configuration> |
||||
</Configurations> |
||||
<References> |
||||
<ProjectReference |
||||
ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862032}" |
||||
Name="gtest_main"/> |
||||
</References> |
||||
<Files> |
||||
<Filter |
||||
Name="Source Files" |
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" |
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> |
||||
<File |
||||
RelativePath="..\test\gtest_unittest.cc"> |
||||
<FileConfiguration |
||||
Name="Debug|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
Optimization="1" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
BasicRuntimeChecks="0" |
||||
UsePrecompiledHeader="0" |
||||
DebugInformationFormat="3"/> |
||||
</FileConfiguration> |
||||
<FileConfiguration |
||||
Name="Release|Win32"> |
||||
<Tool |
||||
Name="VCCLCompilerTool" |
||||
AdditionalIncludeDirectories=""..";"..\include"" |
||||
UsePrecompiledHeader="0"/> |
||||
</FileConfiguration> |
||||
</File> |
||||
</Filter> |
||||
<Filter |
||||
Name="Header Files" |
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd" |
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> |
||||
</Filter> |
||||
</Files> |
||||
<Globals> |
||||
</Globals> |
||||
</VisualStudioProject> |
@ -0,0 +1 @@
|
||||
# dummy |
@ -0,0 +1 @@
|
||||
# dummy |
@ -0,0 +1 @@
|
||||
# dummy |
@ -0,0 +1 @@
|
||||
# dummy |
@ -0,0 +1 @@
|
||||
# dummy |
@ -0,0 +1 @@
|
||||
# dummy |
@ -0,0 +1 @@
|
||||
# dummy |
@ -0,0 +1,123 @@
|
||||
// Copyright 2008 Google Inc.
|
||||
// All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
|
||||
// This provides interface PrimeTable that determines whether a number is a
|
||||
// prime and determines a next prime number. This interface is used
|
||||
// in Google Test samples demonstrating use of parameterized tests.
|
||||
|
||||
#ifndef GTEST_SAMPLES_PRIME_TABLES_H_ |
||||
#define GTEST_SAMPLES_PRIME_TABLES_H_ |
||||
|
||||
#include <algorithm> |
||||
|
||||
// The prime table interface.
|
||||
class PrimeTable { |
||||
public: |
||||
virtual ~PrimeTable() {} |
||||
|
||||
// Returns true iff n is a prime number.
|
||||
virtual bool IsPrime(int n) const = 0; |
||||
|
||||
// Returns the smallest prime number greater than p; or returns -1
|
||||
// if the next prime is beyond the capacity of the table.
|
||||
virtual int GetNextPrime(int p) const = 0; |
||||
}; |
||||
|
||||
// Implementation #1 calculates the primes on-the-fly.
|
||||
class OnTheFlyPrimeTable : public PrimeTable { |
||||
public: |
||||
virtual bool IsPrime(int n) const { |
||||
if (n <= 1) return false; |
||||
|
||||
for (int i = 2; i*i <= n; i++) { |
||||
// n is divisible by an integer other than 1 and itself.
|
||||
if ((n % i) == 0) return false; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
virtual int GetNextPrime(int p) const { |
||||
for (int n = p + 1; n > 0; n++) { |
||||
if (IsPrime(n)) return n; |
||||
} |
||||
|
||||
return -1; |
||||
} |
||||
}; |
||||
|
||||
// Implementation #2 pre-calculates the primes and stores the result
|
||||
// in an array.
|
||||
class PreCalculatedPrimeTable : public PrimeTable { |
||||
public: |
||||
// 'max' specifies the maximum number the prime table holds.
|
||||
explicit PreCalculatedPrimeTable(int max) |
||||
: is_prime_size_(max + 1), is_prime_(new bool[max + 1]) { |
||||
CalculatePrimesUpTo(max); |
||||
} |
||||
virtual ~PreCalculatedPrimeTable() { delete[] is_prime_; } |
||||
|
||||
virtual bool IsPrime(int n) const { |
||||
return 0 <= n && n < is_prime_size_ && is_prime_[n]; |
||||
} |
||||
|
||||
virtual int GetNextPrime(int p) const { |
||||
for (int n = p + 1; n < is_prime_size_; n++) { |
||||
if (is_prime_[n]) return n; |
||||
} |
||||
|
||||
return -1; |
||||
} |
||||
|
||||
private: |
||||
void CalculatePrimesUpTo(int max) { |
||||
::std::fill(is_prime_, is_prime_ + is_prime_size_, true); |
||||
is_prime_[0] = is_prime_[1] = false; |
||||
|
||||
for (int i = 2; i <= max; i++) { |
||||
if (!is_prime_[i]) continue; |
||||
|
||||
// Marks all multiples of i (except i itself) as non-prime.
|
||||
for (int j = 2*i; j <= max; j += i) { |
||||
is_prime_[j] = false; |
||||
} |
||||
} |
||||
} |
||||
|
||||
const int is_prime_size_; |
||||
bool* const is_prime_; |
||||
|
||||
// Disables compiler warning "assignment operator could not be generated."
|
||||
void operator=(const PreCalculatedPrimeTable& rhs); |
||||
}; |
||||
|
||||
#endif // GTEST_SAMPLES_PRIME_TABLES_H_
|
@ -0,0 +1,68 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// A sample program demonstrating using Google C++ testing framework.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#include "sample1.h" |
||||
|
||||
// Returns n! (the factorial of n). For negative n, n! is defined to be 1.
|
||||
int Factorial(int n) { |
||||
int result = 1; |
||||
for (int i = 1; i <= n; i++) { |
||||
result *= i; |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
// Returns true iff n is a prime number.
|
||||
bool IsPrime(int n) { |
||||
// Trivial case 1: small numbers
|
||||
if (n <= 1) return false; |
||||
|
||||
// Trivial case 2: even numbers
|
||||
if (n % 2 == 0) return n == 2; |
||||
|
||||
// Now, we have that n is odd and n >= 3.
|
||||
|
||||
// Try to divide n by every odd number i, starting from 3
|
||||
for (int i = 3; ; i += 2) { |
||||
// We only have to try i up to the squre root of n
|
||||
if (i > n/i) break; |
||||
|
||||
// Now, we have i <= n/i < n.
|
||||
// If n is divisible by i, n is not prime.
|
||||
if (n % i == 0) return false; |
||||
} |
||||
|
||||
// n has no integer factor in the range (1, n), and thus is prime.
|
||||
return true; |
||||
} |
@ -0,0 +1,43 @@
|
||||
// Copyright 2005, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// A sample program demonstrating using Google C++ testing framework.
|
||||
//
|
||||
// Author: wan@google.com (Zhanyong Wan)
|
||||
|
||||
#ifndef GTEST_SAMPLES_SAMPLE1_H_ |
||||
#define GTEST_SAMPLES_SAMPLE1_H_ |
||||
|
||||
// Returns n! (the factorial of n). For negative n, n! is defined to be 1.
|
||||
int Factorial(int n); |
||||
|
||||
// Returns true iff n is a prime number.
|
||||
bool IsPrime(int n); |
||||
|
||||
#endif // GTEST_SAMPLES_SAMPLE1_H_
|
@ -0,0 +1,145 @@
|
||||
// Copyright 2009 Google Inc. All Rights Reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Author: vladl@google.com (Vlad Losev)
|
||||
|
||||
// This sample shows how to use Google Test listener API to implement
|
||||
// a primitive leak checker.
|
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
|
||||
#include "gtest/gtest.h" |
||||
|
||||
using ::testing::EmptyTestEventListener; |
||||
using ::testing::InitGoogleTest; |
||||
using ::testing::Test; |
||||
using ::testing::TestCase; |
||||
using ::testing::TestEventListeners; |
||||
using ::testing::TestInfo; |
||||
using ::testing::TestPartResult; |
||||
using ::testing::UnitTest; |
||||
|
||||
namespace { |
||||
|
||||
// We will track memory used by this class.
|
||||
class Water { |
||||
public: |
||||
// Normal Water declarations go here.
|
||||
|
||||
// operator new and operator delete help us control water allocation.
|
||||
void* operator new(size_t allocation_size) { |
||||
allocated_++; |
||||
return malloc(allocation_size); |
||||
} |
||||
|
||||
void operator delete(void* block, size_t /* allocation_size */) { |
||||
allocated_--; |
||||
free(block); |
||||
} |
||||
|
||||
static int allocated() { return allocated_; } |
||||
|
||||
private: |
||||
static int allocated_; |
||||
}; |
||||
|
||||
int Water::allocated_ = 0; |
||||
|
||||
// This event listener monitors how many Water objects are created and
|
||||
// destroyed by each test, and reports a failure if a test leaks some Water
|
||||
// objects. It does this by comparing the number of live Water objects at
|
||||
// the beginning of a test and at the end of a test.
|
||||
class LeakChecker : public EmptyTestEventListener { |
||||
private: |
||||
// Called before a test starts.
|
||||
virtual void OnTestStart(const TestInfo& /* test_info */) { |
||||
initially_allocated_ = Water::allocated(); |
||||
} |
||||
|
||||
// Called after a test ends.
|
||||
virtual void OnTestEnd(const TestInfo& /* test_info */) { |
||||
int difference = Water::allocated() - initially_allocated_; |
||||
|
||||
// You can generate a failure in any event handler except
|
||||
// OnTestPartResult. Just use an appropriate Google Test assertion to do
|
||||
// it.
|
||||
EXPECT_TRUE(difference <= 0) |
||||
<< "Leaked " << difference << " unit(s) of Water!"; |
||||
} |
||||
|
||||
int initially_allocated_; |
||||
}; |
||||
|
||||
TEST(ListenersTest, DoesNotLeak) { |
||||
Water* water = new Water; |
||||
delete water; |
||||
} |
||||
|
||||
// This should fail when the --check_for_leaks command line flag is
|
||||
// specified.
|
||||
TEST(ListenersTest, LeaksWater) { |
||||
Water* water = new Water; |
||||
EXPECT_TRUE(water != NULL); |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) { |
||||
InitGoogleTest(&argc, argv); |
||||
|
||||
bool check_for_leaks = false; |
||||
if (argc > 1 && strcmp(argv[1], "--check_for_leaks") == 0 ) |
||||
check_for_leaks = true; |
||||
else |
||||
printf("%s\n", "Run this program with --check_for_leaks to enable " |
||||
"custom leak checking in the tests."); |
||||
|
||||
// If we are given the --check_for_leaks command line flag, installs the
|
||||
// leak checker.
|
||||
if (check_for_leaks) { |
||||
TestEventListeners& listeners = UnitTest::GetInstance()->listeners(); |
||||
|
||||
// Adds the leak checker to the end of the test event listener list,
|
||||
// after the default text output printer and the default XML report
|
||||
// generator.
|
||||
//
|
||||
// The order is important - it ensures that failures generated in the
|
||||
// leak checker's OnTestEnd() method are processed by the text and XML
|
||||
// printers *before* their OnTestEnd() methods are called, such that
|
||||
// they are attributed to the right test. Remember that a listener
|
||||
// receives an OnXyzStart event *after* listeners preceding it in the
|
||||
// list received that event, and receives an OnXyzEnd event *before*
|
||||
// listeners preceding it.
|
||||
//
|
||||
// We don't need to worry about deleting the new listener later, as
|
||||
// Google Test will do it.
|
||||
listeners.Append(new LeakChecker); |
||||
} |
||||
return RUN_ALL_TESTS(); |
||||
} |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue