File content as of revision 0:0b799af9d58e:

/*
 * 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 <stdlib.h>
#include <setjmp.h>
#include <ctype.h>
#include "platform.h"

#include "mbed.h"
#include "Serial.h"
#include "error.h"

#include "CppUTest/TestHarness.h"

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

static jmp_buf test_exit_jmp_buf[10];
static int     jmp_buf_index = 0;

int
PlatformSpecificSetJmp(void (* function) (void* data), void* data)
{
    if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
        jmp_buf_index++;
        function(data);
        jmp_buf_index--;
        return (1);
    }
    return (0);
}

void
PlatformSpecificLongJmp()
{
    jmp_buf_index--;
    longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}

void
PlatformSpecificRestoreJumpBuffer()
{
    jmp_buf_index = 0;
    memset(test_exit_jmp_buf, 0, sizeof(test_exit_jmp_buf));
}

void
PlatformSpecificRunTestInASeperateProcess(UtestShell* shell,
                                          TestPlugin* plugin,
                                          TestResult* result)
{
    (void) shell;
    (void) plugin;
    (void) result;

    /* To be implemented */
    error("PlatformSpecificRunTestInASeperateProcess not implemented, but called");
}

long
GetPlatformSpecificTimeInMillis()
{
    /* To be implemented */
    return (0);
}

void
SetPlatformSpecificTimeInMillisMethod(long (* platformSpecific) ())
{
    (void) platformSpecific;

    /* To be implemented */
    error("SetPlatformSpecificTimeInMillisMethod not implemented, but called");
}

TestOutput::WorkingEnvironment
PlatformSpecificGetWorkingEnvironment()
{
    return (TestOutput::eclipse);
}

///////////// Time in String

const char*
GetPlatformSpecificTimeString()
{
    /* To be implemented */
    error("GetPlatformSpecificTimeString not implemented, but called");

    return (NULL);
}

void
SetPlatformSpecificTimeStringMethod(const char* (* platformMethod) ())
{
    (void) platformMethod;

    /* To be implemented */
    error("SetPlatformSpecificTimeStringMethod not implemented, but called");
}

int
PlatformSpecificAtoI(const char* str)
{
    return (atoi(str));
}

size_t
PlatformSpecificStrLen(const char* str)
{
    return (strlen(str));
}

char*
PlatformSpecificStrCat(char* s1, const char* s2)
{
    return (strcat(s1, s2));
}

char*
PlatformSpecificStrCpy(char* s1, const char* s2)
{
    return (strcpy(s1, s2));
}

char*
PlatformSpecificStrNCpy(char* s1, const char* s2, size_t size)
{
    return (strncpy(s1, s2, size));
}

int
PlatformSpecificStrCmp(const char* s1, const char* s2)
{
    return (strcmp(s1, s2));
}

int
PlatformSpecificStrNCmp(const char* s1, const char* s2, size_t size)
{
    return (strncmp(s1, s2, size));
}

char*
PlatformSpecificStrStr(const char* s1, const char* s2)
{
    return ((char*) strstr(s1, s2));
}

int
PlatformSpecificVSNprintf(char*       str,
                          size_t      size,
                          const char* format,
                          va_list     args)
{
    return (vsnprintf( str, size, format, args));
}

char
PlatformSpecificToLower(char c)
{
    return ((char) tolower((char) c));
}

PlatformSpecificFile
PlatformSpecificFOpen(const char* filename, const char* flag)
{
    (void) filename;
    (void) flag;

    /* To be implemented */
    error("PlatformSpecificFOpen not implemented, but called");

    return (NULL);
}

void
PlatformSpecificFPuts(const char* str, PlatformSpecificFile file)
{
    (void) str;
    (void) file;

    /* To be implemented */
    error("PlatformSpecificFPuts not implemented, but called");
}

void
PlatformSpecificFClose(PlatformSpecificFile file)
{
    (void) file;

    /* To be implemented */
    error("PlatformSpecificFClose not implemented, but called");
}

void
PlatformSpecificFlush()
{
}

int
PlatformSpecificPutchar(int c)
{
	/* Please modify this block for test results to be reported as
	 * console output. The following is a sample implementation using a
	 * Serial object connected to the console. */
#define NEED_TEST_REPORT_AS_CONSOLE_OUTPUT 1
#if NEED_TEST_REPORT_AS_CONSOLE_OUTPUT
    extern Serial console;

	#define NEED_LINE_FEED_IN_ADDITION_TO_NEWLINE 1
	#if NEED_LINE_FEED_IN_ADDITION_TO_NEWLINE
	/* CppUTest emits \n line terminators in its reports; some terminals
	 * need the linefeed (\r) in addition. */
	if (c == '\n') {
	    console.putc('\r');
	}
	#endif /* #if NEED_LINE_FEED_IN_ADDITION_TO_NEWLINE */

    return (console.putc(c));
#else /* NEED_TEST_REPORT_AS_CONSOLE_OUTPUT */
    return (0);
#endif /* NEED_TEST_REPORT_AS_CONSOLE_OUTPUT */
}

void*
PlatformSpecificMalloc(size_t size)
{
    return (malloc(size));
}

void*
PlatformSpecificRealloc (void* memory, size_t size)
{
    (void) memory;
    (void) size;

    /* To be implemented */
    error("PlatformSpecificRealloc not implemented, but called");
    return (NULL);
}

void
PlatformSpecificFree(void* memory)
{
    free(memory);
}

void*
PlatformSpecificMemCpy(void* s1, const void* s2, size_t size)
{
    (void) size;
    (void) s1;
    (void) s2;

    /* To be implemented */
    error("PlatformSpecificMemCpy not implemented, but called");

    return (NULL);
}

void*
PlatformSpecificMemset(void* mem, int c, size_t size)
{
    return (memset(mem, c, size));
}

double
PlatformSpecificFabs(double d)
{
    (void) d;

    /* To be implemented */
    error("PlatformSpecificFabs not implemented, but called");

    return (0.0);
}

int
PlatformSpecificIsNan(double d)
{
    (void) d;

    /* To be implemented */
    error("PlatformSpecificIsNan not implemented, but called");

    return (0);
}