Commits

Matt Oswald committed 5fed1bb

moved all tests into Tests subdir

  • Participants
  • Parent commits 65bfa3f

Comments (0)

Files changed (50)

File BareTests/BareTest.cpp

-#include "xUnit++.h"
-
-//
-// FilteredTestsRunner has a tendency to not get linked into the test dlls.
-// This is the simplest valid test library possible, and is intended to ensure
-// this error does not happen in the future.
-//
-FACT(BareTest)
-{
-}

File BareTests/BareTests.vcxproj

-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{EDEB02E2-F389-4CBF-AE7D-3041A934F86B}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>BareTests</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="..\.build\output.props" />
-    <Import Project="..\.build\build.props" />
-    <Import Project="..\.build\debug.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="..\.build\output.props" />
-    <Import Project="..\.build\build.props" />
-    <Import Project="..\.build\debug.props" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="..\.build\output.props" />
-    <Import Project="..\.build\build.props" />
-    <Import Project="..\.build\release.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="..\.build\output.props" />
-    <Import Project="..\.build\build.props" />
-    <Import Project="..\.build\release.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
-    </ClCompile>
-    <PostBuildEvent>
-      <Command>"$(OutputPath)../../../xUnit++.console/$(Configuration)/$(PlatformShortName)/xUnit++.console.exe" "$(TargetPath)"</Command>
-    </PostBuildEvent>
-    <PostBuildEvent>
-      <Message>Running Bare Tests...</Message>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="BareTest.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\xUnit++\xUnit++.vcxproj">
-      <Project>{25df3961-f288-4a96-ae6b-a4950a00ab8e}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

File BareTests/BareTests.vcxproj.filters

-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <ClCompile Include="BareTest.cpp" />
-  </ItemGroup>
-</Project>

File Tests/Assert.Contains.cpp

-#include <string>
-#include <vector>
-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertContains)
-{
-
-FACT(ContainsForSequenceSuccess)
-{
-    std::vector<int> v(1, 0);
-
-    Assert.Contains(v, 0);
-}
-
-FACT(ContainsForSequenceAssertsOnFailure)
-{
-    std::vector<int> v;
-
-    Assert.Throws<xUnitAssert>([&]() { Assert.Contains(v, 0); });
-}
-
-FACT(ContainsForSequenceAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-    std::vector<int> v;
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Contains(v, 0, msg); });
-    auto what = std::string(assert.what());
-
-    Assert.NotEqual(std::string::npos, what.find(msg));
-}
-
-FACT(ContainsForStringSuccess)
-{
-    std::string actual = "abcd";
-
-    Assert.Contains(actual, "a");
-}
-
-FACT(ContainsForStringAssertsOnFailure)
-{
-    std::string actual = "abcd";
-
-    Assert.Throws<xUnitAssert>([&]() { Assert.Contains(actual, "xyz"); });
-}
-
-FACT(ContainsForStringAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-    std::string actual = "abcd";
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Contains(actual, "xyz", msg); });
-    auto what = std::string(assert.what());
-
-    Assert.NotEqual(std::string::npos, what.find(msg));
-}
-
-}

File Tests/Assert.DoesNotContain.cpp

