Refactor put_n_bits()

lib/cmp_icu_new.c

+/**
+ * @file   icu_cmp.c
+ * @author Dominik Loidolt (dominik.loidolt@univie.ac.at),
+ * @date   2020
+ *
+ * @copyright GPLv2
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * @brief software compression library
+ * @see Data Compression User Manual PLATO-UVIE-PL-UM-0001
+ */
+
+
+#include <stdint.h>
+
+#include "cmp_debug.h"
+
+
+/* return code if the bitstream buffer is too small to store the whole bitstream */
+#define CMP_ERROR_SAMLL_BUF -2
+
+
+/**
+ * @brief put the value of up to 32 bits into a bitstream accessed as 32-bit
+ *	RAM in big-endian
+ *
+ * @param value		the value to put
+ * @param n_bits	number of bits to put in the bitstream
+ * @param bit_offset	bit index where the bits will be put, seen from the very
+ *			beginning of the bitstream
+ * @param bitstream_adr	this is the pointer to the beginning of the bitstream
+ *			(can be NULL)
+ * @param max_bit_len	maximum length of the bitstream in bits; is ignored if
+ *			bitstream_adr is NULL
+ *
+ * @returns length in bits of the generated bitstream on success; returns
+ *          negative in case of erroneous input; returns CMP_ERROR_SAMLL_BUF if
+ *          the bitstream buffer is too small to put the value in the bitstream
+ * @note a value with more bits set as the n_bits parameter is considered as an
+ *	erroneous input.
+ */
+
+static int put_n_bits32(uint32_t value, unsigned int n_bits, int bit_offset,
+			uint32_t *bitstream_adr, unsigned int max_bit_len)
+{
+	uint32_t *local_adr;
+	uint32_t mask;
+	unsigned int shiftRight, shiftLeft, bitsLeft, bitsRight;
+	int stream_len = (int)(n_bits + (unsigned int)bit_offset); /* overflow results in a negative return value */
+
+	/* leave in case of erroneous input */
+	if (bit_offset < 0)
+		return -1;
+
+	if (n_bits == 0)
+		return 0;
+
+	if (n_bits > 32)
+		return -1;
+
+	/* (M) is the n_bits parameter large enough to cover all value bits; the
+	 * calculations can be re-used in the unsegmented code, so we have no overhead
+	 */
+	shiftRight = 32 - n_bits;
+	mask = 0xFFFFFFFFU >> shiftRight;
+	if (value & ~mask) {
+		debug_print("Error: Not all set bits in the put value are added to the bitstream. Check value n_bits parameter combination.\n");
+		return -1;
+	}
+
+	/* Do we need to write data to the bitstream? */
+	if (!bitstream_adr)
+		return stream_len;
+
+	/* Check if bitstream buffer is large enough */
+	if ((unsigned int)stream_len > max_bit_len) {
+		debug_print("Error: The buffer for the compressed data is too small to hold the compressed data. Try a larger buffer_length parameter.\n");
+		return CMP_ERROR_SAMLL_BUF;
+	}
+
+	/* Separate the bit_offset into word offset (set local_adr pointer) and local bit offset (bitsLeft) */
+	local_adr = bitstream_adr + (bit_offset >> 5);
+	bitsLeft = bit_offset & 0x1F;
+
+	/* Calculate the bitsRight for the unsegmented case. If bitsRight is
+	 * negative we need to split the value over two words
+	 */
+	bitsRight = shiftRight - bitsLeft;
+
+	if ((int)bitsRight >= 0) {
+		/*         UNSEGMENTED
+		 *
+		 *|-----------|XXXXX|----------------|
+		 *   bitsLeft    n       bitsRight
+		 *
+		 *  -> to get the mask:
+		 *  shiftRight = bitsLeft + bitsRight = 32 - n
+		 *  shiftLeft = bitsRight = 32 - n - bitsLeft = shiftRight - bitsLeft
+		 */
+
+		shiftLeft = bitsRight;
+
+		/* generate the mask, the bits for the values will be true
+		 * shiftRight = 32 - n_bits; see (M) above!
+		 * mask = (0XFFFFFFFF >> shiftRight) << shiftLeft; see (M) above!
+		 */
+		mask <<= shiftLeft;
+		value <<= shiftLeft;
+
+		/* clear the destination with inverse mask */
+		*(local_adr) &= ~mask;
+
+		/* assign the value */
+		*(local_adr) |= value;
+
+	} else {
+		/*                             SEGMENTED
+		 *
+		 *|-----------------------------|XXX| |XX|------------------------------|
+		 *          bitsLeft              n1   n2          bitsRight
+		 *
+		 *  -> to get the mask part 1:
+		 *  shiftRight = bitsLeft
+		 *  n1 = n - (bitsLeft + n - 32) = 32 - bitsLeft
+		 *
+		 *  -> to get the mask part 2:
+		 *  n2 = bitsLeft + n - 32 = -(32 - n - bitsLeft) = -(bitsRight_UNSEGMENTED)
+		 *  shiftLeft = 32 - n2 = 32 - (bitsLeft + n - 32) = 64 - bitsLeft - n
+		 *
+		 */
+
+		unsigned int n2 = -bitsRight;
+
+		/* part 1: */
+		shiftRight = bitsLeft;
+		mask = 0XFFFFFFFFU >> shiftRight;
+
+		/* clear the destination with inverse mask */
+		*(local_adr) &= ~mask;
+
+		/* assign the value part 1 */
+		*(local_adr) |= (value >> n2);
+
+		/* part 2: */
+		/* adjust address */
+		local_adr += 1;
+		shiftLeft = 32 - n2;
+		mask = 0XFFFFFFFFU << shiftLeft;
+
+		/* clear the destination with inverse mask */
+		*(local_adr) &= ~mask;
+
+		/* assign the value part 2 */
+		*(local_adr) |= (value << shiftLeft);
+	}
+	return stream_len;
+}
+

