Merge pull request #22 from devMichaelJones/master

Wiki changes

Author: basvodde

index.markdown

@@ -85,7 +85,7 @@ For Windows users, the above work with cygwin. There are also several MS VC++ pr
 
 ## Where to find more information
 
-* If you have any question, check out the [Google Groups](https://groups.google.com/forum/?fromgroups#!forum/cpputest)
+* If you have any questions, check out the [Google Groups](https://groups.google.com/forum/?fromgroups#!forum/cpputest)
 * The source is at the [main github page](https://github.com/cpputest/cpputest)
 * You can report bugs or features at [the issues page](https://github.com/cpputest/cpputest/issues)
 * You can follow [CppUTest on twitter](https://twitter.com/CppUTest)
@@ -127,7 +127,7 @@ int main(int ac, char** av)
 }
 {% endhighlight %}
 
-For more information, We'd recommend to [read the manual](http://www.cpputest.org) or, even better, check some [existing tests](https://github.com/cpputest/cpputest/tree/master/tests) such as [SimpleStringTest](https://github.com/cpputest/cpputest/blob/master/tests/SimpleStringTest.cpp) or (a bit more complicated) [MemoryLeakDetectorTest](https://github.com/cpputest/cpputest/blob/master/tests/MemoryLeakDetectorTest.cpp) or the [mocking tests](https://github.com/cpputest/cpputest/blob/master/tests/CppUTestExt/TestMockSupport.cpp) or just check out the [Cheat Sheet](https://github.com/cpputest/cpputest/blob/master/tests/CheatSheetTest.cpp)
+For more information, We'd recommend [reading the manual](http://www.cpputest.org) or, even better, check some [existing tests](https://github.com/cpputest/cpputest/tree/master/tests) such as [SimpleStringTest](https://github.com/cpputest/cpputest/blob/master/tests/SimpleStringTest.cpp) or (a bit more complicated) [MemoryLeakDetectorTest](https://github.com/cpputest/cpputest/blob/master/tests/MemoryLeakDetectorTest.cpp) or the [mocking tests](https://github.com/cpputest/cpputest/blob/master/tests/CppUTestExt/TestMockSupport.cpp) or just check out the [Cheat Sheet](https://github.com/cpputest/cpputest/blob/master/tests/CheatSheetTest.cpp)
 
 ## Related projects
 
@@ -141,4 +141,4 @@ Prerequisites:
 
 ## Authors and Contributors
 
-CppUTest has had many contributions from its users. We can't remember all, but we appreciate it a lot!. Much of the original code was written by Michael Feathers (based on CppUnit Lite). The current main maintainers are [@jwgrenning](https://github.com/jwgrenning) and [@basvodde](https://github.com/basvodde)
+CppUTest has had many contributions from its users. We can't remember all, but we appreciate it a lot! Much of the original code was written by Michael Feathers (based on CppUnit Lite). The current main maintainers are [@jwgrenning](https://github.com/jwgrenning) and [@basvodde](https://github.com/basvodde)

manual.markdown

@@ -34,6 +34,8 @@ CppUTest's core design principles
 
 To write your first test, all you need is a new cpp file with a TEST_GROUP and a TEST, like:
 {% highlight c++ %}
+#include "CppUTest/TestHarness.h"
+
 TEST_GROUP(FirstTestGroup)
 {
 };
@@ -60,6 +62,8 @@ One of the key design goals in CppUTest is to make it *very easy* to add and rem
 Of course, in order to get it to run, you'll need to create a main. Most of the mains in CppUTest are very similar. They typically are in an AllTests.cpp file and look like this:
 
 {% highlight c++ %}
+#include "CppUTest/CommandLineTestRunner.h"
+
 int main(int ac, char** av)
 {
     return CommandLineTestRunner::RunAllTests(ac, av);
@@ -107,7 +111,7 @@ You need to add CppUTest library to the linker flags, for example, like:
      LD_LIBRARIES = -L$(CPPUTEST_HOME)/lib -lCppUTest -lCppUTestExt
 {% endhighlight %}
 
-(The last flags is only needed when you want to use extensions such as mocking)
+(The last flag is only needed when you want to use extensions such as mocking)
 
 <a id="test_macros"> </a>
 
@@ -144,9 +148,9 @@ The failure of one of these macros causes the current test to immediately exit:
 
 <a id="setup_teardown"> </a>
 
-*CHECK_EQUALS Warning:*
+*CHECK_EQUAL Warning:*
 
-CHECK_EQUAL(expected, actual) can produce misleading error reports as it will evaluate expected and actual more than ones. THis especially leads to confusions when used with mocks. This happens if the mock function expects to be called exactly once, since the macro needs to evaluate the actual expression more than once. The problem does not occur with type specific checks (e.g. LONGS_EQUAL()), so it is recommended to use them if possible. Instead of:
+CHECK_EQUAL(expected, actual) can produce misleading error reports as it will evaluate expected and actual more than ones. This especially leads to confusions when used with mocks. This happens if the mock function expects to be called exactly once, since the macro needs to evaluate the actual expression more than once. The problem does not occur with type specific checks (e.g. LONGS_EQUAL()), so it is recommended to use them if possible. Instead of:
 
 {% highlight c++ %}
 CHECK_EQUAL(10, mock_returning_11())
@@ -266,7 +270,7 @@ These are added by default when you use the CppUTest Makefile helpers.
 
 ### Turning memory leak detection off and on
 
-If you want to disable the memory leak detection (because you got too much memory leaks?) then you can do so in several ways. However, it is strongly recommended to keep the memory leak detector on and fix your memory leaks (and your static initialization issues) as this tends to lead to higher quality code.
+If you want to disable the memory leak detection (because you have too many memory leaks?) then you can do so in several ways. However, it is strongly recommended to keep the memory leak detector on and fix your memory leaks (and your static initialization issues) as this tends to lead to higher quality code.
 
 You can turn the memory leak detection completely off by adding this to your main:
 
@@ -316,7 +320,7 @@ Now the call to the compiler needs to be -include MyOwnNewMacros.h and this will
 
 ### Conflicts with my own overload!
 
-This one is harder (and luckily less common). You can solve this the same way as the conflict in STL, but its probably better to use a finer grained control. So, instead you can temporary disable the new macros, overload operator new, enable the new macro again. This can be done with the following code:
+This one is harder (and luckily less common). You can solve this the same way as the conflict in STL, but it's probably better to use a finer grained control. So, instead you can temporary disable the new macros, overload operator new, enable the new macro again. This can be done with the following code:
 
 {% highlight c++ %}
 class NewDummyClass
@@ -608,7 +612,7 @@ The most important line to add is the GTestConvertor. Make sure you define the C
 
 ## Running Google Tests in CppUTest
 
-People feel wonderfully religious about unit testing tools. Of course, we feel strongly that CppUTest beats other tools when you actually test-drive your software. But unfortunately, people still use tools like GoogleTest (which is actually not as bad as e.g. CppUnit). It is unlikely that we're going to convince people to use CppUTest instead, so therefore we've written some integration code where you can actually link google test and CppUTest tests together in one binary (with the CppUTest test runner). THis also gives you some additional benefits:
+People feel wonderfully religious about unit testing tools. Of course, we feel strongly that CppUTest beats other tools when you actually test-drive your software. But unfortunately, people still use tools like GoogleTest (which is actually not as bad as e.g. CppUnit). It is unlikely that we're going to convince people to use CppUTest instead, so therefore we've written some integration code where you can actually link google test and CppUTest tests together in one binary (with the CppUTest test runner). This also gives you some additional benefits:
 
 * You get memory leak detection over your google tests...
 * You don't get the verbose gtest output

mocking_manual.markdown

@@ -3,7 +3,7 @@ layout: default
 title: CppUTest Mocking Manual
 ---
 
-CppUTest has support for building mocks. This document described the mocking support. A couple of design goals for the mocking support were:
+CppUTest has support for building mocks. This document describes the mocking support. A couple of design goals for the mocking support were:
 
 
 * Same design goals as CppuTest -- limited C++ set to make it well suitable for embedded soft.
@@ -67,7 +67,7 @@ The TEST(MockDocumentation, SimpleScenario) contains the recording of the expect
 mock().expectOneCall("productionCode");
 {% endhighlight %}
 
-The call to mock() return the global MockSupport (more about that later) on which we can record our expectations. In this example, we'll call expectOneCall("productionCode") which... records an expectation for *one* call to a function called productionCode.
+The call to mock() returns the global MockSupport (more about that later) on which we can record our expectations. In this example, we'll call expectOneCall("productionCode") which... records an expectation for *one* call to a function called productionCode.
 
 The productionCode call is to show a call to whatever your real code is. The test ends with checking whether the expectations have been met. This is done with the:
 
@@ -88,7 +88,7 @@ void productionCode()
 
 where we use MockSupport by calling mock() and then record the actual call to the productionCode function.
 
-This scenario is quite common when using linker stubbing of e.g. a 3rd partly library.
+This scenario is quite common when using linker stubbing of e.g. a 3rd party library.
 
 If the call to productionCode wouldn't happen, then the test would fail with the following error message:
 
@@ -155,7 +155,7 @@ If the call to a wrong object happens, it would give the following error message
 
 ### Parameters
 
-Of course, just checked whether a function is called is not particularly useful when we cannot check the parameters. Recording parameters on a function is done like this:
+Of course, just checking whether a function is called is not particularly useful when we cannot check the parameters. Recording parameters on a function is done like this:
 
 {% highlight c++ %}
 mock().expectOneCall("function").onObject(object).withParameter("p1", 2).withParameter("p2", "hah");
@@ -200,11 +200,11 @@ MyTypeComparator is a custom comparator, which implements the MockNamedValueComp
 class MyTypeComparator : public MockNamedValueComparator
 {
 public:
-    virtual bool isEqual(void* object1, void* object2)
+    virtual bool isEqual(const void* object1, const void* object2)
     {
         return object1 == object2;
     }
-    virtual SimpleString valueToString(void* object)
+    virtual SimpleString valueToString(cont void* object)
     {
         return StringFrom(object);
     }
@@ -219,7 +219,7 @@ To remove the comparators, all you needs to do is call removeAllComparators, lik
 mock().removeAllComparators();
 {% endhighlight %}
 
-Comparators sometimes lead to surprised, so a couple of warnings on its usage:
+Comparators sometimes lead to surprises, so a couple of warnings on its usage:
 
 *Warning 1:*
 
@@ -231,7 +231,7 @@ Comparators are *not* copied, instead it uses the exact instance as passed to th
 
 * Pay extra attention to scope when using the MockPlugin
 
-When using the MockPlugin (recommended), then its best to install the comparators via the MockPlugin or put them in global space. The checkExpectations will be called *after* teardown and if your comparator was destroyed in the teardown then this will cause a crash.
+When using the MockPlugin (recommended), then it's best to install the comparators via the MockPlugin or put them in global space. The checkExpectations will be called *after* teardown and if your comparator was destroyed in the teardown then this will cause a crash.
 
 <a id="output_parameters"> </a>
 
@@ -285,7 +285,7 @@ mock().expectOneCall("Foo").withOutputParameterReturning("bar", &doubleOutputVal
 
 *Warning 2:*
 
-* When an char, int, etc. array is passed to withOutputParameter, you must use the generic withOutputParameterReturning and provide the actual size of the array or only one element will be copied.
+* When a char, int, etc. array is passed to withOutputParameter, you must use the generic withOutputParameterReturning and provide the actual size of the array or only one element will be copied.
 
 <a id="return_values"> </a>
 
@@ -336,15 +336,15 @@ int value = mock().getData("importantValue").getIntValue();
 pobject = (ClassFromProductionCode*) mock().getData("importantObject").getObjectPointer();
 {% endhighlight %}
 
-Like return values. Setting data will not ever make a test fail but it provides support in building mock objects.
+Like return values, setting data will not ever make a test fail but it provides support in building mock objects.
 
 <a id="other_mock_support"> </a>
 
 ### Other MockSupport - ignoring, enabling, clearing, crashing
 
 MockSupport offers a couple of other useful functions, which will be covered in this section.
 
-Frequently, you only want to check a couple of calls in your test and ignore all the other calls. If you add expectOneCall for each of these calls, you're tests might become too large (though, it might be a smell that your test is indeed too large). One way to prevent this is the ignoreOtherCalls, like:
+Frequently, you only want to check a couple of calls in your test and ignore all the other calls. If you add expectOneCall for each of these calls, your tests might become too large (though, it might be a smell that your test is indeed too large). One way to prevent this is the ignoreOtherCalls, like:
 
 {% highlight c++ %}
 mock().expectOneCall("foo");
@@ -373,7 +373,7 @@ int function () {
 
 If you try to ignore it or disable the framework, it will explode. Why ? The return value is not defined so there is no way to define the return value of the mocked function.
 
-To cases like these there is a series of return value functions that allows you to define a default return value, that will be returned when the mock function is ignored.
+To cases like these there is a series of return value functions that allows you to define a default return value that will be returned when the mock function is ignored.
 
 The example above could be written as: