Add BanditCpp 1.1.4 test harness

16 files changed, 815 insertions, 0 deletions

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/constraints.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/constraints.h
new file mode 100644
index 00000000..ea7a53d1
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/constraints.h
@@ -0,0 +1,21 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_CONSTRAINTS_H

+#define IGLOO_CONSTRAINTS_H

+

+#include "containsconstraint.h"

+#include "endswithconstraint.h"

+#include "equalsconstraint.h"

+#include "haslengthconstraint.h"

+#include "isgreaterthanconstraint.h"

+#include "islessthanconstraint.h"

+#include "startswithconstraint.h"

+#include "fulfillsconstraint.h"

+#include "equalswithdeltaconstraint.h"

+#include "equalscontainerconstraint.h"

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/containsconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/containsconstraint.h
new file mode 100644
index 00000000..f20d6800
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/containsconstraint.h
@@ -0,0 +1,80 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_CONTAINSCONSTRAINT_H

+#define IGLOO_CONTAINSCONSTRAINT_H

+

+#include <algorithm>

+

+#include "./expressions/expression.h"

+

+namespace snowhouse {

+  

+  template <typename ContainerType>

+  struct find_in_container_traits

+  {

+    template <typename ExpectedType>

+    static bool find(const ContainerType& container, const ExpectedType& expected)

+    {

+      return std::find(container.begin(), container.end(), expected) != container.end();

+    }

+  };

+  

+  template <typename KeyType, typename ValueType>

+  struct find_in_container_traits<std::map<KeyType, ValueType> >

+  {

+    template <typename ExpectedType>

+    static bool find(const std::map<KeyType, ValueType>& container, const ExpectedType& expected)

+    {

+      return container.find(expected) != container.end();

+    }

+  };

+  

+  template <typename ExpectedType>

+  struct ContainsConstraint : Expression< ContainsConstraint<ExpectedType> >

+  {

+    ContainsConstraint(const ExpectedType& expected) 

+    : m_expected(expected) {}

+    

+    template <typename ActualType>

+    bool operator()(const ActualType& actual) const

+    {

+      return find_in_container_traits<ActualType>::find(actual, m_expected);

+    } 

+    

+    bool operator()(const std::string& actual) const

+    {

+      return actual.find(m_expected) != actual.npos; 

+    }   

+    

+    ExpectedType m_expected;

+  };              

+

+  template< typename ExpectedType >

+  inline ContainsConstraint<ExpectedType> Contains(const ExpectedType& expected)

+  {

+    return ContainsConstraint<ExpectedType>(expected);

+  }        

+  

+  inline ContainsConstraint<std::string> Contains(const char* expected)

+  {

+    return ContainsConstraint<std::string>(expected);

+  }

+  

+  template< typename ExpectedType >

+  struct Stringizer< ContainsConstraint< ExpectedType > >

+  {

+    static std::string ToString(const ContainsConstraint<ExpectedType>& constraint)

+    {

+      std::ostringstream builder;

+	  builder << "contains " << snowhouse::Stringize(constraint.m_expected);

+

+      return builder.str();

+    }

+  };

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/endswithconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/endswithconstraint.h
new file mode 100644
index 00000000..c867e203
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/endswithconstraint.h
@@ -0,0 +1,53 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_ENDSWITHCONSTRAINT_H

+#define IGLOO_ENDSWITHCONSTRAINT_H

+

+#include "./expressions/expression.h"

+

+namespace snowhouse {

+

+  template <typename ExpectedType>

+  struct EndsWithConstraint : Expression< EndsWithConstraint<ExpectedType> >

+  {

+    EndsWithConstraint(const ExpectedType& expected) 

+      : m_expected(expected) {}

+      

+    bool operator()(const std::string& actual) const

+    {

+      size_t expectedPos = actual.length() - m_expected.length();

+      return actual.find(m_expected) == expectedPos;

+    } 

+    

+    ExpectedType m_expected;

+  };              

+

+  template< typename ExpectedType >

+  inline EndsWithConstraint<ExpectedType> EndsWith(const ExpectedType& expected)

+  {

+    return EndsWithConstraint<ExpectedType>(expected);

+  }

+  

+  inline EndsWithConstraint<std::string> EndsWith(const char* expected)

+  {

+    return EndsWithConstraint<std::string>(expected);

+  }

+

+  template< typename ExpectedType >

+  struct Stringizer< EndsWithConstraint< ExpectedType > >

+  {

+    static std::string ToString(const EndsWithConstraint<ExpectedType>& constraint)

+    {

+      std::ostringstream builder;

+	  builder << "ends with " << snowhouse::Stringize(constraint.m_expected);

+

+      return builder.str();

+    }

+  };

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalsconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalsconstraint.h
new file mode 100644
index 00000000..cbdc4054
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalsconstraint.h
@@ -0,0 +1,74 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_EQUALSCONSTRAINT_H

+#define IGLOO_EQUALSCONSTRAINT_H

+

+#include "./expressions/expression.h"

+

+namespace snowhouse {

+

+  template< typename ExpectedType >

+  struct EqualsConstraint : Expression< EqualsConstraint<ExpectedType> >

+  {

+    EqualsConstraint(const ExpectedType& expected)

+      : m_expected(expected)

+    {

+    }

+

+    template<typename ActualType>

+    bool operator()(const ActualType& actual) const

+    {

+      return (m_expected == actual);

+    }

+

+    ExpectedType m_expected;

+  };

+

+  template< typename ExpectedType >

+  inline EqualsConstraint<ExpectedType> Equals(const ExpectedType& expected)

+  {

+    return EqualsConstraint<ExpectedType>(expected);

+  }

+

+  inline EqualsConstraint<std::string> Equals(const char* expected)

+  {

+    return EqualsConstraint<std::string>(expected);

+  }

+

+  inline EqualsConstraint<bool> IsFalse()

+  {

+    return EqualsConstraint<bool>(false);

+  }

+

+  inline EqualsConstraint<bool> IsTrue()

+  {

+    return EqualsConstraint<bool>(true);

+  }

+

+  template <>

+  struct Stringizer< EqualsConstraint< bool > >

+  {

+    static std::string ToString(const EqualsConstraint<bool>& constraint)

+    {

+      return constraint.m_expected ? "true" : "false";

+    }

+  };

+

+  template< typename ExpectedType >

+  struct Stringizer< EqualsConstraint< ExpectedType > >

+  {

+    static std::string ToString(const EqualsConstraint<ExpectedType>& constraint)

+    {

+      std::ostringstream builder;

+	  builder << "equal to " << snowhouse::Stringize(constraint.m_expected);

+

+      return builder.str();

+    }

+  };

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalscontainerconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalscontainerconstraint.h
new file mode 100644
index 00000000..6bb5d797
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalscontainerconstraint.h
@@ -0,0 +1,75 @@
+
+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.
+// 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)
+
+#ifndef IGLOO_EQUALSCONTAINERCONSTRAINT_H
+#define IGLOO_EQUALSCONTAINERCONSTRAINT_H
+
+namespace snowhouse {
+
+  namespace constraint_internal {
+    template<typename T>
+    inline bool default_comparer(const T& lhs, const T& rhs)
+    {
+      return lhs == rhs;
+    }
+  }
+
+  template< typename ExpectedType, typename BinaryPredicate>
+    struct EqualsContainerConstraint : Expression< EqualsContainerConstraint<ExpectedType, BinaryPredicate> >
+  {
+    EqualsContainerConstraint(const ExpectedType& expected, const BinaryPredicate predicate)
+      : expected_(expected), predicate_(predicate)
+    {}
+
+    template<typename ActualType>
+      bool operator()(const ActualType& actual) const
+      {
+        typename ActualType::const_iterator actual_it;
+        typename ExpectedType::const_iterator expected_it;
+
+        for(actual_it = actual.begin(), expected_it = expected_.begin(); actual_it != actual.end() && expected_it != expected_.end(); actual_it++, expected_it++)
+        {
+          if(!predicate_(*actual_it, *expected_it))
+          {
+            return false;
+          }
+        }
+
+        return actual.size() == expected_.size();
+      }
+
+    const ExpectedType expected_;
+    const BinaryPredicate predicate_;
+
+  private:
+	  EqualsContainerConstraint& operator=(const EqualsContainerConstraint&) { return *this; }
+  };
+
+  template< typename ExpectedType>
+    inline EqualsContainerConstraint<ExpectedType, bool (*)(const typename ExpectedType::value_type&, const typename ExpectedType::value_type&)> EqualsContainer(const ExpectedType& expected)
+    {
+      return EqualsContainerConstraint<ExpectedType, bool (*)(const typename ExpectedType::value_type&, const typename ExpectedType::value_type&)>(expected, constraint_internal::default_comparer);
+    }
+
+  template< typename ExpectedType, typename BinaryPredicate >
+    inline EqualsContainerConstraint<ExpectedType, BinaryPredicate> EqualsContainer(const ExpectedType& expected, const BinaryPredicate predicate)
+    {
+      return EqualsContainerConstraint<ExpectedType, BinaryPredicate>(expected, predicate);
+    }
+
+  template< typename ExpectedType, typename BinaryPredicate >
+    struct Stringizer< EqualsContainerConstraint<ExpectedType, BinaryPredicate> >
+    {
+      static std::string ToString(const EqualsContainerConstraint<ExpectedType, BinaryPredicate>& constraint)
+      {
+        std::ostringstream builder;
+        builder << snowhouse::Stringize(constraint.expected_);
+        return builder.str();
+      }
+    };
+}
+
+#endif
diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalswithdeltaconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalswithdeltaconstraint.h
new file mode 100644
index 00000000..b54fb74e
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/equalswithdeltaconstraint.h
@@ -0,0 +1,51 @@
+
+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.
+// 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)
+
+#ifndef IGLOO_EQUALSWITHDELTACONSTRAINT_H
+#define IGLOO_EQUALSWITHDELTACONSTRAINT_H
+
+#include "./expressions/expression.h"
+
+namespace snowhouse {
+
+  template< typename ExpectedType, typename DeltaType >
+  struct EqualsWithDeltaConstraint : Expression< EqualsWithDeltaConstraint<ExpectedType, DeltaType> >
+  {
+    EqualsWithDeltaConstraint(const ExpectedType& expected, const DeltaType& delta)
+      : m_expected(expected), m_delta(delta)
+    {
+    }
+
+    template<typename ActualType>
+    bool operator()(const ActualType& actual) const
+    {
+      return ((m_expected <= (actual + m_delta)) && (m_expected >= (actual - m_delta)));
+    }
+
+    ExpectedType m_expected;
+    DeltaType m_delta;
+  };
+
+  template< typename ExpectedType, typename DeltaType >
+  inline EqualsWithDeltaConstraint<ExpectedType, DeltaType> EqualsWithDelta(const ExpectedType& expected, const DeltaType& delta)
+  {
+    return EqualsWithDeltaConstraint<ExpectedType, DeltaType>(expected, delta);
+  }
+
+  template< typename ExpectedType, typename DeltaType >
+  struct Stringizer< EqualsWithDeltaConstraint< ExpectedType, DeltaType > >
+  {
+    static std::string ToString(const EqualsWithDeltaConstraint<ExpectedType, DeltaType>& constraint)
+    {
+      std::ostringstream builder;
+	  builder << "equal to " << snowhouse::Stringize(constraint.m_expected) << " (+/- " << snowhouse::Stringize(constraint.m_delta) << ")";
+
+      return builder.str();
+    }
+  };
+}
+
+#endif
diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/andexpression.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/andexpression.h
new file mode 100644
index 00000000..8b6b7d12
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/andexpression.h
@@ -0,0 +1,46 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_ANDEXPRESSION_H

+#define IGLOO_ANDEXPRESSION_H

+

+#include "./expression_fwd.h"

+

+namespace snowhouse {

+

+  template< typename LeftExpression, typename RightExpression >

+  struct AndExpression : Expression< AndExpression<LeftExpression, RightExpression> >

+  {

+    AndExpression(const LeftExpression& left, const RightExpression& right)

+      : m_left(left)

+      , m_right(right)

+    {

+    }

+

+    template< typename ActualType >

+    bool operator()(const ActualType& actual) const

+    {

+      return (m_left(actual) && m_right(actual));

+    }

+

+    LeftExpression m_left;

+    RightExpression m_right;

+  };

+

+  template< typename LeftExpression, typename RightExpression >

+  struct Stringizer< AndExpression<LeftExpression, RightExpression> >

+  {

+    static std::string ToString(const AndExpression<LeftExpression, RightExpression>& expression)

+    {

+      std::ostringstream builder;

+      builder << Stringize(expression.m_left) << " and " << Stringize(expression.m_right);

+

+      return builder.str();

+    }

+  };

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/expression.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/expression.h
new file mode 100644
index 00000000..fa894818
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/expression.h
@@ -0,0 +1,38 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_EXPRESSION_H

+#define IGLOO_EXPRESSION_H

+

+#include "./notexpression.h"

+#include "./andexpression.h"

+#include "./orexpression.h"

+

+namespace snowhouse {

+

+  template<typename T>

+  struct Expression

+  {

+    NotExpression<T> operator!() const

+    {

+      return NotExpression<T>(static_cast<const T&>(*this));

+    }

+

+    template< typename Right >

+    AndExpression<T, Right> operator&&(const Right& right) const

+    {

+      return AndExpression<T, Right>(static_cast<const T&>(*this), right);

+    }

+

+    template< typename Right >

+    OrExpression<T, Right> operator||(const Right& right) const

+    {

+      return OrExpression<T, Right>(static_cast<const T&>(*this), right);

+    }

+  };

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/expression_fwd.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/expression_fwd.h
new file mode 100644
index 00000000..c0e3706e
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/expression_fwd.h
@@ -0,0 +1,15 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_EXPRESSION_FWD_H

+#define IGLOO_EXPRESSION_FWD_H

+

+namespace snowhouse {

+	template<typename T>

+	struct Expression;

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/notexpression.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/notexpression.h
new file mode 100644
index 00000000..4785f07b
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/notexpression.h
@@ -0,0 +1,44 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_NOTEXPRESSION_H

+#define IGLOO_NOTEXPRESSION_H

+  

+#include "./expression_fwd.h"

+

+namespace snowhouse {

+

+  template< typename ExpressionType >

+  struct NotExpression : Expression< NotExpression<ExpressionType> >

+  {

+    NotExpression(const ExpressionType& expression)

+      : m_expression(expression)

+    {

+    }

+

+    template<typename ActualType>

+    bool operator()(const ActualType& actual) const

+    {

+      return !m_expression(actual);

+    }

+

+    ExpressionType m_expression;

+  };

+

+  template< typename ExpressionType >

+  struct Stringizer< NotExpression<ExpressionType> >

+  {

+    static std::string ToString(const NotExpression<ExpressionType>& expression)

+    {

+      std::ostringstream builder;

+	  builder << "not " << snowhouse::Stringize(expression.m_expression);

+

+      return builder.str();

+    }

+  };

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/orexpression.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/orexpression.h
new file mode 100644
index 00000000..c1b6c12b
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/expressions/orexpression.h
@@ -0,0 +1,46 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_OREXPRESSION_H

+#define IGLOO_OREXPRESSION_H

+

+#include "./expression_fwd.h"

+       

+namespace snowhouse {

+

+  template< typename LeftExpression, typename RightExpression >

+  struct OrExpression : Expression< OrExpression<LeftExpression, RightExpression> >

+  {

+    OrExpression(const LeftExpression& left, const RightExpression& right)

+      : m_left(left)

+      , m_right(right)

+    {

+    }

+

+    template< typename ActualType >

+    bool operator()(const ActualType& actual) const

+    {

+      return (m_left(actual) || m_right(actual));

+    }

+

+    LeftExpression m_left;

+    RightExpression m_right;

+  };

+

+  template< typename LeftExpression, typename RightExpression >

+  struct Stringizer< OrExpression<LeftExpression, RightExpression> >

+  {

+    static std::string ToString(const OrExpression<LeftExpression, RightExpression>& expression)

+    {

+      std::ostringstream builder;

+	  builder << snowhouse::Stringize(expression.m_left) << " or " << snowhouse::Stringize(expression.m_right);

+

+      return builder.str();

+    }

+  };

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/fulfillsconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/fulfillsconstraint.h
new file mode 100644
index 00000000..577056c1
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/fulfillsconstraint.h
@@ -0,0 +1,51 @@
+
+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.
+// 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)
+
+#ifndef FULFILLSCONSTRAINT_H
+#define FULFILLSCONSTRAINT_H
+
+#include "./expressions/expression.h"
+
+namespace snowhouse {
+
+  template< typename MatcherType >
+  struct FulfillsConstraint : Expression< FulfillsConstraint<MatcherType> >
+  {
+    FulfillsConstraint(const MatcherType& matcher)
+      : m_matcher(matcher)
+    {
+    }
+
+    template<typename ActualType>
+    bool operator()(const ActualType& actual) const
+    {
+      return m_matcher.Matches(actual);
+    }
+
+    MatcherType m_matcher;
+  };
+
+  template< typename MatcherType >
+  inline FulfillsConstraint<MatcherType> Fulfills(const MatcherType& matcher)
+  {
+    return FulfillsConstraint<MatcherType>(matcher);
+  }
+
+  template< typename MatcherType >
+  struct Stringizer< FulfillsConstraint< MatcherType > >
+  {
+    static std::string ToString(const FulfillsConstraint<MatcherType>& constraint)
+    {
+      std::ostringstream builder;
+      builder << snowhouse::Stringize(constraint.m_matcher);
+
+      return builder.str();
+    }
+  };
+
+}
+
+#endif
diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/haslengthconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/haslengthconstraint.h
new file mode 100644
index 00000000..fb6e7cc9
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/haslengthconstraint.h
@@ -0,0 +1,60 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_HASLENGTHCONSTRAINT_H

+#define IGLOO_HASLENGTHCONSTRAINT_H

+

+#include "./expressions/expression.h"

+

+namespace snowhouse {

+

+  template <typename ExpectedType>

+  struct HasLengthConstraint : Expression< HasLengthConstraint<ExpectedType> >

+  {

+    HasLengthConstraint(const ExpectedType& expected) 

+      : m_expected(expected) {}

+      

+    template <typename ActualType>

+    bool operator()(const ActualType& actual) const

+    {                                    

+      typedef typename ActualType::size_type SizeType;

+      SizeType expectedSize = static_cast<SizeType>(m_expected);

+      return (actual.size() == expectedSize);

+    } 

+    

+    ExpectedType m_expected;

+  };              

+

+  template< typename ExpectedType >

+  inline HasLengthConstraint<ExpectedType> HasLength(const ExpectedType& expected)

+  {

+    return HasLengthConstraint<ExpectedType>(expected);

+  }

+  

+  inline HasLengthConstraint<int> IsEmpty()

+  {

+    return HasLength<int>(0);

+  }

+

+  inline HasLengthConstraint<std::string> HasLength(const char* expected)

+  {

+    return HasLengthConstraint<std::string>(expected);

+  }

+

+  template< typename ExpectedType >

+  struct Stringizer< HasLengthConstraint< ExpectedType > >

+  {

+    static std::string ToString(const HasLengthConstraint<ExpectedType>& constraint)

+    {

+      std::ostringstream builder;

+	  builder << "of length " << snowhouse::Stringize(constraint.m_expected);

+

+      return builder.str();

+    }

+  };

+}      

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/isgreaterthanconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/isgreaterthanconstraint.h
new file mode 100644
index 00000000..e7ef01f8
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/isgreaterthanconstraint.h
@@ -0,0 +1,55 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_ISGREATERTHANCONSTRAINT_H

+#define IGLOO_ISGREATERTHANCONSTRAINT_H

+

+#include "./expressions/expression.h"

+

+namespace snowhouse {

+

+  template< typename ExpectedType >

+  struct IsGreaterThanConstraint : Expression< IsGreaterThanConstraint<ExpectedType> >

+  {

+    IsGreaterThanConstraint(const ExpectedType& expected)

+      : m_expected(expected)

+    {

+    }

+

+    template<typename ActualType>

+    bool operator()(const ActualType& actual) const

+    {

+      return (actual > m_expected);

+    }

+

+    ExpectedType m_expected;

+  };

+

+  template< typename ExpectedType >

+  inline IsGreaterThanConstraint<ExpectedType> IsGreaterThan(const ExpectedType& expected)

+  {

+    return IsGreaterThanConstraint<ExpectedType>(expected);

+  }

+

+  inline IsGreaterThanConstraint<std::string> IsGreaterThan(const char* expected)

+  {

+    return IsGreaterThanConstraint<std::string>(expected);

+  }

+

+  template< typename ExpectedType >

+  struct Stringizer< IsGreaterThanConstraint< ExpectedType > >

+  {

+    static std::string ToString(const IsGreaterThanConstraint<ExpectedType>& constraint)

+    {

+      std::ostringstream builder;

+	  builder << "greater than " << snowhouse::Stringize(constraint.m_expected);

+

+      return builder.str();

+    }

+  };

+}

+

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/islessthanconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/islessthanconstraint.h
new file mode 100644
index 00000000..7379dcf7
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/islessthanconstraint.h
@@ -0,0 +1,54 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_ISLESSTHANCONSTRAINT_H

+#define IGLOO_ISLESSTHANCONSTRAINT_H

+

+#include "./expressions/expression.h"

+

+namespace snowhouse {

+

+  template< typename ExpectedType >

+  struct IsLessThanConstraint : Expression< IsLessThanConstraint<ExpectedType> >

+  {

+    IsLessThanConstraint(const ExpectedType& expected)

+      : m_expected(expected)

+    {

+    }

+

+    template<typename ActualType>

+    bool operator()(const ActualType& actual) const

+    {

+      return (actual < m_expected);

+    }

+

+    ExpectedType m_expected;

+  };

+

+  template< typename ExpectedType >

+  inline IsLessThanConstraint<ExpectedType> IsLessThan(const ExpectedType& expected)

+  {

+    return IsLessThanConstraint<ExpectedType>(expected);

+  }

+

+  inline IsLessThanConstraint<std::string> IsLessThan(const char* expected)

+  {

+    return IsLessThanConstraint<std::string>(expected);

+  }

+

+  template< typename ExpectedType >

+  struct Stringizer< IsLessThanConstraint< ExpectedType > >

+  {

+    static std::string ToString(const IsLessThanConstraint<ExpectedType>& constraint)

+    {

+      std::ostringstream builder;

+	  builder << "less than " << snowhouse::Stringize(constraint.m_expected);

+

+      return builder.str();

+    }

+  };

+}

+#endif

diff --git a/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/startswithconstraint.h b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/startswithconstraint.h
new file mode 100644
index 00000000..ffdd1696
--- /dev/null
+++ b/vendor/bandit/bandit/assertion_frameworks/snowhouse/snowhouse/constraints/startswithconstraint.h
@@ -0,0 +1,52 @@
+

+//          Copyright Joakim Karlsson & Kim Gräsman 2010-2012.

+// 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)

+

+#ifndef IGLOO_STARTSWITHCONSTRAINT_H

+#define IGLOO_STARTSWITHCONSTRAINT_H

+

+#include "./expressions/expression.h"

+

+namespace snowhouse {

+

+  template <typename ExpectedType>

+  struct StartsWithConstraint : Expression< StartsWithConstraint<ExpectedType> >

+  {

+    StartsWithConstraint(const ExpectedType& expected) 

+      : m_expected(expected) {}

+      

+    bool operator()(const std::string& actual) const

+    {

+      return actual.find(m_expected) == 0;

+    } 

+    

+    ExpectedType m_expected;

+  };              

+

+  template< typename ExpectedType >

+  inline StartsWithConstraint<ExpectedType> StartsWith(const ExpectedType& expected)

+  {

+    return StartsWithConstraint<ExpectedType>(expected);

+  }

+  

+  inline StartsWithConstraint<std::string> StartsWith(const char* expected)

+  {

+    return StartsWithConstraint<std::string>(expected);

+  }

+

+  template< typename ExpectedType >

+  struct Stringizer< StartsWithConstraint< ExpectedType > >

+  {

+    static std::string ToString(const StartsWithConstraint<ExpectedType>& constraint)

+    {

+      std::ostringstream builder;

+	  builder << "starts with " << snowhouse::Stringize(constraint.m_expected);

+

+      return builder.str();

+    }

+  };

+}

+

+#endif