Problem: tests without test framework

Solution: migrate to unity

Makefile.am

@@ -465,7 +465,8 @@ tests_test_system_LDADD = src/libzmq.la
 tests_test_pair_inproc_SOURCES = \
 	tests/test_pair_inproc.cpp \
 	tests/testutil.hpp
-tests_test_pair_inproc_LDADD = src/libzmq.la
+tests_test_pair_inproc_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_pair_inproc_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_pair_tcp_SOURCES = \
 	tests/test_pair_tcp.cpp \
@@ -594,7 +595,8 @@ tests_test_security_zap_SOURCES = \
 tests_test_security_zap_LDADD = src/libzmq.la
 
 tests_test_spec_req_SOURCES = tests/test_spec_req.cpp
-tests_test_spec_req_LDADD = src/libzmq.la
+tests_test_spec_req_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_spec_req_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_spec_rep_SOURCES = tests/test_spec_rep.cpp
 tests_test_spec_rep_LDADD = src/libzmq.la ${UNITY_LIBS}
@@ -617,7 +619,8 @@ tests_test_req_correlate_LDADD = src/libzmq.la ${UNITY_LIBS}
 tests_test_req_correlate_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_req_relaxed_SOURCES = tests/test_req_relaxed.cpp
-tests_test_req_relaxed_LDADD = src/libzmq.la
+tests_test_req_relaxed_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_req_relaxed_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_conflate_SOURCES = tests/test_conflate.cpp
 tests_test_conflate_LDADD = src/libzmq.la ${UNITY_LIBS}
@@ -788,10 +791,12 @@ tests_test_ipc_wildcard_LDADD = src/libzmq.la
 tests_test_pair_ipc_SOURCES = \
 	tests/test_pair_ipc.cpp \
 	tests/testutil.hpp
-tests_test_pair_ipc_LDADD = src/libzmq.la
+tests_test_pair_ipc_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_pair_ipc_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_rebind_ipc_SOURCES = tests/test_rebind_ipc.cpp
-tests_test_rebind_ipc_LDADD = src/libzmq.la
+tests_test_rebind_ipc_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_rebind_ipc_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_reqrep_ipc_SOURCES = \
 	tests/test_reqrep_ipc.cpp \
@@ -845,7 +850,8 @@ tests_test_connect_delay_tipc_LDADD = src/libzmq.la ${UNITY_LIBS}
 tests_test_connect_delay_tipc_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_pair_tipc_SOURCES = tests/test_pair_tipc.cpp
-tests_test_pair_tipc_LDADD = src/libzmq.la
+tests_test_pair_tipc_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_pair_tipc_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_reqrep_device_tipc_SOURCES = tests/test_reqrep_device_tipc.cpp
 tests_test_reqrep_device_tipc_LDADD = src/libzmq.la ${UNITY_LIBS}

tests/test_pair_inproc.cpp

@@ -28,54 +28,55 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
 
-int main (void)
+#include <unity.h>
+
+void *sb;
+void *sc;
+
+void setUp ()
 {
-    setup_test_environment ();
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
+    setup_test_context ();
 
-    void *sb = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sb);
-    int rc = zmq_bind (sb, "inproc://a");
-    assert (rc == 0);
+    sb = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, "inproc://a"));
 
-    void *sc = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sc);
-    rc = zmq_connect (sc, "inproc://a");
-    assert (rc == 0);
+    sc = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, "inproc://a"));
+}
 