-#include <string>
-#include <vector>
-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertDoesNotContain)
-{
-
-FACT(DoesNotContainForSequenceSuccess)
-{
-    std::vector<int> v;
-
-    Assert.DoesNotContain(v, 0);
-}
-
-FACT(DoesNotContainForSequenceAssertsOnFailure)
-{
-    std::vector<int> v(1, 0);
-
-    Assert.Throws<xUnitAssert>([&]() { Assert.DoesNotContain(v, 0); });
-}
-
-FACT(DoesNotContainForSequenceAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-    std::vector<int> v(1, 0);
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.DoesNotContain(v, 0, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-FACT(DoesNotContainForStringSuccess)
-{
-    std::string actual = "abcd";
-
-    Assert.DoesNotContain(actual, "xyz");
-}
-
-FACT(DoesNotContainForStringAssertsOnFailure)
-{
-    std::string actual = "abcd";
-
-    Assert.Throws<xUnitAssert>([&]() { Assert.DoesNotContain(actual, "bc"); });
-}
-
-FACT(DoesNotContainForStringAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-    std::string actual = "abcd";
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.DoesNotContain(actual, "ab", msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Assert.DoesNotThrow.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertDoesNotThrow)
-{
-
-FACT(DoesNotThrowSuccess)
-{
-    try
-    {
-        Assert.DoesNotThrow([]() { });
-    }
-    catch(...)
-    {
-        Assert.Fail();
-    }
-}
-
-FACT(DoesNotThrowAssertsOnFailure)
-{
-    static const std::string msg = "xUnit++";
-
-    try
-    {
-        Assert.DoesNotThrow([=]() { throw std::exception(msg.c_str()); });
-    }
-    catch(const xUnitAssert &)
-    {
-        return;
-    }
-
-    Assert.Fail();
-}
-
-FACT(DoesNotThrowAppendsMessages)
-{
-    static const std::string exceptionMessage = "xUnit++";
-    static const std::string userMessage = "custom";
-
-    try
-    {
-        Assert.DoesNotThrow([=]() { throw std::exception(exceptionMessage.c_str()); }, userMessage);
-    }
-    catch(const xUnitAssert &assert)
-    {
-        Assert.Contains(assert.what(), exceptionMessage.c_str());
-        Assert.Contains(assert.what(), userMessage.c_str());
-        return;
-    }
-
-    Assert.Fail();
-}
-
-}

File Tests/Assert.Empty.cpp

-#include <vector>
-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-namespace
-{
-    struct
-    {
-        bool empty() const
-        {
-            return true;
-        }
-    } hasConstEmpty;
-
-    namespace Local
-    {
-        struct Container
-        {
-        };
-
-        int begin(const Container &)
-        {
-            return 0;
-        }
-
-        int end(const Container &)
-        {
-            return 0;
-        }
-    }
-}
-
-SUITE(AssertEmpty)
-{
-
-FACT(EmptyCallsEmptyForContainerWithConstEmptyMember)
-{
-    Assert.Empty(hasConstEmpty);
-}
-
-FACT(EmptyFindsLocalBeginEnd)
-{
-    Assert.Empty(Local::Container());
-}
-
-FACT(EmptyFindsStdBeginEnd)
-{
-    int array[10];
-    Assert.Throws<xUnitAssert>([&]() { Assert.Empty(array); });
-}
-
-FACT(EmptyFindsMemberBeginEnd)
-{
-    struct
-    {
-        int begin() const
-        {
-            return 0;
-        }
-
-        int end() const
-        {
-            return 0;
-        }
-    } hasMembers;
-
-    Assert.Empty(hasMembers);
-}
-
-FACT(EmptyAssertsOnFailure)
-{
-    std::vector<int> v;
-    v.push_back(0);
-    v.push_back(1);
-
-    Assert.Throws<xUnitAssert>([&]() { Assert.Empty(v); });
-}
-
-FACT(EmptyAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-
-    std::vector<int> v;
-    v.push_back(0);
-    v.push_back(1);
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Empty(v, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Assert.Equal.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertEqual)
-{
-
-FACT(AssertEqualWithDefaultComparerWithSuccess)
-{
-    Assert.Equal(0, 0);
-}
-
-FACT(AssertEqualWithDefaultComparerAssertsOnFailure)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.Equal(0, 1); });
-}
-
-FACT(AssertEqualWithCustomComparerWithSuccess)
-{
-    Assert.Equal(0, 1, [](int, int) { return true; });
-}
-
-FACT(AssertEqualWithCustomComparerAssertsOnFailure)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.Equal(0, 0, [](int, int) { return false; }); });
-}
-
-FACT(AssertEqualAppendsUserMessage)
-{
-    static const std::string msg = "custom message";
-
-    auto assert = Assert.Throws<xUnitAssert>([]() { Assert.Equal(0, 1, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-FACT(AssertEqualForFloatsWithinPrecision)
-{
-    auto f0 = 1.2345678f;
-    auto f1 = 1.2349999f;
-
-    Assert.Equal(f0, f1, 3);
-}
-
-FACT(AssertEqualForFloatsAssertsOnFailure)
-{
-    auto f0 = 1.2345678f;
-    auto f1 = 1.2349999f;
-
-    Assert.Throws<xUnitAssert>([=]() { Assert.Equal(f0, f1, 4); });
-}
-
-FACT(AssertSequenceEqualDefaultComparerWithSuccess)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-    v0.push_back(2);
-    v0.push_back(3);
-
-    std::vector<long long> v1;
-    v1.push_back(0);
-    v1.push_back(1);
-    v1.push_back(2);
-    v1.push_back(3);
-
-    Assert.Equal(v0.begin(), v0.end(), v1.begin(), v1.end());
-}
-
-FACT(AssertSequenceEqualDefaultComparerAssertsOnFailureDueToLength)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-
-    std::vector<long long> v1;
-    v1.push_back(0);
-    v1.push_back(1);
-    v1.push_back(2);
-    v1.push_back(3);
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Equal(v0.begin(), v0.end(), v1.begin(), v1.end()); });
-
-    Assert.Contains(assert.what(), "at location 2");
-}
-
-FACT(AssertSequenceEqualDefaultComparerAssertsOnFailureDueToMismatch)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(0);
-
-    std::vector<long long> v1;
-    v1.push_back(0);
-    v1.push_back(1);
-    v1.push_back(2);
-    v1.push_back(3);
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Equal(v0.begin(), v0.end(), v1.begin(), v1.end()); });
-
-    Assert.Contains(assert.what(), "at location 1");
-}
-
-FACT(AssertSequenceEqualCustomComparerWithSuccess)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-    v0.push_back(2);
-    v0.push_back(3);
-
-    std::vector<long long> v1;
-    v1.push_back(10);
-    v1.push_back(11);
-    v1.push_back(12);
-    v1.push_back(13);
-
-    Assert.Equal(v0.begin(), v0.end(), v1.begin(), v1.end(), [](int, long long) { return true; });
-}
-
-FACT(AssertSequenceEqualCustomComparerAssertsOnFailureDueToLength)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-
-    std::vector<long long> v1;
-    v1.push_back(0);
-    v1.push_back(1);
-    v1.push_back(2);
-    v1.push_back(3);
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Equal(v0.begin(), v0.end(), v1.begin(), v1.end(), [](int, long long) { return true; }); });
-
-    Assert.Contains(assert.what(), "at location 2");
-}
-
-FACT(AssertSequenceEqualDefaultAssertsOnFailureDueToMismatch)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-
-    std::vector<long long> v1;
-    v1.push_back(0);
-    v1.push_back(1);
-    v1.push_back(2);
-    v1.push_back(3);
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Equal(v0.begin(), v0.end(), v1.begin(), v1.end(), [](int, long long) { return false; }); });
-
-    Assert.Contains(assert.what(), "at location 0");
-}
-
-}

