1 files changed, 192 insertions, 0 deletions
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> >();
+}