+void tearDown ()
+{
+    test_context_socket_close (sc);
+    test_context_socket_close (sb);
+
+    teardown_test_context ();
+}
+
+void test_roundtrip ()
+{
     bounce (sb, sc);
+}
+
+// TODO it appears that this has nothing to do with pair or inproc, and belongs somewhere else
+void test_zmq_send_const ()
+{
+    TEST_ASSERT_EQUAL_INT (3, TEST_ASSERT_SUCCESS_ERRNO (
+                                zmq_send_const (sb, "foo", 3, ZMQ_SNDMORE)));
+    TEST_ASSERT_EQUAL_INT (
+      6, TEST_ASSERT_SUCCESS_ERRNO (zmq_send_const (sb, "foobar", 6, 0)));
+
+    recv_string_expect_success (sc, "foo", 0);
+    recv_string_expect_success (sc, "foobar", 0);
+}
+
+int main ()
+{
+    setup_test_environment ();
 
-    // Test zmq_send_const
-    rc = zmq_send_const (sb, "foo", 3, ZMQ_SNDMORE);
-    assert (rc == 3);
-    rc = zmq_send_const (sb, "foobar", 6, 0);
-    assert (rc == 6);
-
-    zmq_msg_t msg;
-    rc = zmq_msg_init (&msg);
-    assert (rc == 0);
-    rc = zmq_msg_recv (&msg, sc, 0);
-    assert (rc == 3);
-    assert (zmq_msg_size (&msg) == 3);
-    void *data = zmq_msg_data (&msg);
-    assert (memcmp ("foo", data, 3) == 0);
-    rc = zmq_msg_recv (&msg, sc, 0);
-    assert (rc == 6);
-    data = zmq_msg_data (&msg);
-    assert (memcmp ("foobar", data, 6) == 0);
-
-    // Cleanup
-
-    rc = zmq_close (sc);
-    assert (rc == 0);
-
-    rc = zmq_close (sb);
-    assert (rc == 0);
-
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
-
-    return 0;
+    UNITY_BEGIN ();
+    RUN_TEST (test_roundtrip);
+    RUN_TEST (test_zmq_send_const);
+    return UNITY_END ();
 }

tests/test_pair_ipc.cpp

@@ -28,33 +28,39 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
 
-int main (void)
+#include <unity.h>
+
+void setUp ()
 {
-    setup_test_environment ();
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
+    setup_test_context ();
+}
 
-    void *sb = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sb);
-    int rc = zmq_bind (sb, "ipc:///tmp/test_pair_ipc");
-    assert (rc == 0);
+void tearDown ()
+{
+    teardown_test_context ();
+}
 
-    void *sc = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sc);
-    rc = zmq_connect (sc, "ipc:///tmp/test_pair_ipc");
-    assert (rc == 0);
+void test_roundtrip ()
+{
+    void *sb = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, "ipc:///tmp/test_pair_ipc"));
 
-    bounce (sb, sc);
+    void *sc = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, "ipc:///tmp/test_pair_ipc"));
 
-    rc = zmq_close (sc);
-    assert (rc == 0);
+    bounce (sb, sc);
 
-    rc = zmq_close (sb);
-    assert (rc == 0);
+    test_context_socket_close (sc);
+    test_context_socket_close (sb);
+}
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+int main (void)
+{
+    setup_test_environment ();
 
-    return 0;
+    UNITY_BEGIN ();
+    RUN_TEST (test_roundtrip);
+    return UNITY_END ();
 }

tests/test_pair_tipc.cpp

@@ -29,39 +29,42 @@
 
 #include <stdio.h>
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
 
-int main (void)
-{
-    if (!is_tipc_available ()) {
-        printf ("TIPC environment unavailable, skipping test\n");
-        return 77;
-    }
+#include <unity.h>
 
-    fprintf (stderr, "test_pair_tipc running...\n");
+void setUp ()
+{
+    setup_test_context ();
+}
 
-    void *ctx = zmq_init (1);
-    assert (ctx);
+void tearDown ()
+{
+    teardown_test_context ();
+}
 
-    void *sb = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sb);
-    int rc = zmq_bind (sb, "tipc://{5560,0,0}");
-    assert (rc == 0);
+void test_roundtrip ()
+{
+    void *sb = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, "tipc://{5560,0,0}"));
 
-    void *sc = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sc);
-    rc = zmq_connect (sc, "tipc://{5560,0}@0.0.0");
-    assert (rc == 0);
+    void *sc = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, "tipc://{5560,0}@0.0.0"));
 
     bounce (sb, sc);
 
-    rc = zmq_close (sc);
-    assert (rc == 0);
-
-    rc = zmq_close (sb);
-    assert (rc == 0);
+    test_context_socket_close (sc);
+    test_context_socket_close (sb);
+}
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+int main ()
+{
+    if (!is_tipc_available ()) {
+        printf ("TIPC environment unavailable, skipping test\n");
+        return 77;
+    }
 
-    return 0;
+    UNITY_BEGIN ();
+    RUN_TEST (test_roundtrip);
+    return UNITY_END ();
 }

