crpcut-0.8.2 (a.k.a 1.0-beta3) - The Compartmented Robust Posix C++ Unit Tester

• Introductory example
• Why crpcut
• Competition
• crpcut links
• License
• Requirements
• Build and Install
• Writing tests
• Comparing strings
• Comparing floating point values
• Using google-mock with crpcut
• The main program
• Debugging
• Advanced techniques
• Further development

  #include <crpcut.hpp>
  #include <string>

  struct apastr // fixture for mosts tests
  {
    apastr() : s("apa") {}
    std::string s;
  };

  TESTSUITE(basics)
  {
    TEST(default_constr_and_destr)
    {
      std::string s;
      ASSERT_TRUE(s.empty());
      ASSERT_EQ(s.length(), 0);
    }

    TEST(constr_from_char_array, apastr,
                                 DEPENDS_ON(default_constr_and_destr))
    {
      ASSERT_EQ(s.length(), 3UL);
    }

    TEST(at, apastr,
             DEPENDS_ON(default_constr_and_destr))
    {
      ASSERT_EQ(s.at(1), 'p');
    }
  }

  TESTSUITE(errors, DEPENDS_ON(ALL_TESTS(basics)))
  {
    TEST(out_of_mem, EXPECT_EXCEPTION(std::bad_alloc))
    {
      crpcut::heap::set_limit(crpcut::heap::allocated_bytes() + 2);
      std::string s("apa");
    }

    TEST(at_out_of_range, apastr,
                          EXPECT_EXCEPTION(std::out_of_range))
    {
      s.at(4);
    }

    TEST(index_oper_out_of_range, apastr,
                                  EXPECT_SIGNAL_DEATH(SIGABRT),
                                  NO_CORE_FILE)
    {
      s[4];
    }
  }

  int main(int argc, char *argv[])
  {
    return crpcut::test_case_factory::run_test(argc, argv);
  }

• googletest
• CppUnit
• UnitTest++
• unit--
• CppTest
• Dave's Unit Test
• unit++
• Test soon
• CxxTester
• testicle

