CppUTest is a C /C++ based unit xUnit test framework for unit testing and for test-driving your code.

CppUTest

Where to find more information

Getting test reports on the console

You may need to tailor the file src/Platforms/mbed/UtestPlatform.cpp to your needs. In particular, if you want console output, you might want to look at the function PlatformSpecificPutchar().

Quick introduction (some code!)

To write your first test, all you need is a new cpp file with a TEST_GROUP and a TEST, like:

#include "CppUTest/TestHarness.h"

TEST_GROUP(FirstTestGroup)
{
};

TEST(FirstTestGroup, FirstTest)
{
   FAIL("Fail me!");
}

This test will fail.

You can add new tests to the test group by just writing more tests in the file, like this:

TEST(FirstTestGroup, SecondTest)
{
   STRCMP_EQUAL("hello", "world");
   LONGS_EQUAL(1, 2);
   CHECK(false);
}

You do need to trigger the tests from somewhere in your program. It could look something like:

#include "CppUTest/TestRegistry.h"
#include "CppUTest/CommandLineTestRunner.h"

int main(int ac, char** av)
{
    ....
    unsigned failureCount = 0;
    {
        ConsoleTestOutput output;
        CommandLineTestRunner runner(ac, av, &output, TestRegistry::getCurrentRegistry());
        failureCount = runner.runAllTestsMain();
    }

    if (failureCount == 0) {
        console.printf("PASSED\r\n");
    }
    ...
}

For more information, We’d recommend to read the manual or, even better, check some existing tests such as SimpleStringTest or (a bit more complicated) MemoryLeakDetectorTest or the mocking tests or just check out the Cheat Sheet.

Committer:
Rohit Grover
Date:
Thu Jun 19 08:24:31 2014 +0100
Revision:
2:82161d9e7b36
Parent:
1:4769360130ed
uncomment the code in CommandLineTestRunner::RunAllTests() having to do with MemoryLeakWarningPlugin