tests/test_rebind_ipc.cpp

@@ -28,57 +28,51 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
 
-static const char *SOCKET_ADDR = "ipc:///tmp/test_rebind_ipc";
-
+#include <unity.h>
 
-int main (void)
+void setUp ()
 {
-    setup_test_environment ();
-
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
-
-    void *sb0 = zmq_socket (ctx, ZMQ_PUSH);
-    assert (sb0);
-    void *sb1 = zmq_socket (ctx, ZMQ_PUSH);
-    assert (sb1);
+    setup_test_context ();
+}
 
-    int rc = zmq_bind (sb0, SOCKET_ADDR);
-    assert (rc == 0);
+void tearDown ()
+{
+    teardown_test_context ();
+}
 
-    void *sc = zmq_socket (ctx, ZMQ_PULL);
-    assert (sc);
-    rc = zmq_connect (sc, SOCKET_ADDR);
-    assert (rc == 0);
+static const char *SOCKET_ADDR = "ipc:///tmp/test_rebind_ipc";
 
-    rc = zmq_send (sb0, "42", 2, 0);
-    assert (rc == 2);
+void test_rebind_ipc ()
+{
+    void *sb0 = test_context_socket (ZMQ_PUSH);
+    void *sb1 = test_context_socket (ZMQ_PUSH);
 
-    char buffer[2];
-    rc = zmq_recv (sc, buffer, 2, 0);
-    assert (rc == 2);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb0, SOCKET_ADDR));
 
-    rc = zmq_close (sb0);
-    assert (rc == 0);
+    void *sc = test_context_socket (ZMQ_PULL);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, SOCKET_ADDR));
 
-    rc = zmq_bind (sb1, SOCKET_ADDR);
-    assert (rc == 0);
+    send_string_expect_success (sb0, "42", 0);
+    recv_string_expect_success (sc, "42", 0);
 
-    rc = zmq_send (sb1, "42", 2, 0);
-    assert (rc == 2);
+    test_context_socket_close (sb0);
 
-    rc = zmq_recv (sc, buffer, 2, 0);
-    assert (rc == 2);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb1, SOCKET_ADDR));
 
-    rc = zmq_close (sc);
-    assert (rc == 0);
+    send_string_expect_success (sb1, "42", 0);
+    recv_string_expect_success (sc, "42", 0);
 
-    rc = zmq_close (sb1);
-    assert (rc == 0);
+    test_context_socket_close (sc);
+    test_context_socket_close (sb1);
+}
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+int main ()
+{
+    setup_test_environment ();
 
-    return 0;
+    UNITY_BEGIN ();
+    RUN_TEST (test_rebind_ipc);
+    return UNITY_END ();
 }

tests/test_req_relaxed.cpp

@@ -29,26 +29,74 @@
 
 #include "testutil.hpp"
 
+#include "testutil.hpp"
+#include "testutil_unity.hpp"
+
+#include <unity.h>
+
+const size_t services = 5;
+
+void *req;
+void *rep[services];
+
+void setUp ()
+{
+    setup_test_context ();
+
+    char my_endpoint[MAX_SOCKET_STRING];
+    req = test_context_socket (ZMQ_REQ);
+
+    int enabled = 1;
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (req, ZMQ_REQ_RELAXED, &enabled, sizeof (int)));
+
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (req, ZMQ_REQ_CORRELATE, &enabled, sizeof (int)));
+
+    bind_loopback_ipv4 (req, my_endpoint, sizeof (my_endpoint));
+
+    for (size_t peer = 0; peer < services; peer++) {
+        rep[peer] = test_context_socket (ZMQ_REP);
+
+        int timeout = 500;
+        TEST_ASSERT_SUCCESS_ERRNO (
+          zmq_setsockopt (rep[peer], ZMQ_RCVTIMEO, &timeout, sizeof (int)));
+
+        TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rep[peer], my_endpoint));
+    }
+    //  We have to give the connects time to finish otherwise the requests
+    //  will not properly round-robin. We could alternatively connect the
+    //  REQ sockets to the REP sockets.
+    msleep (SETTLE_TIME);
+}
+
+void tearDown ()
+{
+    test_context_socket_close_zero_linger (req);
+    for (size_t peer = 0; peer < services; peer++)
+        test_context_socket_close_zero_linger (rep[peer]);
+
+    teardown_test_context ();
+}
+
 static void bounce (void *socket_)
 {
     int more;
     size_t more_size = sizeof (more);
     do {
         zmq_msg_t recv_part, sent_part;
-        int rc = zmq_msg_init (&recv_part);
-        assert (rc == 0);
+        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&recv_part));
 