subprojects/unity.wrap

+[wrap-file]
+directory = Unity-2.5.2
+source_url = https://github.com/ThrowTheSwitch/Unity/archive/refs/tags/v2.5.2.tar.gz
+source_filename = Unity-2.5.2.tar.gz
+source_hash = 3786de6c8f389be3894feae4f7d8680a02e70ed4dbcce36109c8f8646da2671a
+
+[provide]
+unity = unity_dep

test/cmp_icu/test_cmp_icu_new.c

+#include <string.h>
+
+#include "unity.h"
+
+/* this is a hack to test static functions */
+#include "../lib/cmp_icu_new.c"
+
+
+
+/**
+ * @test put_n_bits32
+ */
+
+#define SDP_PB_N 3
+
+
+static void init_PB32_arrays(uint32_t *z, uint32_t *o)
+{
+	uint32_t i;
+
+	/* init testarray with all 0 and all 1 */
+	for (i = 0; i < SDP_PB_N; i++) {
+		z[i] = 0;
+		o[i] = 0xffffffff;
+	}
+}
+
+
+void test_put_n_bits32(void)
+{
+	uint32_t v, n;
+	int o, rval; /* return value */
+	uint32_t testarray0[SDP_PB_N];
+	uint32_t testarray1[SDP_PB_N];
+	const uint32_t l = sizeof(testarray0) * CHAR_BIT;
+
+	/* hereafter, the value is v,
+	 * the number of bits to write is n,
+	 * the offset of the bit is o,
+	 * the max length the bitstream in bits is l
+	 */
+
+	init_PB32_arrays(testarray0, testarray1);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+
+	/*** n=0 ***/
+
+	/* do not write, left border */
+	v = 0; n = 0; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(0, rval);
+	TEST_ASSERT(testarray0[0] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(0, rval);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+
+	/* TODO: not a valid test */
+	v = 0xffffffff; n = 0; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(0, rval);
+	TEST_ASSERT(testarray0[0] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(0, rval);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+
+	/* do not write, right border */
+	v = 0; n = 0; o = 31;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(0, rval);
+	TEST_ASSERT(testarray0[0] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(0, rval);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+
+	/* TODO: not a valid test */
+	/* test value = 0xffffffff; N = 0 */
+	v = 0xffffffff; n = 0; o = 31;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(0, rval);
+	TEST_ASSERT(testarray0[0] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(0, rval);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+
+	/*** n=1 ***/
+
+	/* left border, write 0 */
+	v = 0; n = 1; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(1, rval);
+	TEST_ASSERT(testarray0[0] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(1, rval);
+	TEST_ASSERT(testarray1[0] == 0x7fffffff);
+
+	/* left border, write 1 */
+	v = 1; n = 1; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(1, rval);
+	TEST_ASSERT(testarray0[0] == 0x80000000);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(1, rval);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+
+	/* left border, write 32 */
+	v = 0xf0f0abcd; n = 32; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 32);
+	TEST_ASSERT(testarray0[0] == 0xf0f0abcd);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 32);
+	TEST_ASSERT(testarray1[0] == 0xf0f0abcd);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* middle, write 2 bits */
+	v = 3; n = 2; o = 29;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 31);
+	TEST_ASSERT(testarray0[0] == 0x6);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	TEST_ASSERT_EQUAL_INT(rval, 31);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/*** n=5, unsegmented ***/
+
+	/* left border, write 0 */
+	v = 0; n = 5; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 5);
+	TEST_ASSERT(testarray0[0] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT(testarray1[0] == 0x07ffffff);
+	TEST_ASSERT_EQUAL_INT(rval, 5);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* left border, write 11111 */
+	v = 0x1f; n = 5; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 5);
+	TEST_ASSERT(testarray0[0] == 0xf8000000);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 5);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* middle, write 0 */
+	v = 0; n = 5; o = 7;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 12);
+	TEST_ASSERT(testarray0[0] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 12);
+	TEST_ASSERT(testarray1[0] == 0xfe0fffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* middle, write 11111 */
+	v = 0x1f; n = 5; o = 7;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 12);
+	TEST_ASSERT(testarray0[0] == 0x01f00000);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 12);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* right, write 0 */
+	v = 0; n = 5; o = 91;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 96);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray0[1] == 0);
+	TEST_ASSERT(testarray0[0] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 96);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	TEST_ASSERT(testarray1[1] == 0xffffffff);
+	TEST_ASSERT(testarray1[2] == 0xffffffe0);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* right, write 11111 */
+	v = 0x1f; n = 5; o = 91;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 96);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray0[1] == 0);
+	TEST_ASSERT(testarray0[2] == 0x0000001f);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 96);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	TEST_ASSERT(testarray1[1] == 0xffffffff);
+	TEST_ASSERT(testarray1[2] == 0xffffffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* 32 bit, write 0 */
+	v = 0; n = 32; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 32);
+	TEST_ASSERT(testarray0[0] == 0x00000000);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 32);
+	TEST_ASSERT(testarray1[0] == 0x00000000);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* 32 bit, write -1 */
+	v = 0xffffffff; n = 32; o = 0;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 32);
+	TEST_ASSERT(testarray0[0] == 0xffffffff);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 32);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* SEGMENTED cases */
+	/* 5 bit, write 0 */
+	v = 0; n = 5; o = 62;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 67);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray0[1] == 0);
+	TEST_ASSERT(testarray0[2] == 0);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 67);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	TEST_ASSERT(testarray1[1] == 0xfffffffc);
+	TEST_ASSERT(testarray1[2] == 0x1fffffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* 5 bit, write 1f */
+	v = 0x1f; n = 5; o = 62;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 67);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray0[1] == 3);
+	TEST_ASSERT(testarray0[2] == 0xe0000000);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 67);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	TEST_ASSERT(testarray1[1] == 0xffffffff);
+	TEST_ASSERT(testarray1[2] == 0xffffffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* 32 bit, write 0 */
+	v = 0; n = 32; o = 1;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 33);
+	TEST_ASSERT(testarray0[0] == 0x00000000);
+	TEST_ASSERT(testarray0[1] == 0x00000000);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 33);
+	TEST_ASSERT(testarray1[0] == 0x80000000);
+	TEST_ASSERT(testarray1[1] == 0x7fffffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* 32 bit, write -1 */
+	v = 0xffffffff; n = 32; o = 1;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, 33);
+	TEST_ASSERT(testarray0[0] == 0x7fffffff);
+	TEST_ASSERT(testarray0[1] == 0x80000000);
+
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(rval, 33);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	TEST_ASSERT(testarray1[1] == 0xffffffff);
+	/* re-init input arrays after clobbering */
+	init_PB32_arrays(testarray0, testarray1);
+
+	/* test NULL buffer */
+	v = 0; n = 0; o = 0;
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT_EQUAL_INT(rval, 0);
+
+	v = 0; n = 1; o = 0;
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT_EQUAL_INT(rval, 1);
+
+	v = 0; n = 5; o = 31;
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT_EQUAL_INT(rval, 36);
+
+	v = 0; n = 2; o = 95;
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT_EQUAL_INT(rval, 97); /* rval can be longer than l */
+
+	/* error cases */
+	/* n too large */
+	v = 0x0; n = 33; o = 1;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(rval, -1);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray0[1] == 0);
+
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT_EQUAL_INT(rval, -1);
+
+	/* value larger than n allows */
+	v = 0x7f; n = 6; o = 10;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(-1, rval);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray0[1] == 0);
+
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT_EQUAL_INT(-1, rval);
+
+	/* try to put too much in the bitstream */
+	v = 0x1; n = 1; o = 96;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(CMP_ERROR_SAMLL_BUF, rval);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray0[1] == 0);
+	TEST_ASSERT(testarray0[2] == 0);
+
+	/* this should work */
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT_EQUAL_INT(97, rval);
+
+	/* offset lager than max_bit_len */
+	v = 0x0; n = 32; o = INT32_MAX;
+	rval = put_n_bits32(v, n, o, testarray1, l);
+	TEST_ASSERT_EQUAL_INT(CMP_ERROR_SAMLL_BUF, rval);
+	TEST_ASSERT(testarray1[0] == 0xffffffff);
+	TEST_ASSERT(testarray1[1] == 0xffffffff);
+	TEST_ASSERT(testarray1[2] == 0xffffffff);
+
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT(rval < 0);
+
+	/* negative offset */
+	v = 0x0; n = 0; o = -1;
+	rval = put_n_bits32(v, n, o, testarray0, l);
+	TEST_ASSERT_EQUAL_INT(-1, rval);
+	TEST_ASSERT(testarray0[0] == 0);
+	TEST_ASSERT(testarray0[1] == 0);
+
+	rval = put_n_bits32(v, n, o, NULL, l);
+	TEST_ASSERT_EQUAL_INT(-1, rval);
+}

