Unit tests: Clean up DataType tests

Author: tstenner

testing/DataType.cpp

@@ -1,67 +1,39 @@
 #include "catch.hpp"
 #include "helpers.h"
+#include "helper_type.hpp"
 #include <cstdint>
 #include <lsl_cpp.h>
 
-
-namespace {
-template <typename T> void test_DataType(const char *name, lsl::channel_format_t cf) {
-	const int numBounces = sizeof(T) * 8;
+TEMPLATE_TEST_CASE("datatransfer", "[datatransfer][basic]", char, int16_t, int32_t, int64_t, float, double) {
+	const int numBounces = sizeof(TestType) * 8;
 	double timestamps[numBounces][2];
+	const char* name = SampleType<TestType>::fmt_string();
+	lsl::channel_format_t cf = (lsl::channel_format_t) SampleType<TestType>::chan_fmt;
 
 	Streampair sp(create_streampair(
-		lsl::stream_info(name, "Bounce", 1, lsl::IRREGULAR_RATE, cf, "streamid")));
+		lsl::stream_info(name, "Bounce", 2, lsl::IRREGULAR_RATE, cf, "streamid")));
 	lsl::stream_inlet &inlet = sp.in_;
 	lsl::stream_outlet &outlet = sp.out_;
 
 	inlet.open_stream(2);
 	outlet.wait_for_consumers(2);
 
-	T sent_data = 0x1;
+	TestType sent_data[2] = {0x1, 0x1};
 	for (int32_t counter = 0; counter < numBounces; counter++) {
-		T received_data;
+		TestType received_data[2];
 		timestamps[counter][0] = lsl::local_clock();
-		outlet.push_sample(&sent_data, timestamps[counter][0], true);
+		sent_data[1] = -sent_data[0] + 1;
+		outlet.push_sample(sent_data, timestamps[counter][0], true);
 
-		CHECK(inlet.pull_sample(&received_data, 1, .5) != 0.0);
+		CHECK(inlet.pull_sample(received_data, 2, .5) != 0.0);
 
 		timestamps[counter][1] = lsl::local_clock();
-		CHECK(received_data == sent_data);
-		sent_data = static_cast<T>(sent_data << 1);
-	}
-}
-
-TEST_CASE("data type int8", "[datatransfer][basic]") { test_DataType<char>("cf_int8", lsl::cf_int8); }
-TEST_CASE("data type int16", "[datatransfer][basic]") { test_DataType<int16_t>("cf_int16", lsl::cf_int16); }
-TEST_CASE("data type int32", "[datatransfer][basic]") { test_DataType<int32_t>("cf_int32", lsl::cf_int32); }
-TEST_CASE("data type int64", "[datatransfer][basic]") { test_DataType<int64_t>("cf_int64", lsl::cf_int64); }
-
-template <typename T> void test_DataTypeMulti(const char *name, lsl::channel_format_t cf) {
-	const int numChannels = sizeof(T) * 8;
-
-	Streampair sp(create_streampair(
-		lsl::stream_info(name, "Bounce", numChannels, lsl::IRREGULAR_RATE, cf, "streamid")));
-	lsl::stream_inlet &inlet = sp.in_;
-	lsl::stream_outlet &outlet = sp.out_;
-
-	std::vector<T> sent_data(numChannels);
-	T data = 0x1LL;
-	for (uint32_t counter = 0; counter < numChannels; counter++) {
-		sent_data[counter] = data;
-		data = static_cast<T>(data << 1LL);
+		CHECK(received_data[0] == sent_data[0]);
+		CHECK(received_data[1] == sent_data[1]);
+		sent_data[0] = static_cast<TestType>(static_cast<int64_t>(sent_data[0]) << 1);
 	}
-
-	std::vector<T> received_data(numChannels);
-	outlet.push_sample(sent_data, lsl::local_clock(), true);
-	CHECK(inlet.pull_sample(received_data, 0.5) != 0.0);
-	CHECK(received_data == sent_data);
 }
 
-TEST_CASE("data type int8 multi", "[datatransfer][multi]") { test_DataTypeMulti<char>("cf_int8", lsl::cf_int8); }
-TEST_CASE("data type int16 multi", "[datatransfer][multi]") { test_DataTypeMulti<int16_t>("cf_int16", lsl::cf_int16); }
-TEST_CASE("data type int32 multi", "[datatransfer][multi]") { test_DataTypeMulti<int32_t>("cf_int32", lsl::cf_int32); }
-TEST_CASE("data type int64 multi", "[datatransfer][multi]") { test_DataTypeMulti<int64_t>("cf_int64", lsl::cf_int64); }
-
 TEST_CASE("data datatransfer", "[datatransfer][multi][string]") {
 	const std::size_t numChannels = 2;
 
@@ -104,4 +76,3 @@ TEST_CASE("data typeconversion", "[datatransfer][types][basic]") {
 	}
 }
 
-} // namespace

testing/helper_type.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include "../include/lsl/common.h"
+#include <string>
+
+template <typename T> struct SampleType {
+	static const lsl_channel_format_t chan_fmt = cft_undefined;
+	static const char *fmt_string();
+};
+
+template <> struct SampleType<char> {
+	static const lsl_channel_format_t chan_fmt = cft_int8;
+	static const char *fmt_string() { return "cf_int8"; }
+};
+
+template <> struct SampleType<int16_t> {
+	static const lsl_channel_format_t chan_fmt = cft_int16;
+	static const char *fmt_string() { return "cf_int16"; }
+};
+
+template <> struct SampleType<int32_t> {
+	static const lsl_channel_format_t chan_fmt = cft_int32;
+	static const char *fmt_string() { return "cf_int32"; }
+};
+
+template <> struct SampleType<int64_t> {
+	static const lsl_channel_format_t chan_fmt = cft_int64;
+	static const char *fmt_string() { return "cf_int64"; }
+};
+
+template <> struct SampleType<float> {
+	static const lsl_channel_format_t chan_fmt = cft_float32;
+	static const char *fmt_string() { return "cf_float32"; }
+};
+
+template <> struct SampleType<double> {
+	static const lsl_channel_format_t chan_fmt = cft_double64;
+	static const char *fmt_string() { return "cf_double64"; }
+};
+
+template <> struct SampleType<std::string> {
+	static const lsl_channel_format_t chan_fmt = cft_string;
+	static const char *fmt_string() { return "cf_string"; }
+};