/*
 * Copyright 2009 Bjorn Fahller <bjorn@fahller.se>
 * All rights reserved

 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

   EEXIST
   EINTR

   alloca()
   chdir()
** clock_gettime(CLOCK_MONOTONIC)
** clock_gettime(CLOCK_PROCESS_CPUTIME_ID)
   close()
   closedir()
   dup2()
++ epoll_create()
++ epoll_ctl()
++ epoll_wait()
   fork()
   getcwd()
   gethostname()
** getitimer(ITIMER_REAL)
** getitimer(ITIMER_VIRTUAL)
   kill()
   mkdir()
   open()
   opendir()
   pipe()
   read()
   readdir_r()
-- regcomp()
-- regexec()
-- regerror()
-- regfree()
   rmdir()
++ select()
** setitimer(ITIMER_REAL)
** setitimer(ITIMER_VIRTUAL)
   setrlimit(RLIMIT_CORE)
   setrlimit(RLIMIT_CPU)
   waitid()
   write()

   mkdtemp()

  > cmake path

  > cmake path -DCMAKE_INSTALL_PREFIX=<desired_install_directory>

  > CXX=icpc cmake ...

  -DWITH_GOOGLE_MOCK=yes

  -DGOOGLE_MOCK_DIR=path

  > make

  > make testprog

  > make selftest

  > make install

  TEST(name_of_testcase (,(fixture|modifier))*)
  {
    ... code
  }

  const char *p = afunc();
  ASSERT_TRUE(std::equal_to<std::string>()("expected", p));

  const char *p = afunc();
  ASSERT_PRED(std::equal_to<std::string>(), "expected", p);

  ASSERT_TRUE(std::equal_to<std::string>()("expected", p))
    where std::equal_to<std::string>()("expected", p) = false

  ASSERT_PRED(std::equal_to<std::string>()("expected", p))
    param1 = expected
    param2 = otherval

  TEST(fail_immediately)
  {
    int n = random();
    INFO << "random value is " << n;
    FAIL << "Goodbye cruel world";
  }

  TESTSUITE(string_length)
  {
    class fixture1
    {
    protected:
      fixture1() : i(3) {}
      int i;
    };
    struct fixture2
    {
      std::string msg;
      fixture2() : msg("cat");
    };

    TEST(check_length, fixture1, fixture2)
    {
      ASSERT_EQ(msg.length(), i);
    }

    TEST(check_c_length, fixture1, fixture2)
    {
      ASSERT_EQ(std::strlen(msg.c_str()), i);
    }
  }

  ASSERT_TRUE(crpcut::collate("aaa") op "aaaa")

  ASSERT_TRUE(crpcut::collate("aaa", std::locale("sv_SE")) op s);

  TEST(de_sv_collation)
  {
    static const char s1[] = "öz";
    static const char s2[] = "zö";
    ASSERT_TRUE(crpcut::collate(s1, std::locale("de_DE")) < s2);
    ASSERT_TRUE(crpcut::collate(s1, std::locale("sv_SE")) > s2);
  }

  ASSERT_PRED(crpcut::match<crpcut::regex>(pattern, flags...), string);

  TEST(looks_like_ipaddr)
  {
    using crpcut::match;
    using crpcut::regex;

    const char *ipaddr = afunc();
    static const char pattern[] = "^([[:digit:]]{1,3}\\.){3}[[:digit:]]{1,3}$";
    ASSERT_PRED(match<regex>(pattern, regex::e), ipaddr);
  }

  ASSERT_PRED(crpcut::match<crpcut::abs_diff>(0.0001), a, b);

  #include <gmock/gmock.h> // Always gmock/gmock.h before crpcut.hpp
  #include <crpcut.hpp>    // since crpcut redefines some macros.

  #include <gmock/gmock.h>
  #include <crpcut.hpp>

  struct iface1 {
    virtual void f1(int) = 0;
  };

  struct iface2 {
    virtual void f1(const char *) = 0;
  };

  struct mock1 : iface1 {
    MOCK_METHOD1(f1, void(int));
  };

  struct mock2 : iface2 {
    MOCK_METHOD1(f1, void(const char*));
  };

  struct fix_base {
    mock1 m1;
    mock2 m2;
  };

  class fix_seq1 : public fix_base {
  public:
    fix_seq1() {
      EXPECT_CALL(m1, f1(3)).InSequence(s);
      EXPECT_CALL(m2, "hello").InSequence(s);
    }
  private:
    testing::sequence s; // prevent test cases from changing the sequence
  };

  class fix_seq2 : public fix_base {
  public:
    fix_seq2() {
      EXPECT_CALL(m1, f1(3)).InSequence(s1, s2);
      EXPECT_CALL(m1, f1(4)).InSequence(s1);
    }
  protected:
    testing::sequence s1; // open-ended, for test-cases
    testing::sequence s2; // to add more to the sequences
  };

  TEST(t1, fix_seq1)
  {
    ... // do things with m1 and m2
  }

  TEST(t2, fix_seq2)
  {
    // add more to the started sequence
    EXPECT_CALL(m2, f("hello")).InSequence(s2);

    ... // do things with m1 and m2
  }

  TEST(t3, fix_seq2)
  {
    // add other things to the started sequence
    EXPECT_CALL(m2, f("world")).InSequence(s2);

    ... // do things with m1 and m2
  }

  int main(int argc, char *argv[])
  {
    return crpcut::test_case_factory::run_test(argc, argv);
  }

  namespace crpcut {
    class test_case_factory
    {
    public:
      static int run_test(int argc, const char *argv[], std::ostream & = std::cerr);
    };
  }

>$ gdb --args ./test/testprog -s asserts::should_succeed_assert_no_throw
GNU gdb 6.8
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-pc-linux-gnu"...
(gdb) break asserts::should_succeed_assert_no_throw::test
Breakpoint 1 at 0x487ce4: file /home/bjorn/devel/crpcut/test-src/asserts_and_depends.cpp, line 80.
(gdb) run
Starting program: /var/tmp/build/test/testprog -s -n asserts::should_succeed_assert_no_throw
[Thread debugging using libthread_db enabled]
[New Thread 0x7f5605d43700 (LWP 17769)]
[Switching to Thread 0x7f5605d43700 (LWP 17769)]

Breakpoint 1, asserts::should_succeed_assert_no_throw::test (this=0x7fff0dd76340)
    at /home/bjorn/devel/crpcut/test-src/asserts_and_depends.cpp:80
80          ASSERT_NO_THROW(i=1);
(gdb) quit

  TEST(fail_vector_resize)
  {
    std::vector<int> vec;
    crpcut::heap::set_limit(crpcut::heap::allocated_bytes() + 100);
    vec.resize(50); // throws!
  }
  

  TEST(verify_no_leaks)
  {
    size_t pre_bytes = crpcut::heap::allocated_bytes();
    size_t pre_objs = crpcut::heap::allocated_objects();
    function_suspect_of_memor_leak();
    ASSERT_EQ(pre_objs, crpcut::heap::allocated_objects());
    ASSERT_EQ(pre_bytes, crpcut::heap::allocated_bytes());
  }
  

  const char *crpcut::test_case_factory::get_start_dir();

  class test_case_factory
  {
  public:
    static const char *get_parameter(const char *name);

    template <typename T>
    static void get_parameter(const char *name, T& t);

    template <typename T>
    static T get_parameter(const char *name);
  };

  const char *p = afunc();
  ASSERT_PRED(boost::bind(std::strcmp, _1, _2) == 0, "expected", p);

  template <typename R, typename P1, typename P2>
  struct binder<R (*)(P1, P2)>
  {
    typedef R (*proto)(P1, P2);
    typedef decltype boost::bind(proto(0), _1, _2) type;
    static type bind(proto f) { return boost::bind(f, _1, _2); }
  };

  template <typename F>
  typename binder<F>::type return_of(F f)
  {
    return binder<F>::bind(f);
  }

  const char *p = afunc();
  ASSERT_PRED(return_of(std::strcmp) == 0, "expected", p);

  ASSERT_PRED(return_of(std::strcmp) == 0, "expected", p)
    param1 = expected
    param2 = otherval

  class equal
  {
  public:
    equal(const char *ref) : r(ref) {}
    bool operator()(const char *v) const { return strcasecmp(v, r) == 0; }
    friend std::ostream& operator<<(std::ostream &os, const equal &e)
    {
      return os << "case insensitive string equal to \"" << e.r << "\"";
    }
  private:
    const char *r;
  };

  const char *p = afunc();
  ASSERT_PRED(equal("expected"), p);

  ASSERT_PRED(equal("expected", p))
    equal("expected") : case insensitive string equal to "expected"
    param1 = otherval

  class ptr_deref_eq
  {
  public:
    template <typename T>
    class type
    {
    public:
      type(T* refp) : rp(refp) {}
      type(const type<T>& t) : rp(t.rp), cp(t.cp) {}
      bool operator()(T* compp)
      {
        cp = compp; // store values for use by output stream operator
        return *rp == *cp;
      }
      friend std::ostream& operator<<(std::ostream &os, const type<T>& t)
      {
        os << "reference ptr=" << t.rp << " pointing to:" << *t.rp
           << "\ncompared ptr=" << t.cp << " pointing to: " << *t.cp;
        return os;
      }
    private:
      T* rp;
      T* cp;
    };
  };

  namespace crpcut {
    template <typename T>
    struct match_traits<ptr_deref_eq, T*>
    {
      typedef typename ptr_deref_eq::template type<T> type;
    };
  } // namespace crpcut
  

    int *p1 = afunc();
    int n = 3;
    ASSERT_PRED(crpcut::match<ptr_deref_eq>(&n), p1);
  

  CRPCUT_WRAP_FUNC(libname, funcname, rettype, prototype_params, call_params)

  extern "C" {
    #include <stdio.h>
  }
  #include <crpcut.hpp>
  namespace mywraps {
    CRPCUT_WRAP_FUNC(libc, fopen, FILE*, (const char *p, const char *m), (p, m))
  }
  FILE* fopen(const char *p, const char *m)
  {
    ASSERT_TRUE(p);
    ASSERT_TRUE(m);
    return mywraps::fopen(p, m);
  }

  extern "C" {
    #include <math.h>
  }
  #include <crpcut.hpp>

  namespace crpcut {
    namespace libs {
      static const int libm = 1;
    }
    namespace libwrapper {
      template <>
      const char *traits<libs::libm>::name[] = {
        "libm.so",
        "libm.so.6",
        0
      };
    }
  }
  namespace mymath {
    CRPCUT_WRAP_FUNC(libm, asin, double, (double d), (d))
  }

  extern "C"
  {
    double asin(double d)
    {
      ASSERT_GE(d, -1.0);
      ASSERT_LE(d, 1.0);
      return mymath::asin(d);
    }
  }

• Rewrite documenation before 1.0
• Set regexp match rules for stdout and stderr (probably won't happen before 1.0)
• OS/X compatibility would be nice