Bas Vodde, from the CppUTest development team has suggested an alternate way to run tests.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
rgrover1 0:0b799af9d58e 1 /*
rgrover1 0:0b799af9d58e 2 * Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
rgrover1 0:0b799af9d58e 3 * All rights reserved.
rgrover1 0:0b799af9d58e 4 *
rgrover1 0:0b799af9d58e 5 * Redistribution and use in source and binary forms, with or without
rgrover1 0:0b799af9d58e 6 * modification, are permitted provided that the following conditions are met:
rgrover1 0:0b799af9d58e 7 * * Redistributions of source code must retain the above copyright
rgrover1 0:0b799af9d58e 8 * notice, this list of conditions and the following disclaimer.
rgrover1 0:0b799af9d58e 9 * * Redistributions in binary form must reproduce the above copyright
rgrover1 0:0b799af9d58e 10 * notice, this list of conditions and the following disclaimer in the
rgrover1 0:0b799af9d58e 11 * documentation and/or other materials provided with the distribution.
rgrover1 0:0b799af9d58e 12 * * Neither the name of the <organization> nor the
rgrover1 0:0b799af9d58e 13 * names of its contributors may be used to endorse or promote products
rgrover1 0:0b799af9d58e 14 * derived from this software without specific prior written permission.
rgrover1 0:0b799af9d58e 15 *
rgrover1 0:0b799af9d58e 16 * THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ``AS IS'' AND ANY
rgrover1 0:0b799af9d58e 17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
rgrover1 0:0b799af9d58e 18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
rgrover1 0:0b799af9d58e 19 * DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
rgrover1 0:0b799af9d58e 20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
rgrover1 0:0b799af9d58e 21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
rgrover1 0:0b799af9d58e 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
rgrover1 0:0b799af9d58e 23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
rgrover1 0:0b799af9d58e 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
rgrover1 0:0b799af9d58e 25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
rgrover1 0:0b799af9d58e 26 */
rgrover1 0:0b799af9d58e 27
rgrover1 0:0b799af9d58e 28 ///////////////////////////////////////////////////////////////////////////////
rgrover1 0:0b799af9d58e 29 //
rgrover1 0:0b799af9d58e 30 // SIMPLESTRING.H
rgrover1 0:0b799af9d58e 31 //
rgrover1 0:0b799af9d58e 32 // One of the design goals of CppUnitLite is to compilation with very old C++
rgrover1 0:0b799af9d58e 33 // compilers. For that reason, the simple string class that provides
rgrover1 0:0b799af9d58e 34 // only the operations needed in CppUnitLite.
rgrover1 0:0b799af9d58e 35 //
rgrover1 0:0b799af9d58e 36 ///////////////////////////////////////////////////////////////////////////////
rgrover1 0:0b799af9d58e 37
rgrover1 0:0b799af9d58e 38 #ifndef D_SimpleString_h
rgrover1 0:0b799af9d58e 39 #define D_SimpleString_h
rgrover1 0:0b799af9d58e 40
rgrover1 0:0b799af9d58e 41 #include "StandardCLibrary.h"
rgrover1 0:0b799af9d58e 42
rgrover1 0:0b799af9d58e 43 class SimpleStringCollection;
rgrover1 0:0b799af9d58e 44 class TestMemoryAllocator;
rgrover1 0:0b799af9d58e 45
rgrover1 0:0b799af9d58e 46 class SimpleString
rgrover1 0:0b799af9d58e 47 {
rgrover1 0:0b799af9d58e 48 friend bool operator==(const SimpleString& left, const SimpleString& right);
rgrover1 0:0b799af9d58e 49 friend bool operator!=(const SimpleString& left, const SimpleString& right);
rgrover1 0:0b799af9d58e 50
rgrover1 0:0b799af9d58e 51 public:
rgrover1 0:0b799af9d58e 52 SimpleString(const char *value = "");
rgrover1 0:0b799af9d58e 53 SimpleString(const char *value, size_t repeatCount);
rgrover1 0:0b799af9d58e 54 SimpleString(const SimpleString& other);
rgrover1 0:0b799af9d58e 55 ~SimpleString();
rgrover1 0:0b799af9d58e 56
rgrover1 0:0b799af9d58e 57 SimpleString& operator=(const SimpleString& other);
rgrover1 0:0b799af9d58e 58 SimpleString operator+(const SimpleString&);
rgrover1 0:0b799af9d58e 59 SimpleString& operator+=(const SimpleString&);
rgrover1 0:0b799af9d58e 60 SimpleString& operator+=(const char*);
rgrover1 0:0b799af9d58e 61
rgrover1 0:0b799af9d58e 62 char at(int pos) const;
rgrover1 0:0b799af9d58e 63 int find(char ch) const;
rgrover1 0:0b799af9d58e 64 int findFrom(size_t starting_position, char ch) const;
rgrover1 0:0b799af9d58e 65 bool contains(const SimpleString& other) const;
rgrover1 0:0b799af9d58e 66 bool containsNoCase(const SimpleString& other) const;
rgrover1 0:0b799af9d58e 67 bool startsWith(const SimpleString& other) const;
rgrover1 0:0b799af9d58e 68 bool endsWith(const SimpleString& other) const;
rgrover1 0:0b799af9d58e 69 void split(const SimpleString& split,
rgrover1 0:0b799af9d58e 70 SimpleStringCollection& outCollection) const;
rgrover1 0:0b799af9d58e 71 bool equalsNoCase(const SimpleString& str) const;
rgrover1 0:0b799af9d58e 72
rgrover1 0:0b799af9d58e 73 size_t count(const SimpleString& str) const;
rgrover1 0:0b799af9d58e 74
rgrover1 0:0b799af9d58e 75 void replace(char to, char with);
rgrover1 0:0b799af9d58e 76 void replace(const char* to, const char* with);
rgrover1 0:0b799af9d58e 77
rgrover1 0:0b799af9d58e 78 SimpleString toLower() const;
rgrover1 0:0b799af9d58e 79 SimpleString subString(size_t beginPos, size_t amount) const;
rgrover1 0:0b799af9d58e 80 SimpleString subStringFromTill(char startChar, char lastExcludedChar) const;
rgrover1 0:0b799af9d58e 81 void copyToBuffer(char* buffer, size_t bufferSize) const;
rgrover1 0:0b799af9d58e 82
rgrover1 0:0b799af9d58e 83 const char *asCharString() const;
rgrover1 0:0b799af9d58e 84 size_t size() const;
rgrover1 0:0b799af9d58e 85 bool isEmpty() const;
rgrover1 0:0b799af9d58e 86
rgrover1 0:0b799af9d58e 87 static void padStringsToSameLength(SimpleString& str1, SimpleString& str2, char ch);
rgrover1 0:0b799af9d58e 88
rgrover1 0:0b799af9d58e 89 static TestMemoryAllocator* getStringAllocator();
rgrover1 0:0b799af9d58e 90 static void setStringAllocator(TestMemoryAllocator* allocator);
rgrover1 0:0b799af9d58e 91
rgrover1 0:0b799af9d58e 92 static char* allocStringBuffer(size_t size);
Rohit Grover 1:4769360130ed 93 static char* StrNCpy(char* s1, const char* s2, size_t n);
rgrover1 0:0b799af9d58e 94 static void deallocStringBuffer(char* str);
rgrover1 0:0b799af9d58e 95 private:
rgrover1 0:0b799af9d58e 96 char *buffer_;
rgrover1 0:0b799af9d58e 97
rgrover1 0:0b799af9d58e 98 static TestMemoryAllocator* stringAllocator_;
rgrover1 0:0b799af9d58e 99
Rohit Grover 1:4769360130ed 100 char* getEmptyString() const;
Rohit Grover 1:4769360130ed 101 static char* copyToNewBuffer(const char* bufferToCopy, size_t bufferSize=0);
rgrover1 0:0b799af9d58e 102 };
rgrover1 0:0b799af9d58e 103
rgrover1 0:0b799af9d58e 104 class SimpleStringCollection
rgrover1 0:0b799af9d58e 105 {
rgrover1 0:0b799af9d58e 106 public:
rgrover1 0:0b799af9d58e 107 SimpleStringCollection();
rgrover1 0:0b799af9d58e 108 ~SimpleStringCollection();
rgrover1 0:0b799af9d58e 109
rgrover1 0:0b799af9d58e 110 void allocate(size_t size);
rgrover1 0:0b799af9d58e 111
rgrover1 0:0b799af9d58e 112 size_t size() const;
rgrover1 0:0b799af9d58e 113 SimpleString& operator[](size_t index);
rgrover1 0:0b799af9d58e 114
rgrover1 0:0b799af9d58e 115 private:
rgrover1 0:0b799af9d58e 116 SimpleString* collection_;
rgrover1 0:0b799af9d58e 117 SimpleString empty_;
rgrover1 0:0b799af9d58e 118 size_t size_;
rgrover1 0:0b799af9d58e 119
rgrover1 0:0b799af9d58e 120 void operator =(SimpleStringCollection&);
rgrover1 0:0b799af9d58e 121 SimpleStringCollection(SimpleStringCollection&);
rgrover1 0:0b799af9d58e 122 };
rgrover1 0:0b799af9d58e 123
rgrover1 0:0b799af9d58e 124 SimpleString StringFrom(bool value);
rgrover1 0:0b799af9d58e 125 SimpleString StringFrom(const void* value);
rgrover1 0:0b799af9d58e 126 SimpleString StringFrom(char value);
rgrover1 0:0b799af9d58e 127 SimpleString StringFrom(const char *value);
rgrover1 0:0b799af9d58e 128 SimpleString StringFromOrNull(const char * value);
Rohit Grover 1:4769360130ed 129 SimpleString StringFrom(int value);
Rohit Grover 1:4769360130ed 130 SimpleString StringFrom(unsigned int value);
rgrover1 0:0b799af9d58e 131 SimpleString StringFrom(long value);
Rohit Grover 1:4769360130ed 132 SimpleString StringFrom(unsigned long value);
rgrover1 0:0b799af9d58e 133 SimpleString HexStringFrom(long value);
Rohit Grover 1:4769360130ed 134 SimpleString HexStringFrom(unsigned long value);
rgrover1 0:0b799af9d58e 135 SimpleString HexStringFrom(const void* value);
rgrover1 0:0b799af9d58e 136 SimpleString StringFrom(double value, int precision = 6);
rgrover1 0:0b799af9d58e 137 SimpleString StringFrom(const SimpleString& other);
rgrover1 0:0b799af9d58e 138 SimpleString StringFromFormat(const char* format, ...) __check_format__(printf, 1, 2);
rgrover1 0:0b799af9d58e 139 SimpleString VStringFromFormat(const char* format, va_list args);
rgrover1 0:0b799af9d58e 140
rgrover1 0:0b799af9d58e 141 #if CPPUTEST_USE_STD_CPP_LIB
rgrover1 0:0b799af9d58e 142
rgrover1 0:0b799af9d58e 143 #include <string>
rgrover1 0:0b799af9d58e 144 #include <stdint.h>
rgrover1 0:0b799af9d58e 145
rgrover1 0:0b799af9d58e 146 SimpleString StringFrom(const std::string& other);
rgrover1 0:0b799af9d58e 147
rgrover1 0:0b799af9d58e 148 #endif
rgrover1 0:0b799af9d58e 149
rgrover1 0:0b799af9d58e 150 #endif