diff options
Diffstat (limited to 'vendor/bandit/bandit/assertion_frameworks/snowhouse/example')
14 files changed, 1336 insertions, 0 deletions
diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/basic_assertions.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/basic_assertions.cpp new file mode 100644 index 00000000..2766ec0a --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/basic_assertions.cpp @@ -0,0 +1,228 @@ +#include <stdexcept> +#include <sstream> +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +void throwRuntimeError() { + throw std::runtime_error("This is expected"); +} + +struct IgnoreErrors { + template <class ExpectedType, class ActualType> + static void Handle(const ExpectedType&, const ActualType&, const char*, int) + { + } + + static void Handle(const std::string&) + { + } +}; + +void BasicAssertions() +{ + std::cout << "================================================" << std::endl; + std::cout << " ASSERTIONS " << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "ShouldHandleIntegerEquality" << std::endl; + { + Assert::That(5, Is().EqualTo(5)); + } + + std::cout << "ShouldDetectIntegerInequality" << std::endl; + { + AssertTestFails(Assert::That(5, Is().EqualTo(4)), "equal to 4"); + } + + std::cout << "ShouldDetectIfNotFails" << std::endl; + { + AssertTestFails(Assert::That(5, Is().Not().EqualTo(5)), "Expected: not equal to 5\nActual: 5\n"); + } + + std::cout << "ShouldHandleStrings" << std::endl; + { + Assert::That(std::string("joakim"), Is().EqualTo(std::string("joakim"))); + } + + std::cout << "ShouldHandleStringsWithoutExplicitTemplateSpecialization" << std::endl; + { + Assert::That("kim", Is().EqualTo("kim")); + } + + std::cout << "ShouldHandleGreaterThan" << std::endl; + { + Assert::That(5, Is().GreaterThan(4)); + } + + std::cout << "ShouldDetectWhenGreaterThanFails" << std::endl; + { + AssertTestFails(Assert::That(5, Is().GreaterThan(5)), + "Expected: greater than 5\nActual: 5\n"); + } + + std::cout << "ShouldHandleLessThan" << std::endl; + { + Assert::That(5, Is().LessThan(6)); + } + + std::cout << "ShouldDetectWhenLessThanFails" << std::endl; + { + AssertTestFails(Assert::That(6, Is().LessThan(5)), + "Expected: less than 5\nActual: 6\n"); + } + + std::cout << "ShouldThrowExplicitFailureMessage" << std::endl; + { + AssertTestFails(Assert::Failure("foo"), "foo"); + } + + std::cout << "Should contain location information" << std::endl; + { + int line; + std::string file; + + try + { + Assert::That(5, Equals(2), "filename", 32); + } + catch(const AssertionException& e) + { + line = e.GetLineNumber(); + file = e.GetFilename(); + } + + Assert::That(line, Equals(32)); + Assert::That(file, Equals("filename")); + } + + std::cout << "ShouldEnsureExceptionIsThrown" << std::endl; + { + + AssertThrows(std::runtime_error, throwRuntimeError()); + } + + std::cout << "ShouldIgnoreTheError" << std::endl; + { + ConfigurableAssert<IgnoreErrors>::That(1, Equals(2)); + } + + std::cout << "================================================" << std::endl; + std::cout << " ASSERTIONS EXPRESSION TEMPLATES" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "ShouldHandleIntegerEquality" << std::endl; + { + Assert::That(5, Equals(5)); + } + + std::cout << "ShouldDetectIntegerInequality" << std::endl; + { + AssertTestFails(Assert::That(5, Equals(4)), "equal to 4"); + } + + std::cout << "ShouldDetectIfNotFails" << std::endl; + { + AssertTestFails(Assert::That(5, !Equals(5)), + "Expected: not equal to 5\nActual: 5\n"); + } + + std::cout << "ShouldHandleStrings" << std::endl; + { + Assert::That(std::string("joakim"), Equals(std::string("joakim"))); + } + + std::cout << "ShouldHandleStringsWithoutExplicitTemplateSpecialization" + << std::endl; + { + Assert::That("kim", Equals("kim")); + } + + std::cout << "ShouldHandleGreaterThan" << std::endl; + { + Assert::That(5, IsGreaterThan(4)); + } + + std::cout << "ShouldHandleGreaterThanOrEqualTo" << std::endl; + { + Assert::That(4, IsGreaterThanOrEqualTo(4)); + Assert::That(5, IsGreaterThanOrEqualTo(4)); + } + + std::cout << "ShouldDetectWhenGreaterThanFails" << std::endl; + { + AssertTestFails(Assert::That(5, IsGreaterThan(5)), + "Expected: greater than 5\nActual: 5\n"); + } + + std::cout << "ShouldDetectWhenGreaterThanOrEqualToFails" << std::endl; + { + AssertTestFails(Assert::That(4, IsGreaterThanOrEqualTo(5)), + "Expected: greater than or equal to 5\nActual: 4\n"); + } + + std::cout << "ShouldHandleLessThan" << std::endl; + { + Assert::That(5, IsLessThan(6)); + } + + std::cout << "ShouldHandleLessThanOrEqualTo" << std::endl; + { + Assert::That(5, IsLessThanOrEqualTo(6)); + Assert::That(6, IsLessThanOrEqualTo(6)); + } + + std::cout << "ShouldDetectWhenLessThanFails" << std::endl; + { + AssertTestFails(Assert::That(6, IsLessThan(5)), + "Expected: less than 5\nActual: 6\n"); + } + + std::cout << "ShouldDetectWhenLessThanOrEqualToFails" << std::endl; + { + AssertTestFails(Assert::That(6, IsLessThanOrEqualTo(5)), + "Expected: less than or equal to 5\nActual: 6\n"); + } + +#if __cplusplus > 199711L + std::cout << "ShouldHandleNull" << std::endl; + { + Assert::That(nullptr, IsNull()); + } + + std::cout << "ShouldHandleNull" << std::endl; + { + Assert::That(nullptr, Is().Null()); + } + + std::cout << "ShouldHandleNotNull" << std::endl; + { + int anInt = 0; + Assert::That(&anInt, ! IsNull()); + } + + std::cout << "ShouldDetectWhenIsNullFails" << std::endl; + { + int anInt = 0; + std::ostringstream message; + message << "Expected: equal to nullptr\nActual: " << &anInt << "\n"; + AssertTestFails(Assert::That(&anInt, IsNull()), message.str()); + } + + std::cout << "ShouldDetectWhenIsNullFails" << std::endl; + { + int anInt = 0; + std::ostringstream message; + message << "Expected: equal to nullptr\nActual: " << &anInt << "\n"; + AssertTestFails(Assert::That(&anInt, Is().Null()), message.str()); + } + + std::cout << "ShouldDetectWhenIsNotNullFails" << std::endl; + { + std::ostringstream message; + message << "Expected: not equal to nullptr\nActual: nullptr\n"; + + AssertTestFails(Assert::That(nullptr, ! IsNull()), message.str()); + } +#endif +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/boolean_operators.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/boolean_operators.cpp new file mode 100644 index 00000000..3e4577a5 --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/boolean_operators.cpp @@ -0,0 +1,48 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +void BooleanOperators() +{ + std::cout << "================================================" << std::endl; + std::cout << " Boolean operators" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "ShouldHandleIsFalseOperator" << std::endl; + { + Assert::That(false, IsFalse()); + } + + std::cout << "ShouldHandleWhenIsFalseFails" << std::endl; + { + AssertTestFails(Assert::That(true, IsFalse()), "Expected: false"); + } + + std::cout << "ShouldHandleIsTrueOperator" << std::endl; + { + Assert::That(true, IsTrue()); + } + + std::cout << "ShouldHandleWhenIsTrueFails" << std::endl; + { + AssertTestFails(Assert::That(false, IsTrue()), "Expected: true"); + } + + std::cout << "ShouldHandleFluentIsTrue" << std::endl; + { + Assert::That(true, Is().True()); + AssertTestFails(Assert::That(false, Is().True()), "Expected: true"); + } + + std::cout << "ShouldHandleFluentIsFalse" << std::endl; + { + Assert::That(false, Is().False()); + AssertTestFails(Assert::That(true, Is().False()), "Expected: false"); + } + + std::cout << "ShouldTreatAssertWithoutConstraintAsBooleanConstrains" << std::endl; + { + Assert::That(true); + } +} + diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/container_spec.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/container_spec.cpp new file mode 100644 index 00000000..c668dffa --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/container_spec.cpp @@ -0,0 +1,85 @@ + +// Copyright Joakim Karlsson & Kim Gräsman 2010-2013. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +struct my_type +{ + my_type(int my_val) + : my_val_(my_val) + {} + + friend bool operator==(const my_type&, const my_type&); + friend bool operator!=(const my_type&, const my_type&); + friend std::ostream& operator<<(std::ostream&, const my_type&); + + int my_val_; +}; + +bool operator==(const my_type& lhs, const my_type& rhs) +{ + return lhs.my_val_ == rhs.my_val_; +} + +bool operator!=(const my_type& lhs, const my_type& rhs) +{ + return !(lhs == rhs); +} + +std::ostream& operator<<(std::ostream& stream, const my_type& item) +{ + stream << "(my_type: my_val_=" << item.my_val_ << " )"; + return stream; +} + +static bool are_my_types_equal(const my_type& lhs, const my_type& rhs) +{ + return lhs.my_val_ == rhs.my_val_; +} + +void ContainerConstraints() +{ + std::cout << "================================================" << std::endl; + std::cout << " ContainerContstraints" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "it_should_be_able_to_compare_containers_of_custom_types" << std::endl; + { + const my_type e[] = {my_type(1), my_type(3)}; + const std::list<my_type> expected(e, e + sizeof(e) / sizeof(e[0])); + std::list<my_type> my_container_; + my_container_.push_back(my_type(1)); + my_container_.push_back(my_type(3)); + + AssertThat(my_container_, EqualsContainer(expected)); + } + + std::cout << "it_should_handle_failing_comparisons" << std::endl; + { + const my_type e[] = {my_type(1), my_type(2)}; + const std::list<my_type> expected(e, e + sizeof(e) / sizeof(e[0])); + std::list<my_type> my_container_; + my_container_.push_back(my_type(1)); + my_container_.push_back(my_type(3)); + + AssertTestFails(Assert::That(my_container_, EqualsContainer(expected)), + "Expected: [ (my_type: my_val_=1 ), (my_type: my_val_=2 ) ]"); + } + + std::cout << "it_should_handle_comparison_with_a_predicate_function" << std::endl; + { + const my_type e[] = {my_type(1), my_type(3)}; + const std::list<my_type> expected(e, e + sizeof(e) / sizeof(e[0])); + std::list<my_type> my_container_; + my_container_.push_back(my_type(1)); + my_container_.push_back(my_type(3)); + + Assert::That(my_container_, EqualsContainer(expected, are_my_types_equal)); + Assert::That(my_container_, Is().EqualToContainer(expected, are_my_types_equal)); + } +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/custom_matchers_test.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/custom_matchers_test.cpp new file mode 100644 index 00000000..c5437f9f --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/custom_matchers_test.cpp @@ -0,0 +1,69 @@ + +// Copyright Joakim Karlsson & Kim Gräsman 2010-2013. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +struct IsEvenNumberNoStreamOperator +{ + bool Matches(const int actual) const + { + return (actual % 2) == 0; + } +}; + +struct IsEvenNumberWithStreamOperator +{ + bool Matches(const int actual) const + { + return (actual % 2) == 0; + } + + friend std::ostream& operator<<(std::ostream& stm, + const IsEvenNumberWithStreamOperator& ); +}; + +std::ostream& operator<<(std::ostream& stm, + const IsEvenNumberWithStreamOperator& ) +{ + stm << "An even number"; + return stm; +} + +void CustomMatchers() +{ + std::cout << "================================================" << std::endl; + std::cout << " CustomMatchersNoStreamOperator" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "CanHandleCustomMatcher" << std::endl; + { + Assert::That(2, Fulfills(IsEvenNumberNoStreamOperator())); + } + + std::cout << "CustomMatcherWithFluent" << std::endl; + { + Assert::That(2, Is().Fulfilling(IsEvenNumberNoStreamOperator())); + } + + std::cout << "OutputsCorrectMessageWhenFails" << std::endl; + { + AssertTestFails(Assert::That(3, Fulfills(IsEvenNumberNoStreamOperator())), + "Expected: [unsupported type]\nActual: 3"); + } + + + std::cout << "================================================" << std::endl; + std::cout << "CustomMatcherWithStreamOperator" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "ErrorMessageUsesCustomStreamOperatorIfAvailable" << std::endl; + { + AssertTestFails(Assert::That(3, Fulfills(IsEvenNumberWithStreamOperator())), + "Expected: An even number\nActual: 3"); + } +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/exceptions_tests.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/exceptions_tests.cpp new file mode 100644 index 00000000..0f1ac2ab --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/exceptions_tests.cpp @@ -0,0 +1,97 @@ + +// Copyright Joakim Karlsson & Kim Gräsman 2010-2013. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <snowhouse/snowhouse.h> +#include <stdexcept> +using namespace snowhouse; + +#include "tests.h" + +class ClassWithExceptions +{ +public: + int LogicError() + { + throw std::logic_error("not logical!"); + } + + double RangeError() + { + throw std::range_error("range error!"); + } + + void NoError() + { + } +}; + +void ExceptionTests() +{ + ClassWithExceptions objectUnderTest; + + std::cout << "================================================" << std::endl; + std::cout << " ExceptionTests" << std::endl; + std::cout << "================================================" << std::endl; + + + std::cout << "CanDetectExceptions" << std::endl; + { + AssertThrows(std::exception, objectUnderTest.LogicError()); + } + + std::cout << "CanAssertOnLastException" << std::endl; + { + AssertThrows(std::logic_error, objectUnderTest.LogicError()); + Assert::That(LastException<std::logic_error>().what(), Contains("not logical!")); + } + + std::cout << "CanDetectWhenWrongExceptionIsThrown" << std::endl; + { + AssertTestFails(AssertThrows(std::logic_error, objectUnderTest.RangeError()), "Wrong exception"); + } + + std::cout << "CanPrintExpectedExceptionTypeWhenWrongExceptionIsThrown" << std::endl; + { + AssertTestFails(AssertThrows(std::logic_error, objectUnderTest.RangeError()), "Expected std::logic_error"); + } + + std::cout << "CanHaveSeveralExceptionAssertionsInSameSpec" << std::endl; + { + AssertThrows(std::logic_error, objectUnderTest.LogicError()); + Assert::That(LastException<std::logic_error>().what(), Contains("not logical!")); + + AssertThrows(std::range_error, objectUnderTest.RangeError()); + Assert::That(LastException<std::range_error>().what(), Contains("range error!")); + } + + std::cout << "CanHaveSeveralExceptionAssertionForTheSameExceptionInSameSpec" << std::endl; + { + AssertThrows(std::logic_error, objectUnderTest.LogicError()); + Assert::That(LastException<std::logic_error>().what(), Contains("not logical!")); + + AssertThrows(std::logic_error, objectUnderTest.LogicError()); + Assert::That(LastException<std::logic_error>().what(), Contains("not logical!")); + } + + std::cout << "CanDetectWhenNoExceptionIsThrown" << std::endl; + { + AssertTestFails(AssertThrows(std::logic_error, objectUnderTest.NoError()), "No exception"); + } + + std::cout << "CanPrintExpectedExceptionWhenNoExceptionIsThrown" << std::endl; + { + AssertTestFails(AssertThrows(std::logic_error, objectUnderTest.NoError()), "Expected std::logic_error"); + } + + std::cout << "ExceptionsAreDestoryedWhenWeExitScope" << std::endl; + { + { + AssertThrows(std::logic_error, objectUnderTest.LogicError()); + } + AssertThrows(AssertionException, LastException<std::logic_error>()); + Assert::That(LastException<AssertionException>().GetMessage(), Contains("No exception was stored")); + } +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/expression_error_handling.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/expression_error_handling.cpp new file mode 100644 index 00000000..de96f038 --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/expression_error_handling.cpp @@ -0,0 +1,28 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +void ExpressionErrorHandling() +{ + std::cout << "================================================" << std::endl; + std::cout << " ExpressionErrorHandling" << std::endl; + std::cout << "================================================" << std::endl; + + std::vector<int> collection; + collection.push_back(1); + collection.push_back(2); + collection.push_back(3); + + std::cout << "AnInvalidAllOperationShouldBeReportedProperly" << std::endl; + { + AssertTestFails(Assert::That(collection, Has().All()), + "The expression after \"all\" operator does not yield any result"); + } + + std::cout << "AnInvalidAtLeastOperationShouldBeReportedProperly" << std::endl; + { + AssertTestFails(Assert::That(collection, Has().AtLeast(2)), + "The expression after \"at least 2\" operator does not yield any result"); + } + +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/main.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/main.cpp new file mode 100644 index 00000000..616b97ff --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/main.cpp @@ -0,0 +1,43 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +void BooleanOperators(); +void BasicAssertions(); +void ContainerConstraints(); +void CustomMatchers(); +void ExceptionTests(); +void ExpressionErrorHandling(); +void MapTests(); +void OperatorTests(); +void SequenceContainerTests(); +void StringLineTests(); +void StringTests(); +void StringizeTests(); + +int main() +{ + try + { + BasicAssertions(); + BooleanOperators(); + ContainerConstraints(); + CustomMatchers(); + ExceptionTests(); + ExpressionErrorHandling(); + MapTests(); + OperatorTests(); + SequenceContainerTests(); + StringLineTests(); + StringTests(); + StringizeTests(); + } + catch(const AssertionException& e) + { + std::cout << "Tests failed!" << std::endl; + std::cout << e.GetMessage() << std::endl; + return 1; + } + + return 0; +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/map_tests.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/map_tests.cpp new file mode 100644 index 00000000..813b5011 --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/map_tests.cpp @@ -0,0 +1,38 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +void MapTests() +{ + std::cout << "================================================" << std::endl; + std::cout << " MapTests" << std::endl; + std::cout << "================================================" << std::endl; + + std::map<std::string, int> ages; + ages["joakim"] = 38; + ages["maria"] = 36; + ages["hanna"] = 6; + ages["moa"] = 4; + + std::cout << "ContainingShouldDetermineIfKeyExists" << std::endl; + { + Assert::That(ages, Is().Containing("joakim")); + } + + std::cout << "ShouldGiveAProperMessageWhenContainingFails" << std::endl; + { + AssertTestFails(Assert::That(ages, Is().Not().Containing("hanna")), + "Expected: not contains hanna"); + } + + std::cout << "ContainingShouldDetermineIfKeyExists" << std::endl; + { + Assert::That(ages, Contains("joakim")); + } + + std::cout << "ShouldGiveAProperMessageWhenContainingFails" << std::endl; + { + AssertTestFails(Assert::That(ages, !Contains("hanna")), + "Expected: not contains hanna"); + } +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/operator_tests.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/operator_tests.cpp new file mode 100644 index 00000000..3d11ae07 --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/operator_tests.cpp @@ -0,0 +1,137 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +void OperatorTests() +{ + std::cout << "================================================" << std::endl; + std::cout << " OperatorTests" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "ShouldHandleAndOperatorExpressionTemplates" << std::endl; + { + Assert::That(5, IsLessThan(6) && IsGreaterThan(4)); + } + + std::cout << "ShouldHandleAndOperator" << std::endl; + { + Assert::That(5, Is().LessThan(6).And().GreaterThan(4)); + } + + std::cout << "ShouldHandleAndOperatorFailExpressionTemplates" << std::endl; + { + AssertTestFails(Assert::That(5, IsLessThan(7) && IsGreaterThan(5)), + "less than 7 and greater than 5"); + } + + std::cout << "ShouldHandleAndOperatorFail" << std::endl; + { + AssertTestFails(Assert::That(5, Is().LessThan(7).And().GreaterThan(5)), + "less than 7 and greater than 5"); + } + + std::cout << "ShouldHandleOrOperator" << std::endl; + { + Assert::That(12, Is().LessThan(7).Or().GreaterThan(5)); + } + + std::cout << "ShouldHandleOrOperatorExpressionTemplates" << std::endl; + { + Assert::That(12, IsLessThan(7) || IsGreaterThan(5)); + } + + std::cout << "ShouldHandleOrOperatorFails" << std::endl; + { + AssertTestFails(Assert::That(67, Is().LessThan(12).Or().GreaterThan(99)), + "less than 12 or greater than 99"); + } + + std::cout << "ShouldHandleOrOperatorFailsExpressionTemplates" << std::endl; + { + AssertTestFails(Assert::That(67, IsLessThan(12) || IsGreaterThan(99)), + "less than 12 or greater than 99"); + } + + std::cout << "ShouldHandleNotOperators" << std::endl; + { + Assert::That(5, Is().Not().EqualTo(4)); + } + + std::cout << "ShouldHandleNotOperatorsExpressionTemplates" << std::endl; + { + Assert::That(5, !Equals(4)); + } + + std::cout << "ShouldHandleNotOperatorsFails" << std::endl; + { + AssertTestFails(Assert::That(12, Is().Not().EqualTo(12)), "not equal to 12"); + } + + std::cout << "ShouldHandleNotOperatorsFailsExpressionTemplates" << std::endl; + { + AssertTestFails(Assert::That(12, !Equals(12)), "not equal to 12"); + } + + std::cout << "ShouldHandleNotOperatorsForStrings" << std::endl; + { + Assert::That("joakim", Is().Not().EqualTo("harry")); + } + + std::cout << "ShouldHandleNotOperatorsForStringsExpressionTemplates" << std::endl; + { + Assert::That("joakim", !Equals("harry")); + } + + std::cout << "ShouldHandleBothLeftAndRightAssociativeOperators" << std::endl; + { + Assert::That(5, Is().GreaterThan(4).And().Not().LessThan(3)); + } + + std::cout << "ShouldHandleBothLeftAndRightAssociativeOperatorsExpressionTemplates" << std::endl; + { + Assert::That(5, IsGreaterThan(4)&& !IsLessThan(3)); + } + + std::cout << "MalformedExpressionYieldsError" << std::endl; + { + AssertTestFails(Assert::That(4, Is().Not()), + "The expression contains a not operator without any operand"); + } + + std::cout << + "EqualsWithDeltaOperator_should_fail_for_actual_larger_than_delta" + << std::endl; + { + AssertTestFails(Assert::That(3.9, EqualsWithDelta(3, 0.5)), + "Expected: equal to 3 (+/- 0.5)"); + } + + std::cout << "EqualsWithDeltaOperator_should_fail_for_actual_less_than_delta" << std::endl; + { + AssertTestFails(Assert::That(2.49, EqualsWithDelta(3, 0.5)), + "Expected: equal to 3 (+/- 0.5)"); + } + + std::cout << "EqualsWithDeltaOperator_should_succeed" << std::endl; + { + Assert::That(2, EqualsWithDelta(1.9, 0.1)); + } + + std::cout << "Fluent_equals_with_delta_should_fail_for_actual_larger_than_delta" << std::endl; + { + AssertTestFails(Assert::That(3.9, Is().EqualToWithDelta(3, 0.5)), + "Expected: equal to 3 (+/- 0.5)"); + } + + std::cout << "Fluent_EqualsWithDeltaOperator_should_fail_for_actual_less_than_delta" << std::endl; + { + AssertTestFails(Assert::That(2.49, Is().EqualToWithDelta(3, 0.5)), + "Expected: equal to 3 (+/- 0.5)"); + } + + std::cout << "Fluent_EqualsWithDeltaOperator_should_succeed" << std::endl; + { + Assert::That(2, Is().EqualToWithDelta(1.9, 0.1)); + } + +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/sequence_container_tests.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/sequence_container_tests.cpp new file mode 100644 index 00000000..c090cc58 --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/sequence_container_tests.cpp @@ -0,0 +1,192 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + + +template <typename T> +void SequenceContainerActual() +{ + const char* ExpectedActual = "\nActual: [ 1, 2, 3, 5, 8 ]"; + + T container; + container.clear(); + container.push_back(1); + container.push_back(2); + container.push_back(3); + container.push_back(5); + container.push_back(8); + + std::cout << "ShouldHandleAllOperator" << std::endl; + { + Assert::That(container, Has().All().GreaterThan(1).Or().LessThan(4)); + } + + std::cout << "ShouldHandleFailingAllOperator" << std::endl; + { + AssertTestFails(Assert::That(container, Has().All().GreaterThan(4)), std::string("Expected: all greater than 4") + ExpectedActual); + } + + std::cout << "SHouldHandleInvalidExpressionAfterAllOperator" << std::endl; + { + AssertTestFails(Assert::That(container, Has().All().Not()), "The expression contains a not operator without any operand"); + } + + std::cout << "ShouldHandleNoExpressionAfterAllOperator" << std::endl; + { + AssertTestFails(Assert::That(container, Has().All()), "The expression after \"all\" operator does not yield any result"); + } + + std::cout << "ShouldHandleAtLeastOperator" << std::endl; + { + Assert::That(container, Has().AtLeast(1).LessThan(5)); + } + + std::cout << "ShouldHandleFailingAtLeastOperator" << std::endl; + { + AssertTestFails(Assert::That(container, Has().AtLeast(2).LessThan(2)), std::string("Expected: at least 2 less than 2") + ExpectedActual); + } + + std::cout << "ShouldHandleExactlyOperator" << std::endl; + { + Assert::That(container, Has().Exactly(1).EqualTo(3)); + } + + std::cout << "ShouldHandleFailingExactlyOperator" << std::endl; + { + AssertTestFails(Assert::That(container, Has().Exactly(2).EqualTo(3)), std::string("Expected: exactly 2 equal to 3") + ExpectedActual); + } + + std::cout << "ShouldHandleAtMostOperator" << std::endl; + { + Assert::That(container, Has().AtMost(1).EqualTo(5)); + } + + std::cout << "ShouldHandleFailingAtMostOperator" << std::endl; + { + AssertTestFails(Assert::That(container, Has().AtMost(1).EqualTo(3).Or().EqualTo(5)), std::string("Expected: at most 1 equal to 3 or equal to 5") + ExpectedActual); + } + + std::cout << "ShouldHandleNoneOperator" << std::endl; + { + Assert::That(container, Has().None().EqualTo(666)); + } + + std::cout << "ShouldHandleFailingNoneOperator" << std::endl; + { + AssertTestFails(Assert::That(container, Has().None().EqualTo(5)), std::string("Expected: none equal to 5") + ExpectedActual); + } + + std::cout << "ShouldHandleContaining" << std::endl; + { + Assert::That(container, Contains(3)); + } + + std::cout << "ShouldDetectFailingContains" << std::endl; + { + AssertTestFails(Assert::That(container, Contains(99)), std::string("contains 99") + ExpectedActual); + } + + std::cout << "ShouldHandleOfLength" << std::endl; + { + Assert::That(container, HasLength(5)); + } + + std::cout << "ShouldHandleFailingOfLength" << std::endl; + { + AssertTestFails(Assert::That(container, HasLength(7)), std::string("of length 7") + ExpectedActual); + } + + std::cout << "ShouldHandleContaining_ExpressionTemplates" << std::endl; + { + Assert::That(container, Contains(3)); + } + + std::cout << "ShouldDetectFailingContains_ExpressionTemplates" << std::endl; + { + AssertTestFails(Assert::That(container, Contains(99)), std::string("contains 99") + ExpectedActual); + } + + std::cout << "ShouldHandleOfLength_ExpressionTemplates" << std::endl; + { + Assert::That(container, HasLength(5)); + } + + std::cout << "ShouldHandleFailingOfLengthForVectors" << std::endl; + { + AssertTestFails(Assert::That(container, HasLength(7)), std::string("of length 7") + ExpectedActual); + } + + std::cout << "ShouldHandleIsEmpty" << std::endl; + { + T is_empty; + + Assert::That(is_empty, IsEmpty()); + } + + std::cout << "ShouldHandleFailingIsEmpty" << std::endl; + { + AssertTestFails(Assert::That(container, IsEmpty()), "of length 0"); + } + + std::cout << "ShouldHandleFluentIsEmpty" << std::endl; + { + T is_empty; + + Assert::That(is_empty, Is().Empty()); + } + + std::cout << "ShouldHandleFailingFluentIsEmpty" << std::endl; + { + AssertTestFails(Assert::That(container, Is().Empty()), "of length 0"); + } + + std::cout << "ShouldHandlerEqualsContainer" << std::endl; + { + std::list<int> expected; + expected.assign(container.begin(), container.end()); + + AssertThat(container, EqualsContainer(expected)); + } + + std::cout << "ShouldHandleEqualsContainer_Fluent" << std::endl; + { + std::list<int> expected; + expected.assign(container.begin(), container.end()); + + AssertThat(container, Is().EqualToContainer(expected)); + } + + std::cout << "ShouldHandleFailingEqualsContainer" << std::endl; + { + const int e[] = {4, 2, 4}; + std::list<int> expected(e, e + sizeof(e) / sizeof(e[0])); + + AssertTestFails(Assert::That(container, EqualsContainer(expected)), "Expected: [ 4, 2, 4 ]"); + } + + std::cout << "ShouldHandleFailingEqualsContainer_Fluent" << std::endl; + { + const int e[] = {4, 2, 4}; + std::list<int> expected(e, e + sizeof(e) / sizeof(e[0])); + + AssertTestFails(Assert::That(container, Is().EqualToContainer(expected)), "Expected: [ 4, 2, 4 ]"); + } +} + +void SequenceContainerTests() +{ + std::cout << "================================================" << std::endl; + std::cout << " SequenceContainerTests(vector)" << std::endl; + std::cout << "================================================" << std::endl; + SequenceContainerActual<std::vector<int> >(); + + std::cout << "================================================" << std::endl; + std::cout << " SequenceContainerTests(list)" << std::endl; + std::cout << "================================================" << std::endl; + SequenceContainerActual<std::list<int> >(); + + std::cout << "================================================" << std::endl; + std::cout << " SequenceContainerTests(deque)" << std::endl; + std::cout << "================================================" << std::endl; + SequenceContainerActual<std::deque<int> >(); +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/string_line_tests.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/string_line_tests.cpp new file mode 100644 index 00000000..8cf90cfb --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/string_line_tests.cpp @@ -0,0 +1,179 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +void StringLineTests() +{ + std::cout << "================================================" << std::endl; + std::cout << " StringLineTests" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "CanAssertThatAtLeastOneLineInAStreamMatches" << std::endl; + { + Assert::That("First line\n", Has().AtLeast(1).EqualTo("First line")); + } + + std::cout << "CanDetectWhenAssertionFails" << std::endl; + { + AssertTestFails(Assert::That("First line\n", Has().AtLeast(1).EqualTo("Second line")), "Expected: at least 1 equal to Second line"); + } + + std::cout << "CanHandleLineMissingNewline" << std::endl; + { + Assert::That("First line", Has().AtLeast(1).EqualTo("First line")); + } + + std::cout << "CanHandleSeveralLines" << std::endl; + { + std::string lines = "First line\nSecond line"; + Assert::That(lines, Has().Exactly(2).EndingWith("line")); + } + + std::cout << "CanHandleWindowsLineEndings" << std::endl; + { + std::string lines = "First line\r\nSecond line\r\nThird line"; + Assert::That(lines, Has().Exactly(3).EndingWith("line")); + } + + std::cout << "CanMatchBeginningOfLinesWithWindowsLineEndings" << std::endl; + { + std::string lines = "First line\nSecond line\r\nThird line"; + Assert::That(lines, Has().Exactly(1).StartingWith("Second")); + } + + std::cout << "CanHandleEmptyLinesWhenUsingWindowsLineEndings" << std::endl; + { + std::string lines = "\r\nSecond line\r\n\r\n"; + Assert::That(lines, Has().Exactly(2).OfLength(0)); + } + + std::cout << "CanHandleLastLineMissingNewlineForWindowsLineEndings" << std::endl; + { + std::string lines = "First line\r\nSecond line"; + Assert::That(lines, Has().Exactly(2).EndingWith("line")); + } + + std::cout << "CanHandleAllEmptyLines" << std::endl; + { + Assert::That("\n\n\n\n\n\n", Has().Exactly(6).OfLength(0)); + } + + std::cout << "CanHandleAllEmptyLinesWithWindowsLineEndings" << std::endl; + { + Assert::That("\r\n\r\n\r\n", Has().Exactly(3).OfLength(0)); + } + + + std::cout << "================================================" << std::endl; + std::cout << " StringLineParserTests" << std::endl; + std::cout << "================================================" << std::endl; + + + std::cout << "CanParseEmptyString" << std::endl; + { + std::vector<std::string> res; + + StringLineParser::Parse("", res); + + Assert::That(res, HasLength(0)); + } + + std::cout << "CanParseSingleLine" << std::endl; + { + std::vector<std::string> res; + + StringLineParser::Parse("Simple line", res); + + Assert::That(res, HasLength(1)); + Assert::That(res, Has().Exactly(1).EqualTo("Simple line")); + } + + std::cout << "CanParseTwoLines" << std::endl; + { + std::vector<std::string> res; + + StringLineParser::Parse("One line\nTwo lines", res); + + Assert::That(res, HasLength(2)); + Assert::That(res, Has().Exactly(1).EqualTo("One line")); + Assert::That(res, Has().Exactly(1).EqualTo("Two lines")); + } + + std::cout << "CanParseThreeLines" << std::endl; + { + std::vector<std::string> res; + + StringLineParser::Parse("One line\nTwo lines\nThree lines", res); + + Assert::That(res, HasLength(3)); + Assert::That(res, Has().Exactly(1).EqualTo("One line")); + Assert::That(res, Has().Exactly(1).EqualTo("Two lines")); + Assert::That(res, Has().Exactly(1).EqualTo("Three lines")); + } + + std::cout << "CanHandleStringEndingWithNewline" << std::endl; + { + std::vector<std::string> res; + StringLineParser::Parse("One line\n", res); + Assert::That(res, HasLength(1)); + Assert::That(res, Has().Exactly(1).EqualTo("One line")); + } + + std::cout << "CanHandleSingleLineWithWindowsLineEnding" << std::endl; + { + std::vector<std::string> res; + StringLineParser::Parse("One line\r\n", res); + Assert::That(res, HasLength(1)); + Assert::That(res, Has().Exactly(1).EqualTo("One line")); + } + + std::cout << "CanHandleTwoLinesWithWindowsLineEndings" << std::endl; + { + std::vector<std::string> res; + StringLineParser::Parse("One line\r\nTwo lines", res); + Assert::That(res, HasLength(2)); + Assert::That(res, Has().Exactly(1).EqualTo("One line")); + Assert::That(res, Has().Exactly(1).EqualTo("Two lines")); + } + + std::cout << "CanHandleEmptyLineWithNewline" << std::endl; + { + std::vector<std::string> res; + StringLineParser::Parse("\n", res); + Assert::That(res, Is().OfLength(1).And().Exactly(1).OfLength(0)); + } + + std::cout << "CanHandleTwoEmptyLines" << std::endl; + { + std::vector<std::string> res; + StringLineParser::Parse("\n\n", res); + Assert::That(res, HasLength(2)); + Assert::That(res, Has().Exactly(2).OfLength(0)); + } + + std::cout << "CanHandleTwoEmptyLinesWithWindowsLineEndings" << std::endl; + { + std::vector<std::string> res; + StringLineParser::Parse("\r\n\r\n", res); + Assert::That(res, HasLength(2)); + Assert::That(res, Has().Exactly(2).OfLength(0)); + } + + std::cout << "CanHandleCarriageReturnOnly" << std::endl; + { + std::vector<std::string> res; + StringLineParser::Parse("One line\rTwo lines", res); + Assert::That(res, HasLength(2)); + Assert::That(res, Has().Exactly(1).EqualTo("One line")); + Assert::That(res, Has().Exactly(1).EqualTo("Two lines")); + } + + std::cout << "CanHandleCarriageReturnOnlyAtEndOfString" << std::endl; + { + std::vector<std::string> res; + StringLineParser::Parse("One line\r\nTwo lines\r", res); + Assert::That(res, HasLength(2)); + Assert::That(res, Has().Exactly(1).EqualTo("One line")); + Assert::That(res, Has().Exactly(1).EqualTo("Two lines")); + } +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/string_tests.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/string_tests.cpp new file mode 100644 index 00000000..989ad42b --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/string_tests.cpp @@ -0,0 +1,65 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +void StringTests() +{ + std::cout << "================================================" << std::endl; + std::cout << " StringTests" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "ShouldHandleStringContainsConstraint" << std::endl; + { + Assert::That("abcdef", Contains("bcde")); + } + + std::cout << "StringConstraintShouldHandleMatchAtBeginningOfString" << std::endl; + { + Assert::That("abcdef", Contains("a")); + } + + std::cout << "ShouldDetectFailingContains" << std::endl; + { + AssertTestFails(Assert::That("abcdef", Contains("hello")), "contains hello"); + } + + std::cout << "ShouldHandleStringStartingWithConstraint" << std::endl; + { + Assert::That("abcdef", StartsWith("abc")); + } + + std::cout << "ShouldHandleStringEndingWithConstraint" << std::endl; + { + Assert::That("abcdef", EndsWith("def")); + } + + std::cout << "ShouldHandleOperatorsForStrings" << std::endl; + { + Assert::That("abcdef", StartsWith("ab") && EndsWith("ef")); + } + + std::cout << "ShouldHandleStringsWithMultipleOperators" << std::endl; + { + Assert::That("abcdef", StartsWith("ab") && !EndsWith("qwqw")); + } + + std::cout << "ShouldHandleOfLength" << std::endl; + { + Assert::That("12345", HasLength(5)); + } + + std::cout << "ShouldHandleWeirdLongExpressions" << std::endl; + { + Assert::That("12345", HasLength(5) && StartsWith("123") && !EndsWith("zyxxy")); + } + + std::cout << "ShouldHandleStdStrings" << std::endl; + { + Assert::That("12345", Contains(std::string("23"))); + } + + std::cout << "ShouldHandleSimpleChar" << std::endl; + { + Assert::That("12345", StartsWith('1')); + } +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/stringize_tests.cpp b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/stringize_tests.cpp new file mode 100644 index 00000000..a0971274 --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/stringize_tests.cpp @@ -0,0 +1,111 @@ +#include <snowhouse/snowhouse.h> +using namespace snowhouse; +#include "tests.h" + +namespace +{ + // No overload for operator<<(std::ostream&) or specialization of igloo::Stringizer + struct WithoutStreamOperator + { + WithoutStreamOperator(int id) + : m_id(id) + { + } + + bool operator==(const WithoutStreamOperator& rhs) const + { + return m_id == rhs.m_id; + } + + int m_id; + }; + + // Has operator<<(std::ostream&) + struct WithStreamOperator : public WithoutStreamOperator + { + WithStreamOperator(int id) + : WithoutStreamOperator(id) + { + } + }; + + std::ostream& operator<<(std::ostream& stream, const WithStreamOperator& a) + { + stream << a.m_id; + return stream; + } + + // Has no operator<<(std::ostream&), but a specialization of igloo::Stringizer + struct WithoutStreamOperatorButWithStringizer : public WithoutStreamOperator + { + WithoutStreamOperatorButWithStringizer(int id) + : WithoutStreamOperator(id) + { + } + }; +} + +namespace snowhouse { + + template<> + struct Stringizer< WithoutStreamOperatorButWithStringizer > + { + static std::string ToString(const WithoutStreamOperatorButWithStringizer& value) + { + return snowhouse::Stringize(value.m_id); + } + }; +} + +void StringizeTests() +{ + std::cout << "================================================" << std::endl; + std::cout << " StringizeTests" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "ShouldHandleTypesWithStreamOperators" << std::endl; + { + WithStreamOperator a(12); + WithStreamOperator b(13); + AssertTestFails(Assert::That(a, Is().EqualTo(b)), "Expected: equal to 13\nActual: 12"); + } + + std::cout << "ShouldHandleTypesWithoutStreamOperators" << std::endl; + { + WithoutStreamOperator a(12); + WithoutStreamOperator b(13); + AssertTestFails(Assert::That(a, Is().EqualTo(b)), "Expected: equal to [unsupported type]\nActual: [unsupported type]"); + } + + std::cout << "ShouldHandleTypesWithTraits" << std::endl; + { + WithoutStreamOperatorButWithStringizer a(12); + WithoutStreamOperatorButWithStringizer b(13); + AssertTestFails(Assert::That(a, Is().EqualTo(b)), "Expected: equal to 13\nActual: 12"); + } + + std::cout << "================================================" << std::endl; + std::cout << " StringizeTestsExpressionTemplates" << std::endl; + std::cout << "================================================" << std::endl; + + std::cout << "ShouldHandleTypesWithStreamOperators" << std::endl; + { + WithStreamOperator a(12); + WithStreamOperator b(13); + AssertTestFails(Assert::That(a, Equals(b)), "Expected: equal to 13\nActual: 12"); + } + + std::cout << "ShouldHandleTypesWithoutStreamOperators" << std::endl; + { + WithoutStreamOperator a(12); + WithoutStreamOperator b(13); + AssertTestFails(Assert::That(a, Equals(b)), "Expected: equal to [unsupported type]\nActual: [unsupported type]"); + } + + std::cout << "ShouldHandleTypesWithTraits" << std::endl; + { + WithoutStreamOperatorButWithStringizer a(12); + WithoutStreamOperatorButWithStringizer b(13); + AssertTestFails(Assert::That(a, Is().EqualTo(b)), "Expected: equal to 13\nActual: 12"); + } +} diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/tests.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/tests.h new file mode 100644 index 00000000..9dd1d28c --- /dev/null +++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/example/tests.h @@ -0,0 +1,16 @@ +#ifndef SNOWHOUSE_EXAMPLES_TEST_H +#define SNOWHOUSE_EXAMPLES_TEST_H + +#define AssertTestFails(assertion, expected_error_text) \ + std::string IGLOO_INTERNAL_expected_error = "Test did not fail"; \ + try \ + { \ + assertion; \ + } \ + catch(const AssertionException& exception_from_igloo_assertion) \ + { \ + IGLOO_INTERNAL_expected_error = exception_from_igloo_assertion.GetMessage(); \ + } \ + Assert::That(IGLOO_INTERNAL_expected_error, Is().Containing(expected_error_text)); + +#endif |