vyperling 0.0.1__py3-none-any.whl

vyperling/__init__.py

@@ -0,0 +1,3 @@
+"""vyperling — Embedded C test runner with cross-compilation support."""
+
+__version__ = "0.0.1"

vyperling/c/UNITY_LICENSE

@@ -0,0 +1,24 @@
+Unity Test Framework
+https://github.com/ThrowTheSwitch/Unity
+Version: 2.6.1
+License: MIT
+
+Copyright (c) 2007-2021 Mike Karlesky, Mark VanderVoord, Greg Williams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vyperling/c/forge_mock.c

@@ -0,0 +1,111 @@
+/* forge_mock.c — vyperling mock runtime (shared, vendored). See forge_mock.h. */
+#include "forge_mock.h"
+#include "unity.h"
+
+static unsigned char forge_mock_arena[FORGE_MOCK_MEM_SIZE];
+static size_t        forge_mock_used = 0;
+static int           forge_mock_refs = 0;
+static int           forge_mock_line = 0;
+
+#define FORGE_MOCK_ALIGN (sizeof(void *))
+
+void forge_mock_arena_acquire(void)
+{
+    if (forge_mock_refs == 0) {
+        forge_mock_used = 0;  /* reset only at the start of a round */
+    }
+    forge_mock_refs++;
+}
+
+void forge_mock_arena_release(void)
+{
+    if (forge_mock_refs > 0) {
+        forge_mock_refs--;
+    }
+}
+
+void *forge_mock_alloc(size_t size)
+{
+    size = (size + (FORGE_MOCK_ALIGN - 1)) & ~(FORGE_MOCK_ALIGN - 1);
+    if (forge_mock_used + size > FORGE_MOCK_MEM_SIZE) {
+        UNITY_TEST_FAIL((UNITY_LINE_TYPE)forge_mock_line,
+                        "forge_mock: arena exhausted; raise FORGE_MOCK_MEM_SIZE");
+        return 0;
+    }
+    {
+        void *p = &forge_mock_arena[forge_mock_used];
+        forge_mock_used += size;
+        return p;
+    }
+}
+
+void forge_mock_queue_reset(forge_mock_queue *q)
+{
+    q->head = q->tail = q->replay = 0;
+    q->count = 0;
+    q->consumed = 0;
+}
+
+void *forge_mock_queue_push(forge_mock_queue *q, size_t size)
+{
+    void *rec = forge_mock_alloc(size);
+    if (!rec) {
+        return 0;
+    }
+    *(void **)rec = 0;  /* next = NULL */
+    if (q->tail) {
+        *(void **)q->tail = rec;
+    } else {
+        q->head = rec;
+        q->replay = rec;
+    }
+    q->tail = rec;
+    q->count++;
+    return rec;
+}
+
+void *forge_mock_queue_pop(forge_mock_queue *q)
+{
+    void *rec = q->replay;
+    if (rec) {
+        q->replay = *(void **)rec;
+        q->consumed++;
+    }
+    return rec;
+}
+
+void forge_mock_set_line(int line)
+{
+    forge_mock_line = line;
+}
+
+/* Build "<func>: <msg>" without depending on sprintf/stdio. */
+void forge_mock_fail(const char *func, const char *msg)
+{
+    static char buf[256];
+    size_t i = 0;
+    const char *s = func;
+    while (*s && i < 200) {
+        buf[i++] = *s++;
+    }
+    buf[i++] = ':';
+    buf[i++] = ' ';
+    s = msg;
+    while (*s && i < 255) {
+        buf[i++] = *s++;
+    }
+    buf[i] = 0;
+    UNITY_TEST_FAIL((UNITY_LINE_TYPE)forge_mock_line, buf);
+}
+
+void forge_mock_fail_no_expect(const char *func)
+{
+    forge_mock_fail(func, "called more times than expected");
+}
+
+void forge_mock_verify_queue(const char *func, forge_mock_queue *q)
+{
+    if (q->consumed < q->count) {
+        forge_mock_fail(func, "expected call(s) not received before Verify");
+    }
+}

vyperling/c/forge_mock.h

@@ -0,0 +1,54 @@
+/* forge_mock.h — vyperling mock runtime (shared, vendored).
+ *
+ * Generic machinery used by every generated mock_<module>.c:
+ *   - a no-heap bump-allocator arena (works bare-metal under QEMU)
+ *   - a refcounted acquire/release so multiple modules can share the arena
+ *     within one test without one module's Init wiping another's queue
+ *   - a generic FIFO queue of call-instance records
+ *   - a failure funnel that routes every mock failure through Unity
+ *
+ * Generated mocks #include this. Do not edit generated code; edit here.
+ */
+#ifndef FORGE_MOCK_H
+#define FORGE_MOCK_H
+
+#include <stddef.h>
+#include "unity.h"
+
+/* Size of the static arena. Override with -DFORGE_MOCK_MEM_SIZE=... if a test
+ * queues enough expectations to exhaust it. */
+#ifndef FORGE_MOCK_MEM_SIZE
+#define FORGE_MOCK_MEM_SIZE 32768
+#endif
+
+/* ---- Arena (bump allocator, no heap) ------------------------------------ */
+
+/* Refcounted. The arena is reset only on the FIRST acquire of a round, so
+ * every mock_<mod>_Init() in setUp() shares one arena cleanly. */
+void  forge_mock_arena_acquire(void);
+void  forge_mock_arena_release(void);
+void *forge_mock_alloc(size_t size);  /* aligned; fails the test on OOM */
+
+/* ---- Generic FIFO queue of call-instance records ------------------------
+ * Each record's FIRST member must be a `void *next` link. Generated per-
+ * function structs follow that layout. */
+typedef struct forge_mock_queue_s {
+    void *head;      /* oldest queued expectation */
+    void *tail;      /* newest */
+    void *replay;    /* next record to consume on an actual call */
+    int   count;     /* total queued */
+    int   consumed;  /* calls replayed so far */
+} forge_mock_queue;
+
+void  forge_mock_queue_reset(forge_mock_queue *q);
+void *forge_mock_queue_push(forge_mock_queue *q, size_t size); /* alloc+append */
+void *forge_mock_queue_pop(forge_mock_queue *q);               /* current or NULL */
+
+/* ---- Failure funnel — everything routes through Unity ------------------- */
+
+void forge_mock_set_line(int line);                            /* line of the Expect call */
+void forge_mock_fail(const char *func, const char *msg);       /* -> UNITY_TEST_FAIL */
+void forge_mock_fail_no_expect(const char *func);              /* called more than expected */
+void forge_mock_verify_queue(const char *func, forge_mock_queue *q); /* too-few-calls */
+
+#endif /* FORGE_MOCK_H */