Diff: src/Platforms/mbed/UtestPlatform.cpp

Revision:

0:0b799af9d58e

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/Platforms/mbed/UtestPlatform.cpp	Tue Jan 28 09:27:41 2014 +0000
@@ -0,0 +1,312 @@
+/*
+ * 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);
+}