added some basic tests

Author: ZERICO2005

test/standalone/cxx_stl/autotest.json

@@ -0,0 +1,40 @@
+{
+  "transfer_files": [
+    "bin/DEMO.8xp"
+  ],
+  "target": {
+    "name": "DEMO",
+    "isASM": true
+  },
+  "sequence": [
+    "action|launch",
+    "delay|200",
+    "hashWait|1",
+    "key|enter",
+    "delay|300",
+    "hashWait|2"
+  ],
+  "hashes": {
+    "1": {
+      "description": "All tests passed",
+	  "timeout": 5000,
+      "start": "vram_start",
+      "size": "vram_16_size",
+      "expected_CRCs": [
+        "38E2AD5A"
+      ]
+    },
+    "2": {
+      "description": "Exit",
+      "start": "vram_start",
+      "size": "vram_16_size",
+      "expected_CRCs": [
+        "FFAF89BA",
+        "101734A5",
+        "9DA19F44",
+        "A32840C8",
+        "349F4775"
+      ]
+    }
+  }
+}

test/standalone/cxx_stl/makefile

@@ -0,0 +1,18 @@
+# ----------------------------
+# Makefile Options
+# ----------------------------
+
+NAME = DEMO
+ICON = icon.png
+DESCRIPTION = "CE C Toolchain Demo"
+COMPRESSED = NO
+ARCHIVED = NO
+
+CFLAGS = -Wall -Wextra -Wno-deprecated-declarations -std=c17 -Oz
+CXXFLAGS = -Wall -Wextra -Wno-deprecated-declarations -std=c++20 -Oz
+
+PREFER_OS_LIBC = NO
+
+# ----------------------------
+
+include $(shell cedev-config --makefile)

test/standalone/cxx_stl/src/common.h

@@ -0,0 +1,10 @@
+#ifndef COMMON_H
+#define COMMON_H
+
+#include "fake_iostream.h"
+
+using namespace fake;
+
+#define C(expr) if (!(expr)) { return __LINE__; }
+
+#endif /* COMMON_H */

test/standalone/cxx_stl/src/fake_iostream.h

@@ -0,0 +1,102 @@
+#ifndef FAKE_IOSTREAM_H
+#define FAKE_IOSTREAM_H
+
+#include <cstdio>
+#include <string>
+#include <string_view>
+
+namespace fake {
+
+struct ostream {};
+
+static ostream cout;
+
+inline ostream& operator<<(ostream& os, char c) {
+    fputc(c, stdout);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, const char* x) {
+    printf("%s", x);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, const std::string& x) {
+    printf("%s", x.c_str());
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, const std::string_view& x) {
+    fwrite(x.data(), sizeof(char), x.size(), stdout);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, bool b) {
+    #if 0
+        fputc(b ? '1' : '0', stdout);
+    #else
+        os << (b ? "true" : "false");
+    #endif
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, void const * x) {
+    printf("%p", x);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, void const volatile * x) {
+    printf("%p", (void const*)x);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, nullptr_t) {
+    printf("%p", nullptr);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, int x) {
+    printf("%d", x);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, unsigned int x) {
+    printf("%u", x);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, float x) {
+    printf("%f", x);
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, double x) {
+    printf("%f", x);
+    return os;
+}
+
+constexpr char endl = '\n';
+constexpr char ends = '\0';
+
+constexpr char dec = '\0';
+constexpr char oct = '\0';
+constexpr char hex = '\0';
+constexpr char basefield = '\0';
+constexpr char left = '\0';
+constexpr char right = '\0';
+constexpr char internal = '\0';
+constexpr char adjustfield = '\0';
+constexpr char scientific = '\0';
+constexpr char fixed = '\0';
+constexpr char floatfield = '\0';
+constexpr char boolalpha = '\0';
+constexpr char showbase = '\0';
+constexpr char showpoint = '\0';
+constexpr char showpos = '\0';
+constexpr char skipws = '\0';
+constexpr char unitbuf = '\0';
+constexpr char uppercase = '\0';
+
+} // namespace fake
+
+#endif /* FAKE_IOSTREAM_H */

test/standalone/cxx_stl/src/main.cpp

@@ -0,0 +1,59 @@
+#include <ti/screen.h>
+#include <ti/getcsc.h>
+#include <sys/util.h>
+#include <ti/sprintf.h>
+#include <cstdio>
+
+#define TEST(test) { ret = test; if (ret != 0) { return ret; }}
+
+int test_basic();
+int test_apply();
+int test_tuple();
+int test_span();
+int test_charconv();
+int test_random();
+
+extern "C" void outchar(char ch) {
+    char *ptr = (char*)0xFB0000;
+    *ptr++ = ch;
+    *ptr++ = '\0';
+}
+
+
+extern "C" void ti_outchar(char ch);
+
+void ti_puts(const char* str) {
+    while(*str != '\0') {
+        ti_outchar(*str);
+        str++;
+    }
+}
+
+int run_tests(void) {
+    int ret = 0;
+
+    TEST(test_basic());
+    TEST(test_apply());
+    TEST(test_tuple());
+    TEST(test_span());
+    TEST(test_charconv());
+    TEST(test_random());
+
+    return ret;
+}
+
+int main(void) {
+    os_ClrHome();
+    int failed_test = run_tests();
+    if (failed_test != 0) {
+        char buf[sizeof("Failed test L-8388608\n")];
+        boot_sprintf(buf, "Failed test L%d\n", failed_test);
+        ti_puts(buf);
+    } else {
+        ti_puts("All tests passed");
+    }
+
+    while (!os_GetCSC());
+
+    return 0;
+}

