/*
 * Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ``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 <copyright holder> 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.
 */


#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockSupport.h"
#include "CppUTestExt/MockSupport_c.h"

TEST_GROUP(FirstTestGroup)
{
};

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

TEST(FirstTestGroup, SecondTest)
{
//	STRCMP_EQUAL("hello", "world");
}


TEST_GROUP(MockDocumentation)
{
};

static void productionCode()
{
    mock().actualCall("productionCode");
}

TEST(MockDocumentation, SimpleScenario)
{
    mock().expectOneCall("productionCode");
    productionCode();
    mock().checkExpectations();
}

class ClassFromProductionCode
{
public:
    virtual void importantFunction(){}
    virtual ~ClassFromProductionCode() {}
};

class ClassFromProductionCodeMock : public ClassFromProductionCode
{
public:
    virtual void importantFunction()
    {
        mock().actualCall("importantFunction").onObject(this);
    }
};

TEST(MockDocumentation, SimpleScenarioObject)
{
    ClassFromProductionCode* object = new ClassFromProductionCodeMock; /* create mock instead of real thing */

    mock().expectOneCall("importantFunction").onObject(object);
    object->importantFunction();
    mock().checkExpectations();

    delete object;
}

static void parameters_function(int p1, const char* p2)
{
    void* object = (void*) 1;
    mock().actualCall("function").onObject(object).withParameter("p1", p1).withParameter("p2", p2);
}

TEST(MockDocumentation, parameters)
{
    void* object = (void*) 1;
    mock().expectOneCall("function").onObject(object).withParameter("p1", 2).withParameter("p2", "hah");
    parameters_function(2, "hah");
}

class MyTypeComparator : public MockNamedValueComparator
{
public:
    virtual bool isEqual(const void* object1, const void* object2)
    {
        return object1 == object2;
    }
    virtual SimpleString valueToString(const void* object)
    {
        return StringFrom(object);
    }
};

TEST(MockDocumentation, ObjectParameters)
{
    void* object = (void*) 1;
    MyTypeComparator comparator;
    mock().installComparator("myType", comparator);
    mock().expectOneCall("function").withParameterOfType("myType", "parameterName", object);
    mock().clear();
    mock().removeAllComparatorsAndCopiers();
}

TEST(MockDocumentation, returnValue)
{
    mock().expectOneCall("function").andReturnValue(10);
    int value = mock().actualCall("function").returnValue().getIntValue();
    value = mock().returnValue().getIntValue();
    LONGS_EQUAL(10, value);
}

TEST(MockDocumentation, setData)
{
    ClassFromProductionCode object;
    mock().setData("importantValue", 10);
    mock().setDataObject("importantObject", "ClassFromProductionCode", &object);

    ClassFromProductionCode * pobject;
    int value = mock().getData("importantValue").getIntValue();
    pobject = (ClassFromProductionCode*) mock().getData("importantObject").getObjectPointer();

    LONGS_EQUAL(10, value);
    POINTERS_EQUAL(pobject, &object);
}

static void doSomethingThatWouldOtherwiseBlowUpTheMockingFramework()
{
}

TEST(MockDocumentation, otherMockSupport)
{
    mock().crashOnFailure();
//	mock().actualCall("unex");

    mock().expectOneCall("foo");
    mock().ignoreOtherCalls();

    mock().disable();
    doSomethingThatWouldOtherwiseBlowUpTheMockingFramework();
    mock().enable();

    mock().clear();

}

TEST(MockDocumentation, scope)
{
    mock("xmlparser").expectOneCall("open");
    mock("filesystem").ignoreOtherCalls();

    mock("xmlparser").actualCall("open");
}

static  int equalMethod(const void* object1, const void* object2)
{
    return object1 == object2;
}

static const char* toStringMethod(const void*)
{
    return "string";
}

TEST(MockDocumentation, CInterface)
{
    void* object = (void*) 0x1;

    mock_c()->expectOneCall("foo")->withIntParameters("integer", 10)->andReturnDoubleValue(1.11);
    double d = mock_c()->actualCall("foo")->withIntParameters("integer", 10)->returnValue().value.doubleValue;
    DOUBLES_EQUAL(1.11, d, 0.00001);


    mock_c()->installComparator("type", equalMethod, toStringMethod);
    mock_scope_c("scope")->expectOneCall("bar")->withParameterOfType("type", "name", object);
    mock_scope_c("scope")->actualCall("bar")->withParameterOfType("type", "name", object);
    mock_c()->removeAllComparatorsAndCopiers();

    mock_c()->setIntData("important", 10);
    mock_c()->checkExpectations();
    mock_c()->clear();
}

TEST_GROUP(FooTestGroup)
{
    void setup()
    {
        // Init stuff
    }

    void teardown()
    {
        // Uninit stuff
    }
};

TEST(FooTestGroup, Foo)
{
    // Test FOO
}

TEST(FooTestGroup, MoreFoo)
{
    // Test more FOO
}

TEST_GROUP(BarTestGroup)
{
    void setup()
    {
        // Init Bar
    }
};

TEST(BarTestGroup, Bar)
{
    // Test Bar
}