-        rc = zmq_msg_recv (&recv_part, socket_, 0);
-        assert (rc != -1);
+        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&recv_part, socket_, 0));
 
-        rc = zmq_getsockopt (socket_, ZMQ_RCVMORE, &more, &more_size);
-        assert (rc == 0);
+        TEST_ASSERT_SUCCESS_ERRNO (
+          zmq_getsockopt (socket_, ZMQ_RCVMORE, &more, &more_size));
 
         zmq_msg_init (&sent_part);
         zmq_msg_copy (&sent_part, &recv_part);
 
-        rc = zmq_msg_send (&sent_part, socket_, more ? ZMQ_SNDMORE : 0);
-        assert (rc != -1);
+        TEST_ASSERT_SUCCESS_ERRNO (
+          zmq_msg_send (&sent_part, socket_, more ? ZMQ_SNDMORE : 0));
 
         zmq_msg_close (&recv_part);
     } while (more);
@@ -56,73 +104,33 @@ static void bounce (void *socket_)
 
 static int get_events (void *socket_)
 {
-    int rc;
     int events;
     size_t events_size = sizeof (events);
-    rc = zmq_getsockopt (socket_, ZMQ_EVENTS, &events, &events_size);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (socket_, ZMQ_EVENTS, &events, &events_size));
     return events;
 }
 
-int main (void)
+void test_case_1 ()
 {
-    setup_test_environment ();
-    size_t len = MAX_SOCKET_STRING;
-    char my_endpoint[MAX_SOCKET_STRING];
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
-
-    void *req = zmq_socket (ctx, ZMQ_REQ);
-    assert (req);
-
-    int enabled = 1;
-    int rc = zmq_setsockopt (req, ZMQ_REQ_RELAXED, &enabled, sizeof (int));
-    assert (rc == 0);
-
-    rc = zmq_setsockopt (req, ZMQ_REQ_CORRELATE, &enabled, sizeof (int));
-    assert (rc == 0);
-
-    rc = zmq_bind (req, "tcp://127.0.0.1:*");
-    assert (rc == 0);
-    rc = zmq_getsockopt (req, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
-    assert (rc == 0);
-
-    const size_t services = 5;
-    void *rep[services];
-    for (size_t peer = 0; peer < services; peer++) {
-        rep[peer] = zmq_socket (ctx, ZMQ_REP);
-        assert (rep[peer]);
-
-        int timeout = 500;
-        rc = zmq_setsockopt (rep[peer], ZMQ_RCVTIMEO, &timeout, sizeof (int));
-        assert (rc == 0);
-
-        rc = zmq_connect (rep[peer], my_endpoint);
-        assert (rc == 0);
-    }
-    //  We have to give the connects time to finish otherwise the requests
-    //  will not properly round-robin. We could alternatively connect the
-    //  REQ sockets to the REP sockets.
-    msleep (SETTLE_TIME);
-
     //  Case 1: Second send() before a reply arrives in a pipe.
 
     int events = get_events (req);
-    assert (events == ZMQ_POLLOUT);
+    TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);
 
     //  Send a request, ensure it arrives, don't send a reply
     s_send_seq (req, "A", "B", SEQ_END);
     s_recv_seq (rep[0], "A", "B", SEQ_END);
 
     events = get_events (req);
-    assert (events == ZMQ_POLLOUT);
+    TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);
 
     //  Send another request on the REQ socket
     s_send_seq (req, "C", "D", SEQ_END);
     s_recv_seq (rep[1], "C", "D", SEQ_END);
 
     events = get_events (req);
-    assert (events == ZMQ_POLLOUT);
+    TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);
 
     //  Send a reply to the first request - that should be discarded by the REQ
     s_send_seq (rep[0], "WRONG", SEQ_END);