test/tools/meson.build

+generate_test_runner = find_program('generate_test_runner.rb')
+test_runner_generator = generator(
+  generate_test_runner,
+  output: ['@BASENAME@_Runner.c'],
+  arguments: ['@INPUT@', '@OUTPUT@']
+)

test/tools/run_test.erb

+/*=======Test Runner Used To Run Each Test=====*/
+static void run_test(UnityTestFunction func, const char* name, UNITY_LINE_TYPE line_num)
+{
+    Unity.CurrentTestName = name;
+    Unity.CurrentTestLineNumber = line_num;
+#ifdef UNITY_USE_COMMAND_LINE_ARGS
+    if (!UnityTestMatches())
+        return;
+#endif
+    Unity.NumberOfTests++;
+    UNITY_CLR_DETAILS();
+    UNITY_EXEC_TIME_START();
+    CMock_Init();
+    if (TEST_PROTECT())
+    {
+<% if @options[:plugins].include?(:cexception) %>
+        CEXCEPTION_T e;
+        Try {
+            <%= @options[:setup_name] %>();
+            func();
+        } Catch(e) {
+            TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!");
+        }
+<% else %>
+        <%= @options[:setup_name] %>();
+        func();
+<% end %>
+    }
+    if (TEST_PROTECT())
+    {
+        <%= @options[:teardown_name] %>();
+        CMock_Verify();
+    }
+    CMock_Destroy();
+    UNITY_EXEC_TIME_STOP();
+    UnityConcludeTest();
+}

test/tools/type_sanitizer.rb

+module TypeSanitizer
+  def self.sanitize_c_identifier(unsanitized)
+    # convert filename to valid C identifier by replacing invalid chars with '_'
+    unsanitized.gsub(/[-\/\\\.\,\s]/, '_')
+  end
+end