test/standalone/cxx_stl/src/test.asm

@@ -0,0 +1,17 @@
+	assume	adl=1
+
+	section	.text
+
+	public	_ti_outchar
+
+_ti_outchar:
+	pop	de
+	ex	(sp), hl
+	push	de
+	ld	iy, $d00080	; ti.flags
+	ld	a, l
+	cp	a, 32
+	jp	nc, $207B8	; ti.PutC
+	cp	a, 10
+	jp	z, $0207F0	; ti.NewLine
+	ret

test/standalone/cxx_stl/src/test_apply.cpp

@@ -0,0 +1,41 @@
+#include "common.h"
+
+static int add(int first, int second) { return first + second; }
+
+template<typename T>
+T add_generic(T first, T second) { return first + second; }
+
+auto add_lambda = [](auto first, auto second) { return first + second; };
+
+template<typename... Ts>
+ostream& operator<<(ostream& os, std::tuple<Ts...> const& theTuple)
+{
+    std::apply
+    (
+        [&os](Ts const&... tupleArgs)
+        {
+            os << '[';
+            std::size_t n{0};
+            ((os << tupleArgs << (++n != sizeof...(Ts) ? ", " : "")), ...);
+            os << ']';
+        }, theTuple
+    );
+    return os;
+}
+
+int test_apply()
+{
+    // OK
+    cout << std::apply(add, std::pair(1, 2)) << '\n';
+
+    // Error: can't deduce the function type
+    // cout << std::apply(add_generic, std::make_pair(2.0f, 3.0f)) << '\n';
+
+    // OK
+    cout << std::apply(add_lambda, std::pair(2.0f, 3.0f)) << '\n';
+
+    // advanced example
+    std::tuple myTuple{25, "Hello", 9.31f, 'c'};
+    cout << myTuple << '\n';
+	return 0;
+}

test/standalone/cxx_stl/src/test_basic.cpp

@@ -0,0 +1,28 @@
+#include <vector>
+#include <algorithm>
+#include <numeric>
+
+#include "common.h"
+
+int test_basic() {
+    std::vector<int> x = {8, 4, 5, 9};
+    x.push_back(std::move(6));
+    x.push_back(9);
+    x[2] = -1;
+    std::sort(x.begin(), x.end());
+    std::vector<int> y = {7, 3};
+    std::swap(x, y);
+    std::swap(y.front(), y.back());
+    x.insert(x.end(), y.rbegin(), y.rend());
+
+    const std::vector<int> x_truth = {7, 3, -1, 9, 8, 6, 4, 9};
+    constexpr int x_sum = 45;
+
+    C((x.size() == x_truth.size()));
+    C((y.size() == x_truth.size() - 2));
+    C((std::accumulate(x.begin(), x.end(), decltype(x)::value_type(0)) == x_sum));
+    C((std::equal(x.begin(), x.end(), x_truth.begin())));
+    C((std::equal(y.crbegin(), y.crend(), x_truth.cbegin() + 2)));
+
+    return 0;
+}

test/standalone/cxx_stl/src/test_charconv.cpp

@@ -0,0 +1,30 @@
+#include <charconv>
+#include <string_view>
+#include <system_error>
+
+#include "common.h"
+
+void show_to_chars(auto... format_args) {
+    const size_t buf_size = 10;
+    char buf[buf_size]{};
+    std::to_chars_result result = std::to_chars(buf, buf + buf_size, format_args...);
+
+    if (result.ec != std::errc()) {
+        cout << std::make_error_code(result.ec).message() << '\n';
+    } else {
+        std::string_view str(buf, result.ptr - buf);
+        cout << str << '\n';
+    }
+}
+
+int test_charconv() {
+    show_to_chars(42);
+    // These will blow up the binary size
+    #if 0
+        show_to_chars(+3.14159F);
+        show_to_chars(-3.14159, std::chars_format::fixed);
+        show_to_chars(-3.14159, std::chars_format::scientific, 3);
+        show_to_chars(3.1415926535, std::chars_format::fixed, 10);
+    #endif
+    return 0;
+}

test/standalone/cxx_stl/src/test_random.cpp

@@ -0,0 +1,28 @@
+#include <map>
+#include <random>
+#include <string>
+#include <chrono>
+
+#include "common.h"
+
+int test_random()
+{
+    uint64_t seed = static_cast<uint64_t>(
+        std::chrono::high_resolution_clock::now().time_since_epoch().count()
+    );
+    std::mt19937 gen(seed);
+
+    // If an event occurs 3 times a minute on average, how
+    // often is it that it occurs n times in one minute?
+    std::poisson_distribution<> d(3);
+
+    std::map<int, int> hist;
+    for (int n = 0; n != 64; ++n) {
+        ++hist[d(gen)];
+    }
+
+    for (auto [x, y] : hist) {
+        printf("%2d %s\n", x, std::string(y, '*').c_str());
+    }
+    return 0;
+}