Index: ch.vc90.sln
===================================================================
diff -u -r2d7bee54f998ae8f5d4145a2cf3f4a589253016f -r409a0af1e9fdea72ca016118d76a5a95e53496e8
--- ch.vc90.sln (.../ch.vc90.sln) (revision 2d7bee54f998ae8f5d4145a2cf3f4a589253016f)
+++ ch.vc90.sln (.../ch.vc90.sln) (revision 409a0af1e9fdea72ca016118d76a5a95e53496e8)
@@ -5,8 +5,6 @@
{CBBF380B-7B16-4A1E-8194-758DAD7D8011} = {CBBF380B-7B16-4A1E-8194-758DAD7D8011}
{5510B933-046F-4F75-8B46-5E8279C8CCDE} = {5510B933-046F-4F75-8B46-5E8279C8CCDE}
{DD1F3242-7EE4-4F41-8B8D-D833300C445F} = {DD1F3242-7EE4-4F41-8B8D-D833300C445F}
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A} = {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69} = {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chext", "src\chext\chext.vc90.vcproj", "{7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}"
@@ -28,80 +26,164 @@
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ictranslate", "src\ictranslate\ictranslate.vc90.vcproj", "{B0292250-B70C-4395-9859-F181FB113DA8}"
- ProjectSection(ProjectDependencies) = postProject
- {5510B933-046F-4F75-8B46-5E8279C8CCDE} = {5510B933-046F-4F75-8B46-5E8279C8CCDE}
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F} = {DD1F3242-7EE4-4F41-8B8D-D833300C445F}
- EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libchcore", "src\libchcore\libchcore.vc90.vcproj", "{CBBF380B-7B16-4A1E-8194-758DAD7D8011}"
ProjectSection(ProjectDependencies) = postProject
{5510B933-046F-4F75-8B46-5E8279C8CCDE} = {5510B933-046F-4F75-8B46-5E8279C8CCDE}
EndProjectSection
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libchcore_test", "tests\libchcore_test\libchcore_test.vcproj", "{2AF37846-09E7-46EB-83AE-1E4C67742EE7}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "ext\gmock\gmock.vcproj", "{D98F2D98-2352-4303-93EE-A5430C4E98AB}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
- Debug-Unicode|Win32 = Debug-Unicode|Win32
- Debug-Unicode|x64 = Debug-Unicode|x64
- Release-Unicode|Win32 = Release-Unicode|Win32
- Release-Unicode|x64 = Release-Unicode|x64
+ Debug|Win32 = Debug|Win32
+ Debug|x64 = Debug|x64
+ DebugTests|Win32 = DebugTests|Win32
+ DebugTests|x64 = DebugTests|x64
+ Release|Win32 = Release|Win32
+ Release|x64 = Release|x64
+ ReleaseTests|Win32 = ReleaseTests|Win32
+ ReleaseTests|x64 = ReleaseTests|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
- {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Debug-Unicode|Win32.ActiveCfg = Debug-Unicode|Win32
- {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Debug-Unicode|Win32.Build.0 = Debug-Unicode|Win32
- {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Debug-Unicode|x64.ActiveCfg = Debug-Unicode|x64
- {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Debug-Unicode|x64.Build.0 = Debug-Unicode|x64
- {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Release-Unicode|Win32.ActiveCfg = Release-Unicode|Win32
- {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Release-Unicode|Win32.Build.0 = Release-Unicode|Win32
- {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Release-Unicode|x64.ActiveCfg = Release-Unicode|x64
- {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Release-Unicode|x64.Build.0 = Release-Unicode|x64
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Debug-Unicode|Win32.ActiveCfg = Debug-Unicode|Win32
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Debug-Unicode|Win32.Build.0 = Debug-Unicode|Win32
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Debug-Unicode|x64.ActiveCfg = Debug-Unicode|x64
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Debug-Unicode|x64.Build.0 = Debug-Unicode|x64
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Release-Unicode|Win32.ActiveCfg = Release-Unicode|Win32
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Release-Unicode|Win32.Build.0 = Release-Unicode|Win32
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Release-Unicode|x64.ActiveCfg = Release-Unicode|x64
- {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Release-Unicode|x64.Build.0 = Release-Unicode|x64
- {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Debug-Unicode|Win32.ActiveCfg = Debug-Unicode|Win32
- {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Debug-Unicode|Win32.Build.0 = Debug-Unicode|Win32
- {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Debug-Unicode|x64.ActiveCfg = Debug-Unicode|x64
- {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Debug-Unicode|x64.Build.0 = Debug-Unicode|x64
- {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Release-Unicode|Win32.ActiveCfg = Release-Unicode|Win32
- {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Release-Unicode|Win32.Build.0 = Release-Unicode|Win32
- {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Release-Unicode|x64.ActiveCfg = Release-Unicode|x64
- {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Release-Unicode|x64.Build.0 = Release-Unicode|x64
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Debug-Unicode|Win32.ActiveCfg = Debug-Unicode|Win32
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Debug-Unicode|Win32.Build.0 = Debug-Unicode|Win32
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Debug-Unicode|x64.ActiveCfg = Debug-Unicode|x64
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Debug-Unicode|x64.Build.0 = Debug-Unicode|x64
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Release-Unicode|Win32.ActiveCfg = Release-Unicode|Win32
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Release-Unicode|Win32.Build.0 = Release-Unicode|Win32
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Release-Unicode|x64.ActiveCfg = Release-Unicode|x64
- {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Release-Unicode|x64.Build.0 = Release-Unicode|x64
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Debug-Unicode|Win32.ActiveCfg = Debug-Unicode|Win32
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Debug-Unicode|Win32.Build.0 = Debug-Unicode|Win32
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Debug-Unicode|x64.ActiveCfg = Debug-Unicode|x64
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Debug-Unicode|x64.Build.0 = Debug-Unicode|x64
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Release-Unicode|Win32.ActiveCfg = Release-Unicode|Win32
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Release-Unicode|Win32.Build.0 = Release-Unicode|Win32
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Release-Unicode|x64.ActiveCfg = Release-Unicode|x64
- {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Release-Unicode|x64.Build.0 = Release-Unicode|x64
- {B0292250-B70C-4395-9859-F181FB113DA8}.Debug-Unicode|Win32.ActiveCfg = Debug-Unicode|Win32
- {B0292250-B70C-4395-9859-F181FB113DA8}.Debug-Unicode|Win32.Build.0 = Debug-Unicode|Win32
- {B0292250-B70C-4395-9859-F181FB113DA8}.Debug-Unicode|x64.ActiveCfg = Debug-Unicode|x64
- {B0292250-B70C-4395-9859-F181FB113DA8}.Debug-Unicode|x64.Build.0 = Debug-Unicode|x64
- {B0292250-B70C-4395-9859-F181FB113DA8}.Release-Unicode|Win32.ActiveCfg = Release-Unicode|Win32
- {B0292250-B70C-4395-9859-F181FB113DA8}.Release-Unicode|Win32.Build.0 = Release-Unicode|Win32
- {B0292250-B70C-4395-9859-F181FB113DA8}.Release-Unicode|x64.ActiveCfg = Release-Unicode|x64
- {B0292250-B70C-4395-9859-F181FB113DA8}.Release-Unicode|x64.Build.0 = Release-Unicode|x64
- {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Debug-Unicode|Win32.ActiveCfg = Debug-Unicode|Win32
- {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Debug-Unicode|Win32.Build.0 = Debug-Unicode|Win32
- {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Debug-Unicode|x64.ActiveCfg = Debug-Unicode|x64
- {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Debug-Unicode|x64.Build.0 = Debug-Unicode|x64
- {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Release-Unicode|Win32.ActiveCfg = Release-Unicode|Win32
- {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Release-Unicode|Win32.Build.0 = Release-Unicode|Win32
- {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Release-Unicode|x64.ActiveCfg = Release-Unicode|x64
- {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Release-Unicode|x64.Build.0 = Release-Unicode|x64
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Debug|Win32.ActiveCfg = Debug|Win32
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Debug|Win32.Build.0 = Debug|Win32
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Debug|x64.ActiveCfg = Debug|x64
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Debug|x64.Build.0 = Debug|x64
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.DebugTests|Win32.Build.0 = Debug|Win32
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.DebugTests|x64.ActiveCfg = Debug|x64
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.DebugTests|x64.Build.0 = Debug|x64
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Release|Win32.ActiveCfg = Release|Win32
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Release|Win32.Build.0 = Release|Win32
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Release|x64.ActiveCfg = Release|x64
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.Release|x64.Build.0 = Release|x64
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {4B215B9A-58CA-4987-AC95-7DFC3043E100}.ReleaseTests|x64.Build.0 = Release|x64
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Debug|Win32.ActiveCfg = Debug|Win32
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Debug|Win32.Build.0 = Debug|Win32
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Debug|x64.ActiveCfg = Debug|x64
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Debug|x64.Build.0 = Debug|x64
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.DebugTests|Win32.Build.0 = Debug|Win32
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.DebugTests|x64.ActiveCfg = Debug|x64
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.DebugTests|x64.Build.0 = Debug|x64
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Release|Win32.ActiveCfg = Release|Win32
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Release|Win32.Build.0 = Release|Win32
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Release|x64.ActiveCfg = Release|x64
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.Release|x64.Build.0 = Release|x64
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {7CE8B0C5-8CD4-4551-ACBF-EC4749E15E69}.ReleaseTests|x64.Build.0 = Release|x64
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Debug|Win32.ActiveCfg = Debug|Win32
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Debug|Win32.Build.0 = Debug|Win32
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Debug|x64.ActiveCfg = Debug|x64
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Debug|x64.Build.0 = Debug|x64
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.DebugTests|Win32.Build.0 = Debug|Win32
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.DebugTests|x64.ActiveCfg = Debug|x64
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.DebugTests|x64.Build.0 = Debug|x64
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Release|Win32.ActiveCfg = Release|Win32
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Release|Win32.Build.0 = Release|Win32
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Release|x64.ActiveCfg = Release|x64
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.Release|x64.Build.0 = Release|x64
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {5510B933-046F-4F75-8B46-5E8279C8CCDE}.ReleaseTests|x64.Build.0 = Release|x64
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Debug|Win32.ActiveCfg = Debug|Win32
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Debug|Win32.Build.0 = Debug|Win32
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Debug|x64.ActiveCfg = Debug|x64
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Debug|x64.Build.0 = Debug|x64
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.DebugTests|Win32.Build.0 = Debug|Win32
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.DebugTests|x64.ActiveCfg = Debug|x64
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.DebugTests|x64.Build.0 = Debug|x64
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Release|Win32.ActiveCfg = Release|Win32
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Release|Win32.Build.0 = Release|Win32
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Release|x64.ActiveCfg = Release|x64
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.Release|x64.Build.0 = Release|x64
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {DD1F3242-7EE4-4F41-8B8D-D833300C445F}.ReleaseTests|x64.Build.0 = Release|x64
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Debug|Win32.ActiveCfg = Debug|Win32
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Debug|Win32.Build.0 = Debug|Win32
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Debug|x64.ActiveCfg = Debug|x64
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Debug|x64.Build.0 = Debug|x64
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.DebugTests|Win32.Build.0 = Debug|Win32
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.DebugTests|x64.ActiveCfg = Debug|x64
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.DebugTests|x64.Build.0 = Debug|x64
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Release|Win32.ActiveCfg = Release|Win32
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Release|Win32.Build.0 = Release|Win32
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Release|x64.ActiveCfg = Release|x64
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.Release|x64.Build.0 = Release|x64
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {10FB6B7E-81A1-47F9-BC6F-7017E5695D3A}.ReleaseTests|x64.Build.0 = Release|x64
+ {B0292250-B70C-4395-9859-F181FB113DA8}.Debug|Win32.ActiveCfg = Debug|Win32
+ {B0292250-B70C-4395-9859-F181FB113DA8}.Debug|Win32.Build.0 = Debug|Win32
+ {B0292250-B70C-4395-9859-F181FB113DA8}.Debug|x64.ActiveCfg = Debug|x64
+ {B0292250-B70C-4395-9859-F181FB113DA8}.Debug|x64.Build.0 = Debug|x64
+ {B0292250-B70C-4395-9859-F181FB113DA8}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {B0292250-B70C-4395-9859-F181FB113DA8}.DebugTests|Win32.Build.0 = Debug|Win32
+ {B0292250-B70C-4395-9859-F181FB113DA8}.DebugTests|x64.ActiveCfg = Debug|x64
+ {B0292250-B70C-4395-9859-F181FB113DA8}.DebugTests|x64.Build.0 = Debug|x64
+ {B0292250-B70C-4395-9859-F181FB113DA8}.Release|Win32.ActiveCfg = Release|Win32
+ {B0292250-B70C-4395-9859-F181FB113DA8}.Release|Win32.Build.0 = Release|Win32
+ {B0292250-B70C-4395-9859-F181FB113DA8}.Release|x64.ActiveCfg = Release|x64
+ {B0292250-B70C-4395-9859-F181FB113DA8}.Release|x64.Build.0 = Release|x64
+ {B0292250-B70C-4395-9859-F181FB113DA8}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {B0292250-B70C-4395-9859-F181FB113DA8}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {B0292250-B70C-4395-9859-F181FB113DA8}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {B0292250-B70C-4395-9859-F181FB113DA8}.ReleaseTests|x64.Build.0 = Release|x64
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Debug|Win32.ActiveCfg = Debug|Win32
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Debug|Win32.Build.0 = Debug|Win32
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Debug|x64.ActiveCfg = Debug|x64
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Debug|x64.Build.0 = Debug|x64
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.DebugTests|Win32.Build.0 = Debug|Win32
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.DebugTests|x64.ActiveCfg = Debug|x64
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.DebugTests|x64.Build.0 = Debug|x64
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Release|Win32.ActiveCfg = Release|Win32
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Release|Win32.Build.0 = Release|Win32
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Release|x64.ActiveCfg = Release|x64
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.Release|x64.Build.0 = Release|x64
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {CBBF380B-7B16-4A1E-8194-758DAD7D8011}.ReleaseTests|x64.Build.0 = Release|x64
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.Debug|Win32.ActiveCfg = Debug|Win32
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.Debug|x64.ActiveCfg = Debug|x64
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.DebugTests|Win32.Build.0 = Debug|Win32
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.DebugTests|x64.ActiveCfg = Debug|x64
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.DebugTests|x64.Build.0 = Debug|x64
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.Release|Win32.ActiveCfg = Release|Win32
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.Release|x64.ActiveCfg = Release|x64
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {2AF37846-09E7-46EB-83AE-1E4C67742EE7}.ReleaseTests|x64.Build.0 = Release|x64
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.Debug|Win32.ActiveCfg = Debug|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.Debug|x64.ActiveCfg = Debug|x64
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.DebugTests|Win32.ActiveCfg = Debug|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.DebugTests|Win32.Build.0 = Debug|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.DebugTests|x64.ActiveCfg = Debug|x64
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.DebugTests|x64.Build.0 = Debug|x64
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.Release|Win32.ActiveCfg = Release|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.Release|x64.ActiveCfg = Release|x64
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.ReleaseTests|Win32.ActiveCfg = Release|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.ReleaseTests|Win32.Build.0 = Release|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.ReleaseTests|x64.ActiveCfg = Release|x64
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.ReleaseTests|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
Index: ext/gmock/COPYING
===================================================================
diff -u
--- ext/gmock/COPYING (revision 0)
+++ ext/gmock/COPYING (revision 409a0af1e9fdea72ca016118d76a5a95e53496e8)
@@ -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.
Index: ext/gmock/Readme.txt
===================================================================
diff -u
--- ext/gmock/Readme.txt (revision 0)
+++ ext/gmock/Readme.txt (revision 409a0af1e9fdea72ca016118d76a5a95e53496e8)
@@ -0,0 +1,2 @@
+gtest/gmock framework version 1.6.0.
+See http://code.google.com/p/googlemock/
\ No newline at end of file
Index: ext/gmock/gmock.sln
===================================================================
diff -u
--- ext/gmock/gmock.sln (revision 0)
+++ ext/gmock/gmock.sln (revision 409a0af1e9fdea72ca016118d76a5a95e53496e8)
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcproj", "{D98F2D98-2352-4303-93EE-A5430C4E98AB}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.Debug|Win32.ActiveCfg = Debug|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.Debug|Win32.Build.0 = Debug|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.Release|Win32.ActiveCfg = Release|Win32
+ {D98F2D98-2352-4303-93EE-A5430C4E98AB}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
Index: ext/gmock/gmock.vcproj
===================================================================
diff -u
--- ext/gmock/gmock.vcproj (revision 0)
+++ ext/gmock/gmock.vcproj (revision 409a0af1e9fdea72ca016118d76a5a95e53496e8)
@@ -0,0 +1,303 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Index: ext/gmock/include/gmock/gmock.h
===================================================================
diff -u
--- ext/gmock/include/gmock/gmock.h (revision 0)
+++ ext/gmock/include/gmock/gmock.h (revision 409a0af1e9fdea72ca016118d76a5a95e53496e8)
@@ -0,0 +1,12822 @@
+// 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 Mock - a framework for writing C++ mock classes.
+//
+// This is the main header file a user should include.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_H_
+
+// This file implements the following syntax:
+//
+// ON_CALL(mock_object.Method(...))
+// .With(...) ?
+// .WillByDefault(...);
+//
+// where With() is optional and WillByDefault() must appear exactly
+// once.
+//
+// EXPECT_CALL(mock_object.Method(...))
+// .With(...) ?
+// .Times(...) ?
+// .InSequence(...) *
+// .WillOnce(...) *
+// .WillRepeatedly(...) ?
+// .RetiresOnSaturation() ? ;
+//
+// where all clauses are optional and WillOnce() can be repeated.
+
+// 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 Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used actions.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+
+#include
+#include
+
+#ifndef _WIN32_WCE
+# include
+#endif
+
+// 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 Mock - a framework for writing C++ mock classes.
+//
+// This file defines some utilities useful for implementing Google
+// Mock. They are subject to change without notice, so please DO NOT
+// USE THEM IN USER CODE.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
+#include
+#include // NOLINT
+#include
+
+// This file was GENERATED by a script. DO NOT EDIT BY HAND!!!
+
+// 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 Mock - a framework for writing C++ mock classes.
+//
+// This file contains template meta-programming utility classes needed
+// for implementing Google Mock.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+
+// 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: vadimb@google.com (Vadim Berman)
+//
+// Low-level types and utilities for porting Google Mock to various
+// platforms. They are subject to change without notice. DO NOT USE
+// THEM IN USER CODE.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+#include
+#include
+#include
+
+// Most of the types needed for porting Google Mock are also required
+// for Google Test and are defined in gtest-port.h.
+#include "gtest/gtest.h"
+
+// To avoid conditional compilation everywhere, we make it
+// gmock-port.h's responsibility to #include the header implementing
+// tr1/tuple. gmock-port.h does this via gtest-port.h, which is
+// guaranteed to pull in the tuple header.
+
+// For MS Visual C++, check the compiler version. At least VS 2003 is
+// required to compile Google Mock.
+#if defined(_MSC_VER) && _MSC_VER < 1310
+# error "At least Visual C++ 2003 (7.1) is required to compile Google Mock."
+#endif
+
+// Macro for referencing flags. This is public as we want the user to
+// use this syntax to reference Google Mock flags.
+#define GMOCK_FLAG(name) FLAGS_gmock_##name
+
+// Macros for declaring flags.
+#define GMOCK_DECLARE_bool_(name) extern bool GMOCK_FLAG(name)
+#define GMOCK_DECLARE_int32_(name) \
+ extern ::testing::internal::Int32 GMOCK_FLAG(name)
+#define GMOCK_DECLARE_string_(name) \
+ extern ::testing::internal::String GMOCK_FLAG(name)
+
+// Macros for defining flags.
+#define GMOCK_DEFINE_bool_(name, default_val, doc) \
+ bool GMOCK_FLAG(name) = (default_val)
+#define GMOCK_DEFINE_int32_(name, default_val, doc) \
+ ::testing::internal::Int32 GMOCK_FLAG(name) = (default_val)
+#define GMOCK_DEFINE_string_(name, default_val, doc) \
+ ::testing::internal::String GMOCK_FLAG(name) = (default_val)
+
+#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+namespace testing {
+
+template
+class Matcher;
+
+namespace internal {
+
+// An IgnoredValue object can be implicitly constructed from ANY value.
+// This is used in implementing the IgnoreResult(a) action.
+class IgnoredValue {
+ public:
+ // This constructor template allows any value to be implicitly
+ // converted to IgnoredValue. The object has no data member and
+ // doesn't try to remember anything about the argument. We
+ // deliberately omit the 'explicit' keyword in order to allow the
+ // conversion to be implicit.
+ template
+ IgnoredValue(const T&) {}
+};
+
+// MatcherTuple::type is a tuple type where each field is a Matcher
+// for the corresponding field in tuple type T.
+template
+struct MatcherTuple;
+
+template <>
+struct MatcherTuple< ::std::tr1::tuple<> > {
+ typedef ::std::tr1::tuple< > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher, Matcher > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher, Matcher,
+ Matcher > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher, Matcher, Matcher,
+ Matcher > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher, Matcher, Matcher,
+ Matcher, Matcher > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher, Matcher, Matcher,
+ Matcher, Matcher, Matcher > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher, Matcher, Matcher,
+ Matcher, Matcher, Matcher, Matcher > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher, Matcher, Matcher,
+ Matcher, Matcher, Matcher, Matcher, Matcher > type;
+};
+
+template
+struct MatcherTuple< ::std::tr1::tuple > {
+ typedef ::std::tr1::tuple, Matcher, Matcher, Matcher,
+ Matcher, Matcher, Matcher, Matcher, Matcher,
+ Matcher > type;
+};
+
+// Template struct Function, where F must be a function type, contains
+// the following typedefs:
+//
+// Result: the function's return type.
+// ArgumentN: the type of the N-th argument, where N starts with 1.
+// ArgumentTuple: the tuple type consisting of all parameters of F.
+// ArgumentMatcherTuple: the tuple type consisting of Matchers for all
+// parameters of F.
+// MakeResultVoid: the function type obtained by substituting void
+// for the return type of F.
+// MakeResultIgnoredValue:
+// the function type obtained by substituting Something
+// for the return type of F.
+template
+struct Function;
+
+template
+struct Function {
+ typedef R Result;
+ typedef ::std::tr1::tuple<> ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid();
+ typedef IgnoredValue MakeResultIgnoredValue();
+};
+
+template
+struct Function
+ : Function {
+ typedef A1 Argument1;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1);
+ typedef IgnoredValue MakeResultIgnoredValue(A1);
+};
+
+template
+struct Function
+ : Function {
+ typedef A2 Argument2;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
+};
+
+template
+struct Function
+ : Function {
+ typedef A3 Argument3;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2, A3);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
+};
+
+template
+struct Function
+ : Function {
+ typedef A4 Argument4;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2, A3, A4);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
+};
+
+template
+struct Function
+ : Function {
+ typedef A5 Argument5;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2, A3, A4, A5);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
+};
+
+template
+struct Function
+ : Function {
+ typedef A6 Argument6;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
+};
+
+template
+struct Function
+ : Function {
+ typedef A7 Argument7;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
+};
+
+template
+struct Function
+ : Function {
+ typedef A8 Argument8;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8);
+};
+
+template
+struct Function
+ : Function {
+ typedef A9 Argument9;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
+ A9);
+};
+
+template
+struct Function
+ : Function {
+ typedef A10 Argument10;
+ typedef ::std::tr1::tuple ArgumentTuple;
+ typedef typename MatcherTuple::type ArgumentMatcherTuple;
+ typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+ typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
+ A9, A10);
+};
+
+} // namespace internal
+
+} // namespace testing
+
+#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+
+namespace testing {
+namespace internal {
+
+// Converts an identifier name to a space-separated list of lower-case
+// words. Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
+// treated as one word. For example, both "FooBar123" and
+// "foo_bar_123" are converted to "foo bar 123".
+string ConvertIdentifierNameToWords(const char* id_name);
+
+// PointeeOf::type is the type of a value pointed to by a
+// Pointer, which can be either a smart pointer or a raw pointer. The
+// following default implementation is for the case where Pointer is a
+// smart pointer.
+template
+struct PointeeOf {
+ // Smart pointer classes define type element_type as the type of
+ // their pointees.
+ typedef typename Pointer::element_type type;
+};
+// This specialization is for the raw pointer case.
+template
+struct PointeeOf { typedef T type; }; // NOLINT
+
+// GetRawPointer(p) returns the raw pointer underlying p when p is a
+// smart pointer, or returns p itself when p is already a raw pointer.
+// The following default implementation is for the smart pointer case.
+template
+inline typename Pointer::element_type* GetRawPointer(const Pointer& p) {
+ return p.get();
+}
+// This overloaded version is for the raw pointer case.
+template
+inline Element* GetRawPointer(Element* p) { return p; }
+
+// This comparator allows linked_ptr to be stored in sets.
+template
+struct LinkedPtrLessThan {
+ bool operator()(const ::testing::internal::linked_ptr& lhs,
+ const ::testing::internal::linked_ptr& rhs) const {
+ return lhs.get() < rhs.get();
+ }
+};
+
+// Symbian compilation can be done with wchar_t being either a native
+// type or a typedef. Using Google Mock with OpenC without wchar_t
+// should require the definition of _STLP_NO_WCHAR_T.
+//
+// MSVC treats wchar_t as a native type usually, but treats it as the
+// same as unsigned short when the compiler option /Zc:wchar_t- is
+// specified. It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
+// is a native type.
+#if (GTEST_OS_SYMBIAN && defined(_STLP_NO_WCHAR_T)) || \
+ (defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED))
+// wchar_t is a typedef.
+#else
+# define GMOCK_WCHAR_T_IS_NATIVE_ 1
+#endif
+
+// signed wchar_t and unsigned wchar_t are NOT in the C++ standard.
+// Using them is a bad practice and not portable. So DON'T use them.
+//
+// Still, Google Mock is designed to work even if the user uses signed
+// wchar_t or unsigned wchar_t (obviously, assuming the compiler
+// supports them).
+//
+// To gcc,
+// wchar_t == signed wchar_t != unsigned wchar_t == unsigned int
+#ifdef __GNUC__
+// signed/unsigned wchar_t are valid types.
+# define GMOCK_HAS_SIGNED_WCHAR_T_ 1
+#endif
+
+// In what follows, we use the term "kind" to indicate whether a type
+// is bool, an integer type (excluding bool), a floating-point type,
+// or none of them. This categorization is useful for determining
+// when a matcher argument type can be safely converted to another
+// type in the implementation of SafeMatcherCast.
+enum TypeKind {
+ kBool, kInteger, kFloatingPoint, kOther
+};
+
+// KindOf::value is the kind of type T.
+template struct KindOf {
+ enum { value = kOther }; // The default kind.
+};
+
+// This macro declares that the kind of 'type' is 'kind'.
+#define GMOCK_DECLARE_KIND_(type, kind) \
+ template <> struct KindOf { enum { value = kind }; }
+
+GMOCK_DECLARE_KIND_(bool, kBool);
+
+// All standard integer types.
+GMOCK_DECLARE_KIND_(char, kInteger);
+GMOCK_DECLARE_KIND_(signed char, kInteger);
+GMOCK_DECLARE_KIND_(unsigned char, kInteger);
+GMOCK_DECLARE_KIND_(short, kInteger); // NOLINT
+GMOCK_DECLARE_KIND_(unsigned short, kInteger); // NOLINT
+GMOCK_DECLARE_KIND_(int, kInteger);
+GMOCK_DECLARE_KIND_(unsigned int, kInteger);
+GMOCK_DECLARE_KIND_(long, kInteger); // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long, kInteger); // NOLINT
+
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DECLARE_KIND_(wchar_t, kInteger);
+#endif
+
+// Non-standard integer types.
+GMOCK_DECLARE_KIND_(Int64, kInteger);
+GMOCK_DECLARE_KIND_(UInt64, kInteger);
+
+// All standard floating-point types.
+GMOCK_DECLARE_KIND_(float, kFloatingPoint);
+GMOCK_DECLARE_KIND_(double, kFloatingPoint);
+GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
+
+#undef GMOCK_DECLARE_KIND_
+
+// Evaluates to the kind of 'type'.
+#define GMOCK_KIND_OF_(type) \
+ static_cast< ::testing::internal::TypeKind>( \
+ ::testing::internal::KindOf::value)
+
+// Evaluates to true iff integer type T is signed.
+#define GMOCK_IS_SIGNED_(T) (static_cast(-1) < 0)
+
+// LosslessArithmeticConvertibleImpl::value
+// is true iff arithmetic type From can be losslessly converted to
+// arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types, kFromKind is the kind of
+// From, and kToKind is the kind of To; the value is
+// implementation-defined when the above pre-condition is violated.
+template
+struct LosslessArithmeticConvertibleImpl : public false_type {};
+
+// Converting bool to bool is lossless.
+template <>
+struct LosslessArithmeticConvertibleImpl
+ : public true_type {}; // NOLINT
+
+// Converting bool to any integer type is lossless.
+template
+struct LosslessArithmeticConvertibleImpl
+ : public true_type {}; // NOLINT
+
+// Converting bool to any floating-point type is lossless.
+template
+struct LosslessArithmeticConvertibleImpl
+ : public true_type {}; // NOLINT
+
+// Converting an integer to bool is lossy.
+template
+struct LosslessArithmeticConvertibleImpl
+ : public false_type {}; // NOLINT
+
+// Converting an integer to another non-bool integer is lossless iff
+// the target type's range encloses the source type's range.
+template
+struct LosslessArithmeticConvertibleImpl
+ : public bool_constant<
+ // When converting from a smaller size to a larger size, we are
+ // fine as long as we are not converting from signed to unsigned.
+ ((sizeof(From) < sizeof(To)) &&
+ (!GMOCK_IS_SIGNED_(From) || GMOCK_IS_SIGNED_(To))) ||
+ // When converting between the same size, the signedness must match.
+ ((sizeof(From) == sizeof(To)) &&
+ (GMOCK_IS_SIGNED_(From) == GMOCK_IS_SIGNED_(To)))> {}; // NOLINT
+
+#undef GMOCK_IS_SIGNED_
+
+// Converting an integer to a floating-point type may be lossy, since
+// the format of a floating-point number is implementation-defined.
+template
+struct LosslessArithmeticConvertibleImpl
+ : public false_type {}; // NOLINT
+
+// Converting a floating-point to bool is lossy.
+template
+struct LosslessArithmeticConvertibleImpl
+ : public false_type {}; // NOLINT
+
+// Converting a floating-point to an integer is lossy.
+template
+struct LosslessArithmeticConvertibleImpl
+ : public false_type {}; // NOLINT
+
+// Converting a floating-point to another floating-point is lossless
+// iff the target type is at least as big as the source type.
+template
+struct LosslessArithmeticConvertibleImpl<
+ kFloatingPoint, From, kFloatingPoint, To>
+ : public bool_constant {}; // NOLINT
+
+// LosslessArithmeticConvertible::value is true iff arithmetic
+// type From can be losslessly converted to arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types; the value is
+// implementation-defined when the above pre-condition is violated.
+template
+struct LosslessArithmeticConvertible
+ : public LosslessArithmeticConvertibleImpl<
+ GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To> {}; // NOLINT
+
+// This interface knows how to report a Google Mock failure (either
+// non-fatal or fatal).
+class FailureReporterInterface {
+ public:
+ // The type of a failure (either non-fatal or fatal).
+ enum FailureType {
+ NONFATAL, FATAL
+ };
+
+ virtual ~FailureReporterInterface() {}
+
+ // Reports a failure that occurred at the given source file location.
+ virtual void ReportFailure(FailureType type, const char* file, int line,
+ const string& message) = 0;
+};
+
+// Returns the failure reporter used by Google Mock.
+FailureReporterInterface* GetFailureReporter();
+
+// Asserts that condition is true; aborts the process with the given
+// message if condition is false. We cannot use LOG(FATAL) or CHECK()
+// as Google Mock might be used to mock the log sink itself. We
+// inline this function to prevent it from showing up in the stack
+// trace.
+inline void Assert(bool condition, const char* file, int line,
+ const string& msg) {
+ if (!condition) {
+ GetFailureReporter()->ReportFailure(FailureReporterInterface::FATAL,
+ file, line, msg);
+ }
+}
+inline void Assert(bool condition, const char* file, int line) {
+ Assert(condition, file, line, "Assertion failed.");
+}
+
+// Verifies that condition is true; generates a non-fatal failure if
+// condition is false.
+inline void Expect(bool condition, const char* file, int line,
+ const string& msg) {
+ if (!condition) {
+ GetFailureReporter()->ReportFailure(FailureReporterInterface::NONFATAL,
+ file, line, msg);
+ }
+}
+inline void Expect(bool condition, const char* file, int line) {
+ Expect(condition, file, line, "Expectation failed.");
+}
+
+// Severity level of a log.
+enum LogSeverity {
+ INFO = 0,
+ WARNING = 1
+};
+
+// Valid values for the --gmock_verbose flag.
+
+// All logs (informational and warnings) are printed.
+const char kInfoVerbosity[] = "info";
+// Only warnings are printed.
+const char kWarningVerbosity[] = "warning";
+// No logs are printed.
+const char kErrorVerbosity[] = "error";
+
+// Returns true iff a log with the given severity is visible according
+// to the --gmock_verbose flag.
+bool LogIsVisible(LogSeverity severity);
+
+// Prints the given message to stdout iff 'severity' >= the level
+// specified by the --gmock_verbose flag. If stack_frames_to_skip >=
+// 0, also prints the stack trace excluding the top
+// stack_frames_to_skip frames. In opt mode, any positive
+// stack_frames_to_skip is treated as 0, since we don't know which
+// function calls will be inlined by the compiler and need to be
+// conservative.
+void Log(LogSeverity severity, const string& message, int stack_frames_to_skip);
+
+// TODO(wan@google.com): group all type utilities together.
+
+// Type traits.
+
+// is_reference::value is non-zero iff T is a reference type.
+template struct is_reference : public false_type {};
+template struct is_reference : public true_type {};
+
+// type_equals::value is non-zero iff T1 and T2 are the same type.
+template struct type_equals : public false_type {};
+template struct type_equals : public true_type {};
+
+// remove_reference::type removes the reference from type T, if any.
+template struct remove_reference { typedef T type; }; // NOLINT
+template struct remove_reference { typedef T type; }; // NOLINT
+
+// Invalid() returns an invalid value of type T. This is useful
+// when a value of type T is needed for compilation, but the statement
+// will not really be executed (or we don't care if the statement
+// crashes).
+template
+inline T Invalid() {
+ return *static_cast::type*>(NULL);
+}
+template <>
+inline void Invalid() {}
+
+// Given a raw type (i.e. having no top-level reference or const
+// modifier) RawContainer that's either an STL-style container or a
+// native array, class StlContainerView has the
+// following members:
+//
+// - type is a type that provides an STL-style container view to
+// (i.e. implements the STL container concept for) RawContainer;
+// - const_reference is a type that provides a reference to a const
+// RawContainer;
+// - ConstReference(raw_container) returns a const reference to an STL-style
+// container view to raw_container, which is a RawContainer.
+// - Copy(raw_container) returns an STL-style container view of a
+// copy of raw_container, which is a RawContainer.
+//
+// This generic version is used when RawContainer itself is already an
+// STL-style container.
+template
+class StlContainerView {
+ public:
+ typedef RawContainer type;
+ typedef const type& const_reference;
+
+ static const_reference ConstReference(const RawContainer& container) {
+ // Ensures that RawContainer is not a const type.
+ testing::StaticAssertTypeEq();
+ return container;
+ }
+ static type Copy(const RawContainer& container) { return container; }
+};
+
+// This specialization is used when RawContainer is a native array type.
+template
+class StlContainerView {
+ public:
+ typedef GTEST_REMOVE_CONST_(Element) RawElement;
+ typedef internal::NativeArray type;
+ // NativeArray can represent a native array either by value or by
+ // reference (selected by a constructor argument), so 'const type'
+ // can be used to reference a const native array. We cannot
+ // 'typedef const type& const_reference' here, as that would mean
+ // ConstReference() has to return a reference to a local variable.
+ typedef const type const_reference;
+
+ static const_reference ConstReference(const Element (&array)[N]) {
+ // Ensures that Element is not a const type.
+ testing::StaticAssertTypeEq();
+#if GTEST_OS_SYMBIAN
+ // The Nokia Symbian compiler confuses itself in template instantiation
+ // for this call without the cast to Element*:
+ // function call '[testing::internal::NativeArray].NativeArray(
+ // {lval} const char *[4], long, testing::internal::RelationToSource)'
+ // does not match
+ // 'testing::internal::NativeArray::NativeArray(
+ // char *const *, unsigned int, testing::internal::RelationToSource)'
+ // (instantiating: 'testing::internal::ContainsMatcherImpl
+ // ::Matches(const char * (&)[4]) const')
+ // (instantiating: 'testing::internal::StlContainerView::
+ // ConstReference(const char * (&)[4])')
+ // (and though the N parameter type is mismatched in the above explicit
+ // conversion of it doesn't help - only the conversion of the array).
+ return type(const_cast(&array[0]), N, kReference);
+#else
+ return type(array, N, kReference);
+#endif // GTEST_OS_SYMBIAN
+ }
+ static type Copy(const Element (&array)[N]) {
+#if GTEST_OS_SYMBIAN
+ return type(const_cast(&array[0]), N, kCopy);
+#else
+ return type(array, N, kCopy);
+#endif // GTEST_OS_SYMBIAN
+ }
+};
+
+// This specialization is used when RawContainer is a native array
+// represented as a (pointer, size) tuple.
+template
+class StlContainerView< ::std::tr1::tuple > {
+ public:
+ typedef GTEST_REMOVE_CONST_(
+ typename internal::PointeeOf::type) RawElement;
+ typedef internal::NativeArray type;
+ typedef const type const_reference;
+
+ static const_reference ConstReference(
+ const ::std::tr1::tuple& array) {
+ using ::std::tr1::get;
+ return type(get<0>(array), get<1>(array), kReference);
+ }
+ static type Copy(const ::std::tr1::tuple& array) {
+ using ::std::tr1::get;
+ return type(get<0>(array), get<1>(array), kCopy);
+ }
+};
+
+// The following specialization prevents the user from instantiating
+// StlContainer with a reference type.
+template class StlContainerView;
+
+} // namespace internal
+} // namespace testing
+
+#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
+namespace testing {
+
+// To implement an action Foo, define:
+// 1. a class FooAction that implements the ActionInterface interface, and
+// 2. a factory function that creates an Action object from a
+// const FooAction*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers. It also eases ownership
+// management as Action objects can now be copied like plain values.
+
+namespace internal {
+
+template
+class ActionAdaptor;
+
+// BuiltInDefaultValue::Get() returns the "built-in" default
+// value for type T, which is NULL when T is a pointer type, 0 when T
+// is a numeric type, false when T is bool, or "" when T is string or
+// std::string. For any other type T, this value is undefined and the
+// function will abort the process.
+template
+class BuiltInDefaultValue {
+ public:
+ // This function returns true iff type T has a built-in default value.
+ static bool Exists() { return false; }
+ static T Get() {
+ Assert(false, __FILE__, __LINE__,
+ "Default action undefined for the function return type.");
+ return internal::Invalid();
+ // The above statement will never be reached, but is required in
+ // order for this function to compile.
+ }
+};
+
+// This partial specialization says that we use the same built-in
+// default value for T and const T.
+template
+class BuiltInDefaultValue {
+ public:
+ static bool Exists() { return BuiltInDefaultValue::Exists(); }
+ static T Get() { return BuiltInDefaultValue::Get(); }
+};
+
+// This partial specialization defines the default values for pointer
+// types.
+template
+class BuiltInDefaultValue {
+ public:
+ static bool Exists() { return true; }
+ static T* Get() { return NULL; }
+};
+
+// The following specializations define the default values for
+// specific types we care about.
+#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
+ template <> \
+ class BuiltInDefaultValue { \
+ public: \
+ static bool Exists() { return true; } \
+ static type Get() { return value; } \
+ }
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, ); // NOLINT
+#if GTEST_HAS_GLOBAL_STRING
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::string, "");
+#endif // GTEST_HAS_GLOBAL_STRING
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
+
+// There's no need for a default action for signed wchar_t, as that
+// type is the same as wchar_t for gcc, and invalid for MSVC.
+//
+// There's also no need for a default action for unsigned wchar_t, as
+// that type is the same as unsigned int for gcc, and invalid for
+// MSVC.
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U); // NOLINT
+#endif
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U); // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0); // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL); // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L); // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(UInt64, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(Int64, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
+
+#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
+
+} // namespace internal
+
+// When an unexpected function call is encountered, Google Mock will
+// let it return a default value if the user has specified one for its
+// return type, or if the return type has a built-in default value;
+// otherwise Google Mock won't know what value to return and will have
+// to abort the process.
+//
+// The DefaultValue class allows a user to specify the
+// default value for a type T that is both copyable and publicly
+// destructible (i.e. anything that can be used as a function return
+// type). The usage is:
+//
+// // Sets the default value for type T to be foo.
+// DefaultValue::Set(foo);
+template
+class DefaultValue {
+ public:
+ // Sets the default value for type T; requires T to be
+ // copy-constructable and have a public destructor.
+ static void Set(T x) {
+ delete value_;
+ value_ = new T(x);
+ }
+
+ // Unsets the default value for type T.
+ static void Clear() {
+ delete value_;
+ value_ = NULL;
+ }
+
+ // Returns true iff the user has set the default value for type T.
+ static bool IsSet() { return value_ != NULL; }
+
+ // Returns true if T has a default return value set by the user or there
+ // exists a built-in default value.
+ static bool Exists() {
+ return IsSet() || internal::BuiltInDefaultValue::Exists();
+ }
+
+ // Returns the default value for type T if the user has set one;
+ // otherwise returns the built-in default value if there is one;
+ // otherwise aborts the process.
+ static T Get() {
+ return value_ == NULL ?
+ internal::BuiltInDefaultValue::Get() : *value_;
+ }
+ private:
+ static const T* value_;
+};
+
+// This partial specialization allows a user to set default values for
+// reference types.
+template
+class DefaultValue {
+ public:
+ // Sets the default value for type T&.
+ static void Set(T& x) { // NOLINT
+ address_ = &x;
+ }
+
+ // Unsets the default value for type T&.
+ static void Clear() {
+ address_ = NULL;
+ }
+
+ // Returns true iff the user has set the default value for type T&.
+ static bool IsSet() { return address_ != NULL; }
+
+ // Returns true if T has a default return value set by the user or there
+ // exists a built-in default value.
+ static bool Exists() {
+ return IsSet() || internal::BuiltInDefaultValue::Exists();
+ }
+
+ // Returns the default value for type T& if the user has set one;
+ // otherwise returns the built-in default value if there is one;
+ // otherwise aborts the process.
+ static T& Get() {
+ return address_ == NULL ?
+ internal::BuiltInDefaultValue::Get() : *address_;
+ }
+ private:
+ static T* address_;
+};
+
+// This specialization allows DefaultValue::Get() to
+// compile.
+template <>
+class DefaultValue {
+ public:
+ static bool Exists() { return true; }
+ static void Get() {}
+};
+
+// Points to the user-set default value for type T.
+template
+const T* DefaultValue::value_ = NULL;
+
+// Points to the user-set default value for type T&.
+template
+T* DefaultValue::address_ = NULL;
+
+// Implement this interface to define an action for function type F.
+template
+class ActionInterface {
+ public:
+ typedef typename internal::Function::Result Result;
+ typedef typename internal::Function::ArgumentTuple ArgumentTuple;
+
+ ActionInterface() {}
+ virtual ~ActionInterface() {}
+
+ // Performs the action. This method is not const, as in general an
+ // action can have side effects and be stateful. For example, a
+ // get-the-next-element-from-the-collection action will need to
+ // remember the current element.
+ virtual Result Perform(const ArgumentTuple& args) = 0;
+
+ private:
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
+};
+
+// An Action is a copyable and IMMUTABLE (except by assignment)
+// object that represents an action to be taken when a mock function
+// of type F is called. The implementation of Action is just a
+// linked_ptr to const ActionInterface, so copying is fairly cheap.
+// Don't inherit from Action!
+//
+// You can view an object implementing ActionInterface as a
+// concrete action (including its current state), and an Action
+// object as a handle to it.
+template
+class Action {
+ public:
+ typedef typename internal::Function::Result Result;
+ typedef typename internal::Function::ArgumentTuple ArgumentTuple;
+
+ // Constructs a null Action. Needed for storing Action objects in
+ // STL containers.
+ Action() : impl_(NULL) {}
+
+ // Constructs an Action from its implementation. A NULL impl is
+ // used to represent the "do-default" action.
+ explicit Action(ActionInterface