@@ -136,10 +144,15 @@ int main (void)
     s_recv_seq (rep[2], "E", SEQ_END);
     s_send_seq (rep[2], "F", "G", SEQ_END);
     s_recv_seq (req, "F", "G", SEQ_END);
+}
 
-
+void test_case_2 ()
+{
     //  Case 2: Second send() after a reply is already in a pipe on the REQ.
 
+    // TODO instead of rerunning the previous test cases, only do the relevant parts (or change the peer)
+    test_case_1 ();
+
     //  Send a request, ensure it arrives, send a reply
     s_send_seq (req, "H", SEQ_END);
     s_recv_seq (rep[3], "H", SEQ_END);
@@ -155,49 +168,50 @@ int main (void)
     //  Send the expected reply
     s_send_seq (rep[4], "GOOD", SEQ_END);
     s_recv_seq (req, "GOOD", SEQ_END);
+}
 
+void test_case_3 ()
+{
     //  Case 3: Check issue #1690. Two send() in a row should not close the
     //  communication pipes. For example pipe from req to rep[0] should not be
     //  closed after executing Case 1. So rep[0] should be the next to receive,
     //  not rep[1].
+
+    // TODO instead of rerunning the previous test cases, only do the relevant parts (or change the peer)
+    test_case_2 ();
+
     s_send_seq (req, "J", SEQ_END);
     s_recv_seq (rep[0], "J", SEQ_END);
+}
 
-    close_zero_linger (req);
-    for (size_t peer = 0; peer < services; peer++)
-        close_zero_linger (rep[peer]);
-
-    //  Wait for disconnects.
-    msleep (SETTLE_TIME);
+void test_case_4 ()
+{
+    // TODO this test case does not use the sockets from setUp
 
     //  Case 4: Check issue #1695. As messages may pile up before a responder
     //  is available, we check that responses to messages other than the last
     //  sent one are correctly discarded by the REQ pipe
 
     //  Setup REQ socket as client
-    req = zmq_socket (ctx, ZMQ_REQ);
-    assert (req);
-
-    rc = zmq_setsockopt (req, ZMQ_REQ_RELAXED, &enabled, sizeof (int));
-    assert (rc == 0);
+    void *req = test_context_socket (ZMQ_REQ);
 
-    rc = zmq_setsockopt (req, ZMQ_REQ_CORRELATE, &enabled, sizeof (int));
-    assert (rc == 0);
+    int enabled = 1;
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (req, ZMQ_REQ_RELAXED, &enabled, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (req, ZMQ_REQ_CORRELATE, &enabled, sizeof (int)));
 
-    rc = zmq_connect (req, ENDPOINT_0);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (req, ENDPOINT_0));
 
     //  Setup ROUTER socket as server but do not bind it just yet
-    void *router = zmq_socket (ctx, ZMQ_ROUTER);
-    assert (router);
+    void *router = test_context_socket (ZMQ_ROUTER);
 
     //  Send two requests
     s_send_seq (req, "TO_BE_DISCARDED", SEQ_END);
     s_send_seq (req, "TO_BE_ANSWERED", SEQ_END);
 
     //  Bind server allowing it to receive messages
-    rc = zmq_bind (router, ENDPOINT_0);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (router, ENDPOINT_0));
 
     //  Read the two messages and send them back as is
     bounce (router);
@@ -207,14 +221,18 @@ int main (void)
     //  the expected answer is "TO_BE_ANSWERED", not "TO_BE_DISCARDED".
     s_recv_seq (req, "TO_BE_ANSWERED", SEQ_END);
 
-    close_zero_linger (req);
-    close_zero_linger (router);
-
-    //  Wait for disconnects.
-    msleep (SETTLE_TIME);
+    test_context_socket_close_zero_linger (req);
+    test_context_socket_close_zero_linger (router);
+}
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+int main ()
+{
+    setup_test_environment ();
 
-    return 0;
+    UNITY_BEGIN ();
+    RUN_TEST (test_case_1);
+    RUN_TEST (test_case_2);
+    RUN_TEST (test_case_3);
+    RUN_TEST (test_case_4);
+    return UNITY_END ();
 }