File Tests/Assert.Fail.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertFail)
-{
-
-FACT(FailAlwaysAsserts)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.Fail(); });
-}
-
-FACT(FailAppendsMessage)
-{
-    static const std::string msg = "xUnit++";
-
-    auto assert = Assert.Throws<xUnitAssert>([]() { Assert.Fail(msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Assert.False.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertFalse)
-{
-
-FACT(FalseSuccess)
-{
-    Assert.False(false);
-}
-
-FACT(FalseAssertsOnTrue)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.False(true); });
-}
-
-FACT(FalseAppendsCustomMessage)
-{
-    static const std::string msg = "xUnit++";
-
-    auto assert = Assert.Throws<xUnitAssert>([]() { Assert.False(true, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Assert.InRange.cpp

-#include <tuple>
-#include <vector>
-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertInRange)
-{
-
-std::vector<std::tuple<float, int, int>> InRangeSuccessData()
-{
-    std::vector<std::tuple<float, int, int>> data;
-
-    data.push_back(std::make_tuple(0.0f, 0, 1));
-    data.push_back(std::make_tuple(0.5f, 0, 1));
-    data.push_back(std::make_tuple(0.0f, -1, 1));
-    data.push_back(std::make_tuple(-1.0f, -1, 0));
-
-    return data;
-}
-
-THEORY(InRangeSuccess, (float actual, int min, int max), InRangeSuccessData)
-{
-    Assert.InRange(actual, min, max);
-}
-
-std::vector<std::tuple<int, int, int>> InRangeAssertsOnFailureData()
-{
-    std::vector<std::tuple<int, int, int>> data;
-
-    data.push_back(std::make_tuple(1, 0, 1));
-    data.push_back(std::make_tuple(2, 0, 1));
-    data.push_back(std::make_tuple(-1, 0, 1));
-    data.push_back(std::make_tuple(-3, -2, 1));
-    data.push_back(std::make_tuple(1, -2, 1));
-    data.push_back(std::make_tuple(2, -2, 1));
-
-    return data;
-}
-
-THEORY(InRangeAssertsOnFailure, (int actual, int min, int max), InRangeAssertsOnFailureData)
-{
-    Assert.Throws<xUnitAssert>([=]() { Assert.InRange(actual, min, max); });
-}
-
-FACT(InRangeAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-
-    auto assert = Assert.Throws<xUnitAssert>([=]() { Assert.InRange(1, 0, 1, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-FACT(InRangeNeedsValidRange)
-{
-    Assert.Throws<std::invalid_argument>([]() { Assert.InRange(0, 0, 0); });
-    Assert.Throws<std::invalid_argument>([]() { Assert.InRange(0, 1, 0); });
-}
-
-}

File Tests/Assert.NotEqual.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertNotEqual)
-{
-
-FACT(AssertNotEqualDefaultComparerWithSuccess)
-{
-    Assert.NotEqual(0, 1);
-}
-
-FACT(AssertNotEqualDefaultComparerAssertsOnFailure)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.NotEqual(0, 0); });
-}
-
-FACT(AssertNotEqualCustomComparerWithSuccess)
-{
-    Assert.NotEqual(0, 0, [](int, int) { return false; });
-}
-
-FACT(AssertNotEqualCustomComparerAssertsOnFailure)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.NotEqual(0, 1, [](int, int) { return true; }); });
-}
-
-FACT(AssertNotEqualAppendsUserMessage)
-{
-    static const std::string msg = "custom message";
-
-    auto assert = Assert.Throws<xUnitAssert>([]() { Assert.NotEqual(0, 0, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-FACT(AssertSequenceNotEqualDefaultComparerWithSuccess)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-    v0.push_back(2);
-
-    std::vector<long long> v1;
-    v1.push_back(0);
-    v1.push_back(1);
-    v1.push_back(2);
-    v1.push_back(3);
-
-    Assert.NotEqual(v0.begin(), v0.end(), v1.begin(), v1.end());
-}
-
-FACT(AssertSequenceNotEqualDefaultComparerAssertsOnFailure)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-    v0.push_back(2);
-    v0.push_back(3);
-
-    std::vector<long long> v1;
-    v1.push_back(0);
-    v1.push_back(1);
-    v1.push_back(2);
-    v1.push_back(3);
-
-    Assert.Throws<xUnitAssert>([&]() { Assert.NotEqual(v0.begin(), v0.end(), v1.begin(), v1.end()); });
-}
-
-FACT(AssertSequenceNotEqualCustomComparerWithSuccess)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-    v0.push_back(2);
-    v0.push_back(3);
-
-    std::vector<long long> v1;
-    v1.push_back(0);
-    v1.push_back(1);
-    v1.push_back(2);
-    v1.push_back(3);
-
-    Assert.NotEqual(v0.begin(), v0.end(), v1.begin(), v1.end(), [](int, long long) { return false; });
-}
-
-FACT(AssertSequenceNotEqualDefaultAssertsOnFailureDueToMismatch)
-{
-    std::vector<int> v0;
-    v0.push_back(0);
-    v0.push_back(1);
-    v0.push_back(2);
-    v0.push_back(3);
-
-    std::vector<long long> v1;
-    v1.push_back(10);
-    v1.push_back(11);
-    v1.push_back(12);
-    v1.push_back(13);
-
-    Assert.Throws<xUnitAssert>([&]() { Assert.NotEqual(v0.begin(), v0.end(), v1.begin(), v1.end(), [](int, long long) { return true; }); });
-}
-
-}

File Tests/Assert.NotInRange.cpp

-#include <tuple>
-#include <vector>
-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertNotInRange)
-{
-
-std::vector<std::tuple<int, int, int>> NotInRangeSuccessData()
-{
-    std::vector<std::tuple<int, int, int>> data;
-
-    data.push_back(std::make_tuple(-1, 0, 1));
-    data.push_back(std::make_tuple(1, 0, 1));
-    data.push_back(std::make_tuple(2, 0, 1));
-    data.push_back(std::make_tuple(0, -2, -1));
-    data.push_back(std::make_tuple(-1, -2, -1));
-    data.push_back(std::make_tuple(-3, -2, -1));
-
-    return data;
-}
-
-THEORY(NotInRangeSuccess, (int actual, int min, int max), NotInRangeSuccessData)
-{
-    Assert.NotInRange(actual, min, max);
-}
-
-std::vector<std::tuple<int, int, int>> NotInRangeAssertsOnFailureData()
-{
-    std::vector<std::tuple<int, int, int>> data;
-
-    data.push_back(std::make_tuple(0, 0, 1));
-    data.push_back(std::make_tuple(2, 1, 3));
-    data.push_back(std::make_tuple(-1, -1, 0));
-    data.push_back(std::make_tuple(-2, -3, -1));
-
-    return data;
-}
-
-THEORY(NotInRangeAssertsOnFailure, (int actual, int min, int max), NotInRangeAssertsOnFailureData)
-{
-    Assert.Throws<xUnitAssert>([=]() { Assert.NotInRange(actual, min, max); });
-}
-
-FACT(NotInRangeAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-
-    auto assert = Assert.Throws<xUnitAssert>([=]() { Assert.NotInRange(0, 0, 1, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-FACT(NotInRangeNeedsValidRange)
-{
-    Assert.Throws<std::invalid_argument>([]() { Assert.NotInRange(0, 0, 0); });
-    Assert.Throws<std::invalid_argument>([]() { Assert.NotInRange(0, 1, 0); });
-}
-
-}

File Tests/Assert.NotNull.cpp

-#include <memory>
-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertNotNull)
-{
-
-FACT(NotNullForRawPointerSuccess)
-{
-    int x;
-
-    Assert.NotNull(&x);
-}
-
-FACT(NotNullForDoubleConstRawPointerSuccess)
-{
-    int x;
-    const int * const px = &x;
-
-    Assert.NotNull(px);
-}
-
-FACT(NotNullForSmartPointerSuccess)
-{
-    std::unique_ptr<int> x(new int);
-
-    Assert.NotNull(x);
-}
-
-FACT(NotNullForRawPointerAssertsOnFailure)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.NotNull(nullptr); });
-}
-
-FACT(NotNullForSmartPointerAssertsOnFailure)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.NotNull(std::unique_ptr<int>()); });
-}
-
-FACT(NotNullAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-    auto assert = Assert.Throws<xUnitAssert>([]() { Assert.NotNull(nullptr, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Assert.NotSame.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertNotSame)
-{
-
-FACT(NotSameSuccess)
-{
-    int x = 2;
-    int y = 2;
-
-    Assert.NotSame(x, y);
-}
-
-FACT(NotSameForPointersSuccess)
-{
-    int x = 2;
-    int y = 2;
-
-    Assert.NotSame(&x, &y);
-}
-
-FACT(NotSameAssertsOnFailure)
-{
-    int x;
-
-    Assert.Throws<xUnitAssert>([=]() { Assert.NotSame(x, x); });
-}
-
-FACT(NotSameForPointersAssertsOnFailure)
-{
-    int x;
-
-    Assert.Throws<xUnitAssert>([=]() { Assert.NotSame(&x, &x); });
-}
-
-FACT(NotSameAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-
-    int x;
-
-    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.NotSame(x, x, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Assert.Null.cpp

-#include <memory>
-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertNull)
-{
-
-FACT(NullForRawPointerSuccess)
-{
-    Assert.Null(nullptr);
-}
-
-FACT(NullForDoubleConstRawPointerSuccess)
-{
-    const int * const px = nullptr;
-
-    Assert.Null(px);
-}
-
-FACT(NullForSmartPointerSuccess)
-{
-    Assert.Null(std::unique_ptr<int>());
-}
-
-FACT(NullForRawPointerAssertsOnFailure)
-{
-    int x;
-    Assert.Throws<xUnitAssert>([=]() { Assert.Null(&x); });
-}
-
-FACT(NullForSmartPointerAssertsOnFailure)
-{
-    std::unique_ptr<int> x(new int);
-    Assert.Throws<xUnitAssert>([&]() { Assert.Null(x); });
-}
-
-FACT(NullAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-    int x;
-    auto assert = Assert.Throws<xUnitAssert>([=]() { Assert.Null(&x, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Assert.Same.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertSame)
-{
-
-FACT(SameSuccess)
-{
-    int x;
-
-    Assert.Same(x, x);
-}
-
-FACT(SameForPointersSuccess)
-{
-    int x;
-
-    Assert.Same(&x, &x);
-}
-
-FACT(SameForConstPointersSuccess)
-{
-    int x;
-    const int *px = &x;
-
-    Assert.Same(px, px);
-}
-
-FACT(SameAssertsOnFailure)
-{
-    int x = 2;
-    int y = 2;
-
-    Assert.Throws<xUnitAssert>([=]() { Assert.Same(x, y); });
-}
-
-FACT(SameForPointersAssertsOnFailure)
-{
-    int x = 2;
-    int y = 2;
-
-    Assert.Throws<xUnitAssert>([=]() { Assert.Same(&x, &y); });
-}
-
-FACT(SameAppendsUserMessage)
-{
-    static const std::string msg = "xUnit++";
-
-    auto assert = Assert.Throws<xUnitAssert>([]() { Assert.Same(0, 1, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Assert.Throws.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertThrows)
-{
-
-FACT(ThrowsSuccess)
-{
-    struct exp
-    {
-        exp(int x)
-            : x(x)
-        {
-        }
-
-        int x;
-    };
-
-    auto x = Assert.Throws<exp>([]() { throw exp(10); });
-
-    Assert.Equal(10, x.x);
-}
-
-FACT(ThrowsAssertsOnFailure)
-{
-    try
-    {
-        Assert.Throws<int>([=]() { });
-    }
-    catch(const xUnitAssert &)
-    {
-        return;
-    }
-
-    Assert.Fail();
-}
-
-FACT(ThrowAppendsMessages)
-{
-    static const std::string userMessage = "xUnit++";
-
-    try
-    {
-        Assert.Throws<int>([=]() { }, userMessage);
-    }
-    catch(const xUnitAssert &assert)
-    {
-        Assert.Contains(assert.what(), userMessage.c_str());
-        return;
-    }
-
-    Assert.Fail();
-}
-
-}

File Tests/Assert.True.cpp

-#include "xUnit++.h"
-
-using xUnitpp::xUnitAssert;
-using xUnitpp::Assert;
-
-SUITE(AssertTrue)
-{
-
-FACT(TrueSuccess)
-{
-    Assert.True(true);
-}
-
-FACT(TrueAssertsOnFalse)
-{
-    Assert.Throws<xUnitAssert>([]() { Assert.True(false); });
-}
-
-FACT(TrueAppendsCustomMessage)
-{
-    static const std::string msg = "xUnit++";
-
-    auto assert = Assert.Throws<xUnitAssert>([]() { Assert.True(false, msg); });
-
-    Assert.Contains(assert.what(), msg.c_str());
-}
-
-}

File Tests/Attributes.cpp

-#include "IOutput.h"
-#include "TestCollection.h"
-#include "xUnitTestRunner.h"
-#include "xUnit++.h"
-
-using xUnitpp::Assert;
-
-SUITE(Attributes)
-{
-
-ATTRIBUTES(TestWithAttributes, ("Cats", "Meow"))
-FACT(TestWithAttributes)
-{
-    for (const auto &test : xUnitpp::TestCollection::Instance().Tests())
-    {
-        if (test.TestDetails().Name == "TestWithAttributes")
-        {
-            auto it = test.TestDetails().Attributes.find("Cats");
-            Assert.True(it != test.TestDetails().Attributes.end());
-            Assert.True(it->second == "Meow");
-            return;
-        }
-    }
-
-    Assert.Fail("Could not find self in test list.");
-}
-
-FACT(SkippedTestsShouldNotBeInstantiated)
-{
-    // have to set this internal test up manually since the macros don't work embedded within each other
-    struct SkippedTest : xUnitpp::NoFixture
-    {
-        SkippedTest()
-        {
-            Assert.Fail("Should not be instantiated.");
-        }
-    
-        void RunTest()
-        {
-            Assert.Fail("Should not be run.");
-        }
-    };
-
-    struct : xUnitpp::IOutput
-    {
-        virtual void ReportStart(const xUnitpp::TestDetails &) override
-        {
-        }
-
-        virtual void ReportFailure(const xUnitpp::TestDetails &, const std::string &, const xUnitpp::LineInfo &) override
-        {
-        }
-
-        virtual void ReportSkip(const xUnitpp::TestDetails &, const std::string &) override
-        {
-        }
-
-        virtual void ReportFinish(const xUnitpp::TestDetails &, xUnitpp::Time::Duration) override
-        {
-        }
-
-        virtual void ReportAllTestsComplete(size_t, size_t, size_t, xUnitpp::Time::Duration) override 
-        {
-        }
-    } emptyReporter;
-
-    xUnitpp::AttributeCollection attributes;
-    attributes.insert(std::make_pair("Skip", "Testing skip."));
-
-    xUnitpp::TestCollection collection;
-    xUnitpp::TestCollection::Register reg(collection, []() { SkippedTest().RunTest(); }, "SkippedTest", "Attributes", attributes, -1, __FILE__, __LINE__);
-
-    xUnitpp::TestRunner local(emptyReporter);
-    local.RunTests([](const xUnitpp::TestDetails &) { return true; },
-        collection.Tests(), xUnitpp::Time::Duration::zero(), 0);
-}
-
-}

File Tests/BareTests/BareTest.cpp

+#include "xUnit++.h"
+
+//
+// FilteredTestsRunner has a tendency to not get linked into the test dlls.
+// This is the simplest valid test library possible, and is intended to ensure
+// this error does not happen in the future.
+//
+FACT(BareTest)
+{
+}

File Tests/BareTests/BareTests.vcxproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{EDEB02E2-F389-4CBF-AE7D-3041A934F86B}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>BareTests</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\.build\output.props" />
+    <Import Project="..\..\.build\build.props" />
+    <Import Project="..\..\.build\debug.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\.build\output.props" />
+    <Import Project="..\..\.build\build.props" />
+    <Import Project="..\..\.build\debug.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\.build\output.props" />
+    <Import Project="..\..\.build\build.props" />
+    <Import Project="..\..\.build\release.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\.build\output.props" />
+    <Import Project="..\..\.build\build.props" />
+    <Import Project="..\..\.build\release.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(SolutionDir)xUnit++</AdditionalIncludeDirectories>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>"$(OutputPath)../../../xUnit++.console/$(Configuration)/$(PlatformShortName)/xUnit++.console.exe" "$(TargetPath)"</Command>
+    </PostBuildEvent>
+    <PostBuildEvent>
+      <Message>Running Bare Tests...</Message>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(SolutionDir)xUnit++</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="BareTest.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\xUnit++\xUnit++.vcxproj">
+      <Project>{25df3961-f288-4a96-ae6b-a4950a00ab8e}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

File Tests/BareTests/BareTests.vcxproj.filters

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="BareTest.cpp" />
+  </ItemGroup>
+</Project>

File Tests/LineInfo.cpp

-#include "xUnit++.h"
-#include "IOutput.h"
-
-using xUnitpp::Assert;
-
-SUITE(LineInfo)
-{
-
-FACT(LineInfoOverridesDefaultTestLineInfo)
-{
-    auto file = "filename";
-    auto line = 1;
-    auto test = [=]() { Assert.Fail(xUnitpp::LineInfo(file, line)); };
-
-    struct EmptyReporter : xUnitpp::IOutput
-    {
-        EmptyReporter(const std::string &file, int line)
-            : file(file)
-            , line(line)
-        {
-        }
-
-        virtual void ReportStart(const xUnitpp::TestDetails &) override
-        {
-        }
-
-        virtual void ReportFailure(const xUnitpp::TestDetails &, const std::string &, const xUnitpp::LineInfo &lineInfo) override
-        {
-            Assert.Equal(file, lineInfo.file);
-            Assert.Equal(line, lineInfo.line);
-        }
-
-        virtual void ReportSkip(const xUnitpp::TestDetails &, const std::string &) override
-        {
-        }
-
-        virtual void ReportFinish(const xUnitpp::TestDetails &, xUnitpp::Time::Duration) override
-        {
-        }
-
-        virtual void ReportAllTestsComplete(size_t, size_t, size_t, xUnitpp::Time::Duration) override 
-        {
-        }
-
-    private:
-        std::string file;
-        int line;
-    } emptyReporter(file, line);
-
-
-    xUnitpp::AttributeCollection attributes;
-    xUnitpp::TestCollection collection;
-    xUnitpp::TestCollection::Register reg(collection, test, "LineInfoOverridesDefaultTestLineInfo", "LineInfo", attributes, -1, __FILE__, __LINE__);
-
-
-}
-
-}

File Tests/Tests.vcxproj

-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{2276DFCF-ABEA-44FA-9821-2F9F5B891CFF}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>Tests</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="..\.build\output.props" />
-    <Import Project="..\.build\build.props" />
-    <Import Project="..\.build\debug.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="..\.build\output.props" />
-    <Import Project="..\.build\build.props" />
-    <Import Project="..\.build\debug.props" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="..\.build\output.props" />
-    <Import Project="..\.build\build.props" />
-    <Import Project="..\.build\release.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="..\.build\output.props" />
-    <Import Project="..\.build\build.props" />
-    <Import Project="..\.build\release.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../xUnit++</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="Assert.Contains.cpp" />
-    <ClCompile Include="Assert.DoesNotContain.cpp" />
-    <ClCompile Include="Assert.DoesNotThrow.cpp" />
-    <ClCompile Include="Assert.Empty.cpp" />
-    <ClCompile Include="Assert.Equal.cpp" />
-    <ClCompile Include="Assert.Fail.cpp" />
-    <ClCompile Include="Assert.False.cpp" />
-    <ClCompile Include="Assert.InRange.cpp" />
-    <ClCompile Include="Assert.NotEqual.cpp" />
-    <ClCompile Include="Assert.NotInRange.cpp" />
-    <ClCompile Include="Assert.NotNull.cpp" />
-    <ClCompile Include="Assert.NotSame.cpp" />
-    <ClCompile Include="Assert.Null.cpp" />
-    <ClCompile Include="Assert.Same.cpp" />
-    <ClCompile Include="Assert.Throws.cpp" />
-    <ClCompile Include="Assert.True.cpp" />
-    <ClCompile Include="Attributes.cpp" />
-    <ClCompile Include="LineInfo.cpp" />
-    <ClCompile Include="Theory.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\xUnit++\xUnit++.vcxproj">
-      <Project>{25df3961-f288-4a96-ae6b-a4950a00ab8e}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

File Tests/Tests.vcxproj.filters

-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <ClCompile Include="Assert.Contains.cpp" />
-    <ClCompile Include="Assert.DoesNotContain.cpp" />
-    <ClCompile Include="Assert.DoesNotThrow.cpp" />
-    <ClCompile Include="Assert.Empty.cpp" />
-    <ClCompile Include="Assert.Equal.cpp" />
-    <ClCompile Include="Assert.Fail.cpp" />
-    <ClCompile Include="Assert.False.cpp" />
-    <ClCompile Include="Assert.InRange.cpp" />
-    <ClCompile Include="Assert.NotEqual.cpp" />
-    <ClCompile Include="Assert.NotInRange.cpp" />
-    <ClCompile Include="Assert.NotNull.cpp" />
-    <ClCompile Include="Assert.NotSame.cpp" />
-    <ClCompile Include="Assert.Null.cpp" />
-    <ClCompile Include="Assert.Same.cpp" />
-    <ClCompile Include="Assert.Throws.cpp" />
-    <ClCompile Include="Assert.True.cpp" />
-    <ClCompile Include="Attributes.cpp" />
-    <ClCompile Include="Theory.cpp" />
-    <ClCompile Include="LineInfo.cpp" />
-  </ItemGroup>
-</Project>

File Tests/Theory.cpp

-#include <algorithm>
-#include <string>
-#include <tuple>
-#include <vector>
-#include "IOutput.h"
-#include "xUnitTestRunner.h"
-#include "xUnitTime.h"
-#include "xUnit++.h"
-
-using xUnitpp::Assert;
-
-SUITE(Theory)
-{
-
-void TheoryUnderTest(int x)
-{
-    Assert.True(x == 0 || x == 1);
-}
-
-struct TheoryFixture
-{
-private:
-    struct : xUnitpp::IOutput
-    {
-        virtual void ReportStart(const xUnitpp::TestDetails &) override
-        {
-        }
-
-        virtual void ReportFailure(const xUnitpp::TestDetails &, const std::string &, const xUnitpp::LineInfo &) override
-        {
-        }
-
-        virtual void ReportSkip(const xUnitpp::TestDetails &, const std::string &) override
-        {
-        }
-
-        virtual void ReportFinish(const xUnitpp::TestDetails &, xUnitpp::Time::Duration) override
-        {
-        }
-
-        virtual void ReportAllTestsComplete(size_t, size_t, size_t, xUnitpp::Time::Duration) override 
-        {
-        }
-    } emptyReporter;
-
-public:
-    TheoryFixture()
-        : localRunner(emptyReporter)
-    {
-    }
-
-    template<typename TTheoryData>
-    void Register(const std::string &name, TTheoryData &&theoryData)
-    {
-        xUnitpp::TestCollection::Register reg(collection, &TheoryUnderTest, theoryData, name, "Theory", attributes, -1, __FILE__, __LINE__);
-    }
-
-    void Run()
-    {
-        localRunner.RunTests([](const xUnitpp::TestDetails &) { return true; },
-            collection.Tests(), xUnitpp::Time::Duration::zero(), 0);
-    }
-
-    template<typename TTheoryData>
-    void RegisterAndRun(const std::string &name, TTheoryData &&theoryData)
-    {
-        Register(name, theoryData);
-
-        Run();
-    }
-
-    xUnitpp::AttributeCollection attributes;
-    xUnitpp::TestCollection collection;
-    xUnitpp::TestRunner localRunner;
-};
-
-std::vector<std::tuple<int>> RawFunctionProvider()
-{
-    std::tuple<int> tuples[] =
-    {
-        std::make_tuple(0),
-        std::make_tuple(1),
-        std::make_tuple(2),
-        std::make_tuple(3),
-        std::make_tuple(0)
-    };
-
-    return std::vector<std::tuple<int>>(std::begin(tuples), std::end(tuples));
-}
-
-FACT_FIXTURE(TheoriesAcceptRawFunctions, TheoryFixture)
-{
-    RegisterAndRun("TheoriesAcceptRawFunctions", RawFunctionProvider);
-}
-
-FACT_FIXTURE(TheoriesAcceptStdFunction, TheoryFixture)
-{
-    std::function<std::vector<std::tuple<int>>()> provider = RawFunctionProvider;
-
-    RegisterAndRun("TheoriesAcceptStdFunction", provider);
-}
-
-FACT_FIXTURE(TheoriesAcceptFunctors, TheoryFixture)
-{
-    struct
-    {
-        std::vector<std::tuple<int>> operator()() const
-        {
-            return RawFunctionProvider();
-        }
-    } functor;
-
-    RegisterAndRun("TheoriesAcceptFunctors", functor);
-}
-
-FACT_FIXTURE(TheoriesGetAllDataPassedToThem, TheoryFixture)
-{
-    std::vector<int> dataProvided;
-
-    // !!! this line appears to fix a somewhat random buffer overrun bug
-    // I am not sure why. Investigate later.
-    dataProvided.reserve(5);
-
-    auto doTheory = [&](int x) { dataProvided.push_back(x); };
-    xUnitpp::TestCollection::Register reg(collection, doTheory, RawFunctionProvider, "TheoriesGetAllDataPassedToThem", "Theory", attributes, -1, __FILE__, __LINE__);
-
-    Run();
-
-    Assert.Equal(2, std::count(dataProvided.begin(), dataProvided.end(), 0));
-    Assert.Equal(1, std::count(dataProvided.begin(), dataProvided.end(), 1));
-    Assert.Equal(1, std::count(dataProvided.begin(), dataProvided.end(), 2));
-    Assert.Equal(1, std::count(dataProvided.begin(), dataProvided.end(), 3));
-}
-
-FACT_FIXTURE(TheoriesCanBeSkipped, TheoryFixture)
-{
-    attributes.insert(std::make_pair("Skip", "Testing skip."));
-
-    auto doTheory = [](int) { Assert.Fail("Should not be run."); };
-
-    xUnitpp::TestCollection::Register reg(collection, doTheory, RawFunctionProvider, "TheoriesGetAllDataPassedToThem", "Theory", attributes, -1, __FILE__, __LINE__);
-
-    Run();
-}
-
-ATTRIBUTES(TheoriesCanHaveAttributes, ("Cats", "Meow"))
-THEORY(TheoriesCanHaveAttributes, (int), RawFunctionProvider)
-{
-    for (const auto &test : xUnitpp::TestCollection::Instance().Tests())
-    {
-        if (test.TestDetails().ShortName == "TheoriesCanHaveAttributes")
-        {
-            auto it = test.TestDetails().Attributes.find("Cats");
-            Assert.True(it != test.TestDetails().Attributes.end());
-            Assert.True(it->second == "Meow");
-            return;
-        }
-    }
-
-    Assert.Fail("Could not find self in test list.");
-}
-
-std::vector<std::tuple<std::string, std::vector<std::tuple<int, std::string>>>> ComplexProvider()
-{
-    std::vector<std::tuple<std::string, std::vector<std::tuple<int, std::string>>>> result;
-
-    std::vector<std::tuple<int, std::string>> internal_vector;
-    internal_vector.push_back(std::make_tuple(0, std::string("xyz")));
-
-    result.push_back(std::make_tuple(std::string("abcd"), internal_vector));
-
-    return result;
-}
-
-THEORY(TheoriesCanAcceptComplexObjects, (const std::string &, const std::vector<std::tuple<int, std::string>> &), ComplexProvider)
-{
-    // just existing is good enough
-}
-
-THEORY(TheoriesCanAcceptLambdas, (int, int),
-    ([]() -> std::vector<std::tuple<int, int>>
-    {
-        std::vector<std::tuple<int, int>> data;
-        data.push_back(std::make_tuple(0, 0));
-        return data;
-    })
-)
-{
-    // just existing is good enough
-}
-
-}

File Tests/UnitTests/Assert.Contains.cpp

+#include <string>
+#include <vector>
+#include "xUnit++.h"
+
+using xUnitpp::xUnitAssert;
+using xUnitpp::Assert;
+
+SUITE(AssertContains)
+{
+
+FACT(ContainsForSequenceSuccess)
+{
+    std::vector<int> v(1, 0);
+
+    Assert.Contains(v, 0);
+}
+
+FACT(ContainsForSequenceAssertsOnFailure)
+{
+    std::vector<int> v;
+
+    Assert.Throws<xUnitAssert>([&]() { Assert.Contains(v, 0); });
+}
+
+FACT(ContainsForSequenceAppendsUserMessage)
+{
+    static const std::string msg = "xUnit++";
+    std::vector<int> v;
+
+    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Contains(v, 0, msg); });
+    auto what = std::string(assert.what());
+
+    Assert.NotEqual(std::string::npos, what.find(msg));
+}
+
+FACT(ContainsForStringSuccess)
+{
+    std::string actual = "abcd";
+
+    Assert.Contains(actual, "a");
+}
+
+FACT(ContainsForStringAssertsOnFailure)
+{
+    std::string actual = "abcd";
+
+    Assert.Throws<xUnitAssert>([&]() { Assert.Contains(actual, "xyz"); });
+}
+
+FACT(ContainsForStringAppendsUserMessage)
+{
+    static const std::string msg = "xUnit++";
+    std::string actual = "abcd";
+
+    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.Contains(actual, "xyz", msg); });
+    auto what = std::string(assert.what());
+
+    Assert.NotEqual(std::string::npos, what.find(msg));
+}
+
+}

File Tests/UnitTests/Assert.DoesNotContain.cpp

+#include <string>
+#include <vector>
+#include "xUnit++.h"
+
+using xUnitpp::xUnitAssert;
+using xUnitpp::Assert;
+
+SUITE(AssertDoesNotContain)
+{
+
+FACT(DoesNotContainForSequenceSuccess)
+{
+    std::vector<int> v;
+
+    Assert.DoesNotContain(v, 0);
+}
+
+FACT(DoesNotContainForSequenceAssertsOnFailure)
+{
+    std::vector<int> v(1, 0);
+
+    Assert.Throws<xUnitAssert>([&]() { Assert.DoesNotContain(v, 0); });
+}
+
+FACT(DoesNotContainForSequenceAppendsUserMessage)
+{
+    static const std::string msg = "xUnit++";
+    std::vector<int> v(1, 0);
+
+    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.DoesNotContain(v, 0, msg); });
+
+    Assert.Contains(assert.what(), msg.c_str());
+}
+
+FACT(DoesNotContainForStringSuccess)
+{
+    std::string actual = "abcd";
+
+    Assert.DoesNotContain(actual, "xyz");
+}
+
+FACT(DoesNotContainForStringAssertsOnFailure)
+{
+    std::string actual = "abcd";
+
+    Assert.Throws<xUnitAssert>([&]() { Assert.DoesNotContain(actual, "bc"); });
+}
+
+FACT(DoesNotContainForStringAppendsUserMessage)
+{
+    static const std::string msg = "xUnit++";
+    std::string actual = "abcd";
+
+    auto assert = Assert.Throws<xUnitAssert>([&]() { Assert.DoesNotContain(actual, "ab", msg); });
+
+    Assert.Contains(assert.what(), msg.c_str());
+}
+
+}

File Tests/UnitTests/Assert.DoesNotThrow.cpp

+#include "xUnit++.h"
+
+using xUnitpp::xUnitAssert;
+using xUnitpp::Assert;
+
+SUITE(AssertDoesNotThrow)
+{
+
+FACT(DoesNotThrowSuccess)
+{
+    try
+    {
+        Assert.DoesNotThrow([]() { });
+    }
+    catch(...)
+    {
+        Assert.Fail();
+    }
+}
+
+FACT(DoesNotThrowAssertsOnFailure)
+{
+    static const std::string msg = "xUnit++";
+
+    try
+    {
+        Assert.DoesNotThrow([=]() { throw std::exception(msg.c_str()); });
+    }
+    catch(const xUnitAssert &)
+    {
+        return;
+    }
+
+    Assert.Fail();
+}
+
+FACT(DoesNotThrowAppendsMessages)
+{
+    static const std::string exceptionMessage = "xUnit++";
+    static const std::string userMessage = "custom";
+
+    try
+    {
+        Assert.DoesNotThrow([=]() { throw std::exception(exceptionMessage.c_str()); }, userMessage);
+    }
+    catch(const xUnitAssert &assert)
+    {
+        Assert.Contains(assert.what(), exceptionMessage.c_str());
+        Assert.Contains(assert.what(), userMessage.c_str());
+        return;
+    }
+
+    Assert.Fail();
+}
+
+}

File Tests/UnitTests/Assert.Empty.cpp

+#include <vector>
+#include "xUnit++.h"
+
+using xUnitpp::xUnitAssert;
+using xUnitpp::Assert;
+
+namespace
+{
+    struct
+    {
+        bool empty() const
+        {
+            return true;
+        }
+    } hasConstEmpty;
+
+    namespace Local
+    {
+        struct Container
+        {
+        };
+
+        int begin(const Container &)
+        {
+            return 0;
+        }
+
+        int end(const Container &)
+        {
+            return 0;
+        }
+    }
+}
+
+SUITE(AssertEmpty)
+{
+
+FACT(EmptyCallsEmptyForContainerWithConstEmptyMember)
+{
+    Assert.Empty(hasConstEmpty);
+}
+
+FACT(EmptyFindsLocalBeginEnd)
+{
+    Assert.Empty(Local::Container());
+}
+
+FACT(EmptyFindsStdBeginEnd)
+{
+    int array[10];
+    Assert.Throws<xUnitAssert>([&]() { Assert.Empty(array); });
+}
+
+FACT(EmptyFindsMemberBeginEnd)
+{
+    struct
+    {
+        int begin() const
+        {
+            return 0;
+        }
+
+        int end() const
+        {
+            return 0;
+        }
+    } hasMembers;
+
+    Assert.Empty(hasMembers);
+}
+