Adds test directory containing TAP style tests. Run "make check" in
the root directory to build and run the tests.
The tests can fork a child ptp4l process to interact with or can link
to object files in the root directory and test functions directly.
Should consider building the core of ptp4l as a static library that
the tests can link against.
---
.gitignore | 11 +-
makefile | 5 +
tests/TESTS | 6 +
tests/childproc-t.c | 41 ++
tests/childproc.c | 477 ++++++++++++++++++++
tests/childproc.h | 55 +++
tests/description-t.c | 87 ++++
tests/errors-t.c | 121 +++++
tests/example-t.c | 30 ++
tests/faultlog-t.c | 189 ++++++++
tests/makefile | 71 +++
tests/mgmt.c | 239 ++++++++++
tests/mgmt.h | 68 +++
tests/priority-t.c | 39 ++
tests/runtests.c | 1204 +++++++++++++++++++++++++++++++++++++++++++++++++
tests/tap/basic.c | 629 ++++++++++++++++++++++++++
tests/tap/basic.h | 134 ++++++
tests/tap/float.c | 67 +++
tests/tap/float.h | 42 ++
tests/tap/libtap.sh | 246 ++++++++++
tests/tap/macros.h | 88 ++++
tests/testutil.c | 115 +++++
tests/testutil.h | 42 ++
23 files changed, 4004 insertions(+), 2 deletions(-)
create mode 100644 tests/TESTS
create mode 100644 tests/childproc-t.c
create mode 100644 tests/childproc.c
create mode 100644 tests/childproc.h
create mode 100644 tests/description-t.c
create mode 100644 tests/errors-t.c
create mode 100644 tests/example-t.c
create mode 100644 tests/faultlog-t.c
create mode 100644 tests/makefile
create mode 100644 tests/mgmt.c
create mode 100644 tests/mgmt.h
create mode 100644 tests/priority-t.c
create mode 100644 tests/runtests.c
create mode 100644 tests/tap/basic.c
create mode 100644 tests/tap/basic.h
create mode 100644 tests/tap/float.c
create mode 100644 tests/tap/float.h
create mode 100644 tests/tap/libtap.sh
create mode 100644 tests/tap/macros.h
create mode 100644 tests/testutil.c
create mode 100644 tests/testutil.h
diff --git a/.gitignore b/.gitignore
index e0710ad..0ed84ca 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,13 @@
-/*.d
-/*.o
+*.d
+*.o
/hwstamp_ctl
/phc2sys
/pmc
/ptp4l
+/tests/runtests
+/tests/example-t
+/tests/childproc-t
+/tests/errors-t
+/tests/priority-t
+/tests/description-t
+/tests/faultlog-t
diff --git a/makefile b/makefile
index 53b9e4d..18a5e6b 100644
--- a/makefile
+++ b/makefile
@@ -71,10 +71,15 @@ install: $(PRG)
clean:
rm -f $(OBJECTS) $(DEPEND)
+ make -C tests clean
distclean: clean
rm -f $(PRG)
rm -f .version
+ make -C tests distclean
+
+check: all
+ make -C tests check
# Implicit rule to generate a C source file's dependencies.
%.d: %.c
diff --git a/tests/TESTS b/tests/TESTS
new file mode 100644
index 0000000..361cf3b
--- /dev/null
+++ b/tests/TESTS
@@ -0,0 +1,6 @@
+example
+childproc
+errors
+priority
+description
+faultlog
diff --git a/tests/childproc-t.c b/tests/childproc-t.c
new file mode 100644
index 0000000..c08a0be
--- /dev/null
+++ b/tests/childproc-t.c
@@ -0,0 +1,41 @@
+/**
+ * @file childproc-t.c
+ * @brief Tests childproc
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "tap/basic.h"
+#include "testutil.h"
+
+int main() {
+ struct childproc *proc;
+ int res;
+ plan(5);
+
+ ok((res = childproc_new(&proc)) == 0, "new");
+ if (res != 0) return 0;
+ ok((res = childproc_spawn(proc, 0)) == 0, "spawn");
+ if (res != 0) return 0;
+
+ struct mgmt_msg out;
+ struct mgmt_msg in;
+ mgmt_msg_init(&out, ACTION_GET, MGMT_NULL_MANAGEMENT);
+ ok(childproc_send_recv(proc, &out, &in) == 0, "send and recv NULL");
+
+ ok(childproc_kill(proc) == 0, "kill");
+ ok(childproc_free(proc) == 0, "free");
+ return 0;
+}
diff --git a/tests/childproc.c b/tests/childproc.c
new file mode 100644
index 0000000..446fda9
--- /dev/null
+++ b/tests/childproc.c
@@ -0,0 +1,477 @@
+/**
+ * @file childproc.c
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "childproc.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/wait.h>
+#include <stddef.h>
+#include <poll.h>
+
+#include "msg.h"
+#include "uds.h"
+#include "mgmt.h"
+
+#include "testutil.h"
+
+#define CHILDERR_DEV_NULL 100
+#define CHILDERR_DUP 101
+#define CHILDERR_EXEC 102
+
+struct childproc {
+ pid_t pid;
+ int running; /* flag */
+
+ int skt;
+ struct sockaddr_un server;
+ socklen_t server_len;
+
+ struct sequence_ids seqs;
+
+ struct pollfd pollfd;
+};
+
+int childproc_new(struct childproc **proc) {
+ struct childproc *cp = malloc(sizeof(*cp));
+ *proc = 0;
+ if (cp == 0) {
+ return -ENOMEM;
+ }
+ memset(cp, 0, sizeof(*cp));
+ cp->skt = -1;
+ *proc = cp;
+ return 0;
+}
+
+int childproc_free(struct childproc *proc) {
+ if (proc->running) {
+ childproc_kill(proc);
+ }
+ free(proc);
+ return 0;
+}
+
+int childproc_kill(struct childproc *proc) {
+ int status;
+ if (!proc->running) {
+ /* already spawned */
+ return -EALREADY;
+ }
+
+ if (proc->skt >= 0) {
+ close(proc->skt);
+ proc->skt = -1;
+ }
+
+ if (kill(proc->pid, SIGINT) == -1) {
+ return -errno;
+ }
+
+ if (waitpid(proc->pid, &status, 0) == -1) {
+ return -errno;
+ }
+ if (WIFEXITED(status)) {
+ switch (WEXITSTATUS(status)) {
+ case CHILDERR_DEV_NULL:
+ printf("Child Process failed to open /dev/null\n");
+ break;
+ case CHILDERR_DUP:
+ printf("Child Process failed to redirect streams\n");
+ break;
+ case CHILDERR_EXEC:
+ printf("Child Process failed to exec ptp4l\n");
+ break;
+ default:
+ printf("Child Process exited with status %d\n",
+ WEXITSTATUS(status));
+ break;
+ }
+ } else if (WIFSIGNALED(status)) {
+ printf("Child Process was signalled %d\n", WTERMSIG(status));
+ }
+
+ proc->running = 0;
+ memset(&proc->seqs, 0, sizeof(proc->seqs));
+ return 0;
+}
+
+#define UDS_FILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP) /*0660*/
+
+static int init_child_skt(struct childproc *proc,
+ const char *bind_name,
+ const char *server_name) {
+ struct sockaddr_un sa;
+ int skt = socket(AF_LOCAL, SOCK_DGRAM, 0);
+ if (skt < 0) {
+ printf("Failed to create socket: %m\n");
+ return -1;
+ }
+ memset(&sa, 0, sizeof(sa));
+ sa.sun_family = AF_LOCAL;
+ strcpy(sa.sun_path, bind_name);
+
+ unlink(bind_name);
+ if (bind(skt, (struct sockaddr*) &sa, sizeof(sa)) == -1) {
+ printf("Failed to bind socket: %m\n");
+ close(skt);
+ return -1;
+ }
+ chmod(bind_name, UDS_FILEMODE);
+
+ proc->skt = skt;
+ proc->pollfd.fd = skt;
+ proc->pollfd.events = POLLIN;
+
+ memset(&proc->server, 0, sizeof(proc->server));
+ proc->server.sun_family = AF_LOCAL;
+ strcpy(proc->server.sun_path, server_name);
+ proc->server_len = offsetof(struct sockaddr_un, sun_path) +
+ strlen(server_name) + 1;
+ return 0;
+}
+
+/* Returns 0 if out and in are management messages and in appears to
+ * be a reply to out */
+static int verify_is_request_reply(struct mgmt_msg *out,
+ struct mgmt_msg *in)
+{
+
+ /*printf("verify\n"
+ "sequenceId %d %d\n"
+ "messageType %d %d\n",
+ out->hdr.sequenceId,
+ in->hdr.sequenceId,
+ out->hdr.messageType,
+ in->hdr.messageType);*/
+
+ if (out->hdr.sequenceId == in->hdr.sequenceId &&
+ out->hdr.messageType == MSG_MANAGEMENT &&
+ in->hdr.messageType == MSG_MANAGEMENT)
+ {
+ /* check that actions make sense */
+ switch (out->msg.actionField) {
+ case ACTION_GET:
+ case ACTION_SET:
+ if (in->msg.actionField != ACTION_RESPONSE) {
+ return -1;
+ }
+ break;
+ case ACTION_COMMAND:
+ if (in->msg.actionField != ACTION_ACKNOWLEDGE) {
+ return -1;
+ }
+ break;
+ default:
+ return -1;
+
+ }
+ switch (in->tlv.type) {
+ case TLV_MANAGEMENT:
+ /*printf("mgmt %d %d\n",
+ out->tlv.mgmt.id,
+ in->tlv.mgmt.id);*/
+ if (out->tlv.mgmt.id == in->tlv.mgmt.id) {
+ return 0;
+ }
+ break;
+ case TLV_MANAGEMENT_ERROR_STATUS:
+ /*printf("mgmterror %d %d\n",
+ out->tlv.mgmt.id,
+ in->tlv.error.managementId);*/
+ if (out->tlv.mgmt.id == in->tlv.error.managementId) {
+ return 0;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ return -1;
+}
+
+#define NUM_WAIT_SENDS 10
+#define NORMAL_DELAY 30
+#define LONG_DELAY 200
+
+static int wait_for_running(struct childproc *proc) {
+ int i;
+ int err;
+ int sent_successful = 0;
+ struct mgmt_msg msg;
+ struct mgmt_msg recv_msg;
+ uint8_t buf[300];
+ UInteger16 seq;
+ int len;
+
+ /* Repeatedly try send a NULL_MANAGEMENT to the ptp4l process
+ * until it replies. */
+ mgmt_msg_init(&msg, ACTION_GET, MGMT_NULL_MANAGEMENT);
+ for (i = 0; i < NUM_WAIT_SENDS; i++) {
+ /* attempt to send */
+ if (sent_successful == 0) {
+ seq = proc->seqs.mgmt++;
+ msg.hdr.sequenceId = seq;
+ len = mgmt_write_msg(&msg, buf, sizeof(buf));
+ if (len < 0) {
+ printf("Failed to serialize wait msg\n");
+ return -1;
+ }
+ printf("Sending wakeup msg\n");
+ if ((err = childproc_send(proc, buf, len)) < 0) {
+ /* ignore errors that mean the ptp4l
+ process hasn't called bind yet. */
+ if (err != -ECONNREFUSED && err != -ENOENT) {
+ return -1;
+ }
+ } else {
+ sent_successful = 1;
+ }
+ }
+
+ switch(poll(&proc->pollfd, 1,
+ i == NUM_WAIT_SENDS - 1 ? LONG_DELAY : NORMAL_DELAY))
+ {
+ case -1:
+ return -1;
+ break;
+ case 0:
+ /* timeout occured */
+ break;
+ case 1:
+ printf("Receiving wakeup msg\n");
+ len = childproc_recv(proc, buf, sizeof(buf));
+ if (len == -1) {
+ return -1;
+ }
+ if (mgmt_read_msg(buf, len, &recv_msg) < 0) {
+ printf("Unable to read wakeup reply\n");
+ }
+ if (verify_is_request_reply(&msg, &recv_msg) == 0) {
+ return 0;
+ }
+ break;
+ }
+ }
+
+ return -1;
+}
+
+int childproc_spawn(struct childproc *proc, const char *config) {
+ int infds[2];
+ int nullfd;
+ pid_t child;
+ int len;
+ int err;
+
+ if (proc->running) {
+ /* already spawned */
+ return -EALREADY;
+ }
+
+ /* create stdin pipe */
+ if (pipe(infds) == -1) {
+ return -errno;
+ }
+ child = fork();
+ if (child == -1) {
+ err = errno;
+ close(infds[0]);
+ close(infds[1]);
+ return -err;
+ } else if (child == 0) {
+ /* in child */
+ /* redirect stdout and stderr to /dev/null */
+ if ((nullfd = open("/dev/null", O_WRONLY)) == -1) {
+ _exit(CHILDERR_DEV_NULL);
+ }
+ /* redirect streams */
+ if (dup2(nullfd, STDERR_FILENO) == -1) {
+ _exit(CHILDERR_DUP);
+ }
+ if (dup2(nullfd, STDOUT_FILENO) == -1) {
+ _exit(CHILDERR_DUP);
+ }
+ if (dup2(infds[0], STDIN_FILENO) == -1) {
+ _exit(CHILDERR_DUP);
+ }
+ close(infds[0]);
+ close(infds[1]);
+
+ char *argv[7];
+ argv[0] = "ptp4l";
+ argv[1] = "-S"; /* sw timestamps */
+ argv[2] = "-i"; argv[3] = "lo"; /* network interface
+ * */
+ if (config) {
+ argv[4] = "-f"; argv[5] = "-"; /* config from stdin */
+ argv[6] = 0;
+ } else {
+ argv[4] = 0;
+ }
+ execv("../ptp4l", argv);
+ /* if execv returns, an error occured */
+ _exit(CHILDERR_EXEC);
+ } else {
+ /* in parent */
+ close(infds[0]); /* close read end */
+ proc->running = 1;
+ proc->pid = child;
+
+ if (config) {
+ /* write config to the child's stdin */
+ len = strlen(config);
+ if ((err = write(infds[1], config, len)) == -1) {
+ printf("failed to write config file %m\n");
+ goto kill_child;
+ }
+ if (err < len) {
+ printf("Only able to partially write config file %d < %d\n", err, len);
+ }
+ }
+ close(infds[1]);
+
+ /* open the ptp4l's unix domain socket.
+ *
+ * TODO: This currently uses a name hardcoded in
+ * ptp4l. Would be better to support passing the
+ * socket name to ptp4l. Possibly even use an abstract
+ * socket address and avoid filesystem completely..
+ */
+ if (init_child_skt(proc, "/tmp/ptptest", UDS_PATH) != 0) {
+ goto kill_child;
+ }
+
+
+ if (wait_for_running(proc) != 0) {
+ goto kill_child;
+ }
+ return 0;
+ }
+kill_child:
+ childproc_kill(proc);
+ return -1;
+}
+
+int childproc_pid(struct childproc *proc) {
+ if (proc->running) {
+ return proc->pid;
+ }
+ return -1;
+}
+
+int childproc_skt(struct childproc *proc) {
+ return proc->skt;
+}
+
+struct sequence_ids *childproc_seqs(struct childproc *proc) {
+ return &proc->seqs;
+}
+
+ssize_t childproc_send(struct childproc *proc, uint8_t *buf, size_t len) {
+ /*printf("Sending to fd %d msg len %zd\n", proc->skt, len);*/
+ ssize_t result = sendto(proc->skt, buf, len, 0,
+ (struct sockaddr*) &proc->server,
+ sizeof(proc->server));
+ if (result == -1) {
+ result = -errno;
+ printf("sendto UDS failed(%d): %m\n", errno);
+ }
+ return result;
+}
+
+ssize_t childproc_recv(struct childproc *proc, uint8_t *buf, size_t len) {
+ struct sockaddr_un sa;
+ socklen_t sa_len = sizeof(sa);
+ ssize_t result = recvfrom(proc->skt, buf, len, 0,
+ (struct sockaddr*) &sa, &sa_len);
+ if (result == -1) {
+ result = -errno;
+ printf("recvfrom UDS failed(%d): %m\n", errno);
+ } else {
+ /* ensure message came from the server */
+ if (sa_len != proc->server_len ||
+ strcmp(proc->server.sun_path, sa.sun_path) != 0) {
+ printf("Ignoring message from unknown sender\n");
+ return 0;
+ }
+ }
+ return result;
+}
+
+#define RECV_TIMEOUT 500
+
+int childproc_send_recv(struct childproc *proc,
+ struct mgmt_msg *out,
+ struct mgmt_msg *in)
+{
+ uint8_t buf[1500];
+ int len;
+ int err;
+
+ out->hdr.sequenceId = proc->seqs.mgmt++;
+ len = mgmt_write_msg(out, buf, sizeof(buf));
+ if (len < 0) {
+ printf("Failed to serialize msg\n");
+ return -1;
+ }
+ if ((err = childproc_send(proc, buf, len)) < 0) {
+ return err;
+ }
+ return childproc_recv_response(proc, out, in);
+}
+
+int childproc_recv_response(struct childproc *proc,
+ struct mgmt_msg *out,
+ struct mgmt_msg *in)
+{
+ uint8_t buf[1500];
+ int len;
+ switch (poll(&proc->pollfd, 1, RECV_TIMEOUT)) {
+ case -1:
+ printf("poll failed: %m\n");
+ return -1;
+ case 0:
+ /* timeout */
+ return -1;
+ case 1:
+ len = childproc_recv(proc, buf, sizeof(buf));
+ if (len == -1) {
+ return -1;
+ }
+ printf("RECV %d bytes\n", len);
+ if (mgmt_read_msg(buf, len, in) < 0) {
+ printf("Unable to read response\n");
+ return -1;
+ }
+ if (verify_is_request_reply(out, in) == 0) {
+ return 0;
+ }
+ break;
+ }
+ return -1;
+}
diff --git a/tests/childproc.h b/tests/childproc.h
new file mode 100644
index 0000000..4c02e42
--- /dev/null
+++ b/tests/childproc.h
@@ -0,0 +1,55 @@
+/**
+ * @file childproc.h
+ * @brief Utilities for forking a ptp4l process to test
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef TESTS_CHILDPROC_H
+#define TESTS_CHILDPROC_H
+
+#include <inttypes.h>
+#include <sys/types.h>
+
+#include "mgmt.h"
+
+/*
+ Support for running ptp4l as a child process.
+ */
+
+struct childproc;
+
+int childproc_new(struct childproc **proc);
+int childproc_free(struct childproc *proc);
+
+int childproc_spawn(struct childproc *proc, const char *config);
+int childproc_kill(struct childproc *proc);
+
+int childproc_pid(struct childproc *proc);
+int childproc_skt(struct childproc *proc);
+
+struct sequence_ids *childproc_seqs(struct childproc *proc);
+
+ssize_t childproc_send(struct childproc *proc, uint8_t *buf, size_t len);
+ssize_t childproc_recv(struct childproc *proc, uint8_t *buf, size_t len);
+
+int childproc_send_recv(struct childproc *proc,
+ struct mgmt_msg *out,
+ struct mgmt_msg *in);
+int childproc_recv_response(struct childproc *proc,
+ struct mgmt_msg *out,
+ struct mgmt_msg *in);
+
+#endif
diff --git a/tests/description-t.c b/tests/description-t.c
new file mode 100644
index 0000000..f9cd9ff
--- /dev/null
+++ b/tests/description-t.c
@@ -0,0 +1,87 @@
+/**
+ * @file description-t.c
+ * @brief Tests management CLOCK_DESCRIPTION
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "tap/basic.h"
+#include "testutil.h"
+
+const char *config =
+"[global]\n\
+product_description product\n\
+revision_data revision\n\
+user_description user\n\
+manufacturer_id aa:bb:cc\n\
+";
+
+int cmp_text(const struct PTPText *pt, const char *t) {
+ int len = strlen(t);
+ if (pt->length != len) return -1;
+ return memcmp(pt->text, t, len);
+}
+
+int main() {
+ struct childproc *proc = test_childproc(0);
+ plan(16);
+ struct mgmt_msg out;
+ struct mgmt_msg in;
+
+ /* Get CLOCK_DESCRIPTION */
+ mgmt_msg_init(&out, ACTION_GET, MGMT_CLOCK_DESCRIPTION);
+ ok(childproc_send_recv(proc, &out, &in) == 0, "send and recv GET CLOCK_DESCRIPTION");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.productDescription, "") == 0, "default productDescription");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.revisionData, "") == 0, "default revisionData");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.userDescription, "") == 0, "default userDescription");
+
+ ok(in.tlv.mgmt.data.cd.manufacturerIdentity[0] == 0 &&
+ in.tlv.mgmt.data.cd.manufacturerIdentity[1] == 0 &&
+ in.tlv.mgmt.data.cd.manufacturerIdentity[2] == 0,
+ "default manufacturerIdentity");
+
+ /* restart ptp4l with a config file */
+ proc = test_restart_childproc(config);
+
+ /* Get USER_DESCRIPTION */
+ mgmt_msg_init(&out, ACTION_GET, MGMT_USER_DESCRIPTION);
+ ok(childproc_send_recv(proc, &out, &in) == 0, "send and recv GET USER_DESCRIPTION");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.userDescription, "user") == 0, "config userDescription");
+
+ /* Get CLOCK_DESCRIPTION */
+ mgmt_msg_init(&out, ACTION_GET, MGMT_CLOCK_DESCRIPTION);
+ ok(childproc_send_recv(proc, &out, &in) == 0, "send and recv GET CLOCK_DESCRIPTION");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.productDescription, "product") == 0, "config productDescription");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.revisionData, "revision") == 0, "config revisionData");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.userDescription, "user") == 0, "config userDescription");
+
+ ok(in.tlv.mgmt.data.cd.manufacturerIdentity[0] == 0xaa &&
+ in.tlv.mgmt.data.cd.manufacturerIdentity[1] == 0xbb &&
+ in.tlv.mgmt.data.cd.manufacturerIdentity[2] == 0xcc,
+ "config manufacturerIdentity");
+
+ /* Set a new user description "ok" */
+ mgmt_msg_init(&out, ACTION_SET, MGMT_USER_DESCRIPTION);
+ out.tlv.mgmt.data.cd.userDescription.length = 2;
+ out.tlv.mgmt.data.cd.userDescription.text = (Octet*)"ok";
+ ok(childproc_send_recv(proc, &out, &in) == 0, "send and recv SET USER_DESCRIPTION");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.userDescription, "ok") == 0, "set userDescription");
+
+ /* Double check that set "ok" stuck */
+ mgmt_msg_init(&out, ACTION_GET, MGMT_CLOCK_DESCRIPTION);
+ ok(childproc_send_recv(proc, &out, &in) == 0, "send and recv GET CLOCK_DESCRIPTION");
+ ok(cmp_text(&in.tlv.mgmt.data.cd.userDescription, "ok") == 0, "config userDescription");
+ return 0;
+}
diff --git a/tests/errors-t.c b/tests/errors-t.c
new file mode 100644
index 0000000..61e9150
--- /dev/null
+++ b/tests/errors-t.c
@@ -0,0 +1,121 @@
+/**
+ * @file errors-t.c
+ * @brief Tests management error messages
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "tap/basic.h"
+#include "testutil.h"
+
+#include "pdt_pack.h"
+
+void send_check_error(struct childproc *proc, struct mgmt_msg *send,
+ uint8_t *buf, int len,
+ enum management_error_types error)
+{
+ struct mgmt_msg recv;
+ if (childproc_send(proc, buf, len) < 0) {
+ ok_block(2, 0, "send request failed");
+ } else if (childproc_recv_response(proc, send, &recv) == 0) {
+ ok(recv.tlv.type == TLV_MANAGEMENT_ERROR_STATUS,
+ "receive error");
+ ok(recv.tlv.error.managementErrorId == error,
+ "correct error %d =?= %d",
+ recv.tlv.error.managementErrorId, error);
+ } else {
+ ok_block(2, 0, "recv response failed");
+ }
+}
+
+/* Send malformed messages and ensure errors are returned */
+int main() {
+ int len;
+ uint8_t buf[1500];
+ UInteger16 *msg_len_field = (UInteger16 *)(buf + 2);
+ UInteger16 *tlv_len_field = (UInteger16 *)(buf + 34 + 14 + 2);
+ UInteger16 *mgmt_id_field = (UInteger16 *)(buf + 34 + 14 + 4);
+ struct childproc *proc = test_childproc(0);
+ Enumeration16 val;
+ plan(10);
+
+ struct mgmt_msg out;
+
+ /* invalid management id */
+ mgmt_msg_init(&out, ACTION_GET, MGMT_NULL_MANAGEMENT);
+ out.hdr.sequenceId = childproc_seqs(proc)->mgmt++;
+ len = mgmt_write_msg(&out, buf, sizeof(buf));
+ if (len < 0) {
+ printf("Failed to serialize msg\n");
+ return -1;
+ }
+
+ /* tweak management id to invalid one */
+ val = 0xFFF0;
+ out.tlv.mgmt.id = val;
+ packUInteger16(&val, mgmt_id_field);
+
+ send_check_error(proc, &out, buf, len, MGMT_ERROR_NO_SUCH_ID);
+
+
+ /* DEFAULT_DATA_SET is not settable */
+ mgmt_msg_init(&out, ACTION_SET, MGMT_DEFAULT_DATA_SET);
+ out.hdr.sequenceId = childproc_seqs(proc)->mgmt++;
+ len = mgmt_write_msg(&out, buf, sizeof(buf));
+ if (len < 0) {
+ printf("Failed to serialize msg\n");
+ return -1;
+ }
+ send_check_error(proc, &out, buf, len, MGMT_ERROR_NOT_SETABLE);
+
+ /* ENABLE_PORT is a command so setting is not supported */
+ mgmt_msg_init(&out, ACTION_SET, MGMT_ENABLE_PORT);
+ out.hdr.sequenceId = childproc_seqs(proc)->mgmt++;
+ len = mgmt_write_msg(&out, buf, sizeof(buf));
+ if (len < 0) {
+ printf("Failed to serialize msg\n");
+ return -1;
+ }
+ /* TODO: Should this be MGMT_ERROR_NOT_SETABLE instead? */
+ send_check_error(proc, &out, buf, len, MGMT_ERROR_NOT_SUPPORTED);
+
+ /* Test invalid tlv sizes */
+ mgmt_msg_init(&out, ACTION_SET, MGMT_USER_DESCRIPTION);
+ out.hdr.sequenceId = childproc_seqs(proc)->mgmt++;
+ out.tlv.mgmt.data.cd.userDescription.length = 5;
+ out.tlv.mgmt.data.cd.userDescription.text = (uint8_t*)"hello";
+ len = mgmt_write_msg(&out, buf, sizeof(buf));
+ if (len < 0) {
+ printf("Failed to serialize msg\n");
+ return -1;
+ }
+ UInteger16 msg_len;
+ unpackUInteger16(msg_len_field, &msg_len);
+
+ /* tlv len too small */
+ val = msg_len - 5;
+ packUInteger16(&val, msg_len_field);
+ val = 3;
+ packUInteger16(&val, tlv_len_field);
+ send_check_error(proc, &out, buf, len - 5, MGMT_ERROR_WRONG_LENGTH);
+
+ /* tlv len too large */
+ val = msg_len + 2;
+ packUInteger16(&val, msg_len_field);
+ val = 10;
+ packUInteger16(&val, tlv_len_field);
+ send_check_error(proc, &out, buf, len + 2, MGMT_ERROR_WRONG_LENGTH);
+ return 0;
+}
diff --git a/tests/example-t.c b/tests/example-t.c
new file mode 100644
index 0000000..d7b8137
--- /dev/null
+++ b/tests/example-t.c
@@ -0,0 +1,30 @@
+/**
+ * @file example-t.c
+ * @brief Example of a test
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "tap/basic.h"
+#include "testutil.h"
+
+int main() {
+ struct childproc *proc;
+ plan(1);
+
+ proc = test_childproc(0);
+ ok(0 < childproc_pid(proc), "valid pid");
+ return 0;
+}
diff --git a/tests/faultlog-t.c b/tests/faultlog-t.c
new file mode 100644
index 0000000..f51a305
--- /dev/null
+++ b/tests/faultlog-t.c
@@ -0,0 +1,189 @@
+/**
+ * @file faultlog-t.c
+ * @brief Tests FaultLog packing and unpacking
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "tap/basic.h"
+#include "testutil.h"
+
+#include <string.h>
+
+#include "tlv.h"
+#include "ddt_pack.h"
+
+int cmp_timestamp(struct Timestamp *t1, struct Timestamp *t2) {
+ if (t1->seconds_msb != t2->seconds_msb ||
+ t1->seconds_lsb != t2->seconds_lsb ||
+ t1->nanoseconds != t2->nanoseconds)
+ return -1;
+ return 0;
+}
+
+int cmp_ptptext(struct PTPText *t1, struct PTPText *t2) {
+ if (t1->length != t2->length)
+ return -1;
+ return memcmp(t1->text, t2->text, t1->length);
+}
+
+int cmp_record(struct FaultRecord *r1, struct FaultRecord *r2) {
+ if (cmp_timestamp(&r1->faultTime, &r2->faultTime)) return -1;
+ if (r1->severityCode != r2->severityCode) return -1;
+ if (cmp_ptptext(&r1->faultName, &r2->faultName)) return -1;
+ if (cmp_ptptext(&r1->faultValue, &r2->faultValue)) return -1;
+ if (cmp_ptptext(&r1->faultDescription, &r2->faultDescription)) return -1;
+ return 0;
+}
+
+int cmp_logs(struct FaultLog *l1, struct FaultLog *l2) {
+ int offset;
+ int i;
+ struct FaultRecord fault, *f;
+ struct FaultLog *t;
+ if (l1->type == l2->type) {
+ if (l1->type == FAULT_RECORD_BUFFER) {
+ /* both buffers */
+ if (l1->buffer.len != l2->buffer.len)
+ return -1;
+ return memcmp(l1->buffer.buf, l2->buffer.buf, l1->buffer.len);
+ } else {
+ /* both lists - this shouldn't occur in tests */
+ return -1;
+ }
+ } else {
+ /* one of each type */
+ if (l1->type == FAULT_RECORD_BUFFER) {
+ /* swap so l1 is always the list type */
+ t = l1;
+ l1 = l2;
+ l2 = t;
+ }
+
+ /* When fault records are written, if all of the
+ * records don't fit in the message then the records
+ * are skipped. How should the tests and comparison
+ * code account for that?
+ */
+ f = TAILQ_FIRST(&l1->list);
+ offset = 0;
+ for (i = 0; i < l2->numberRecords; i++) {
+ if (f == NULL) {
+ /* ran out of l1 records */
+ return -1;
+ }
+ offset += unpackFaultRecord(l2->buffer.buf + offset, &fault);
+ if (cmp_record(f, &fault))
+ return -1;
+ f = TAILQ_NEXT(f, entry);
+ }
+ if (f != NULL) {
+ /* ran out of l2 records */
+ return -1;
+ }
+ return 0;
+ }
+ return -1;
+}
+
+void set_text(struct PTPText *t, char *s) {
+ if (s) {
+ t->text = (uint8_t*)s;
+ t->length = strlen(s);
+ } else {
+ t->text = 0;
+ t->length = 0;
+ }
+}
+
+static int test_read(uint8_t *buf, int len, struct tlv *tlv, const char *msg) {
+ ok(len == tlv_read(buf, len, tlv), msg);
+ ok(tlv->mgmt.error == 0, "read successful");
+ return tlv->mgmt.error == 0;
+}
+
+
+int main() {
+ plan(18);
+
+ struct tlv tlv;
+ struct FaultLog *log = &tlv.mgmt.data.fl;
+
+ memset(&tlv, 0, sizeof(tlv));
+ tlv.type = TLV_MANAGEMENT;
+ tlv.mgmt.id = MGMT_FAULT_LOG;
+ log->numberRecords = 0;
+ log->type = FAULT_RECORD_LIST;
+ TAILQ_INIT(&log->list);
+
+ struct tlv recv_tlv;
+
+ uint8_t buf[1500];
+ int len;
+ len = tlv_write(&tlv, buf, sizeof(buf));
+ ok(len > 0, "write empty list log");
+
+ if (test_read(buf, len, &recv_tlv, "read empty log"))
+ ok(0 == cmp_logs(log, &recv_tlv.mgmt.data.fl), "empty logs match");
+ else
+ skip("can't compare after failed read");
+
+ log->type = FAULT_RECORD_BUFFER;
+ log->buffer.len = 0;
+ len = tlv_write(&tlv, buf, sizeof(buf));
+ ok(len > 0, "write empty buffer log");
+ printf("write=%d read=%d\n", len, tlv_read(buf, len, &recv_tlv));
+ if(test_read(buf, len, &recv_tlv, "read empty buffer log"))
+ ok(0 == cmp_logs(log, &recv_tlv.mgmt.data.fl), "empty logs match");
+ else
+ skip("can't compare after failed read");
+
+ struct FaultRecord r1, r2;
+ memset(&r1, 0, sizeof(r1));
+ memset(&r2, 0, sizeof(r2));
+
+ r1.severityCode = FAULT_ALERT;
+ set_text(&r1.faultName, "explosion");
+ set_text(&r1.faultValue, NULL);
+ set_text(&r1.faultValue, "lots of smoke");
+
+ log->type = FAULT_RECORD_LIST;
+ TAILQ_INIT(&log->list);
+ TAILQ_INSERT_TAIL(&log->list, &r1, entry);
+
+ len = tlv_write(&tlv, buf, sizeof(buf));
+ ok(len > 0, "write 1 log");
+
+ if (test_read(buf, len, &recv_tlv, "read log")) {
+ ok(recv_tlv.mgmt.data.fl.numberRecords == 1, "got 1 record");
+ ok(0 == cmp_logs(log, &recv_tlv.mgmt.data.fl), "1 record matches");
+ } else
+ skip_block(2, "can't compare after failed read");
+
+ r2.severityCode = FAULT_NOTICE;
+ set_text(&r2.faultName, "meal");
+ set_text(&r2.faultValue, "dinner");
+ set_text(&r2.faultValue, "fish and chips");
+ TAILQ_INSERT_TAIL(&log->list, &r2, entry);
+
+ len = tlv_write(&tlv, buf, sizeof(buf));
+ ok(len > 0, "write 2 logs");
+ if(test_read(buf, len, &recv_tlv, "read logs")) {
+ ok(recv_tlv.mgmt.data.fl.numberRecords == 2, "got 2 records");
+ ok(0 == cmp_logs(log, &recv_tlv.mgmt.data.fl), "2 record logs match");
+ } else
+ skip_block(2, "can't compare after failed read");
+ return 0;
+}
diff --git a/tests/makefile b/tests/makefile
new file mode 100644
index 0000000..318c011
--- /dev/null
+++ b/tests/makefile
@@ -0,0 +1,71 @@
+#
+# Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that 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.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+DEBUG =
+CC = $(CROSS_COMPILE)gcc
+INC = -I..
+CFLAGS = -Wall -Werror $(INC) $(DEBUG)$(EXTRA_CFLAGS)
+LDLIBS = $(EXTRA_LDFLAGS)
+
+PRG = runtests example-t childproc-t errors-t priority-t description-t faultlog-t
+
+OBJECTS = $(PRG:=.o) tap/basic.o testutil.o childproc.o mgmt.o
+SRC = $(OBJECTS:.o=.c)
+DEPEND = $(OBJECTS:.o=.d)
+srcdir := $(dir $(lastword $(MAKEFILE_LIST)))
+VPATH = $(srcdir)
+
+all: $(PRG)
+
+clean:
+ rm -f $(OBJECTS) $(DEPEND)
+
+distclean: clean
+ rm -f $(PRG)
+
+TEST_OBJS = testutil.o tap/basic.o childproc.o mgmt.o ../tlv.o
+
+example-t: example-t.o $(TEST_OBJS)
+childproc-t: childproc-t.o $(TEST_OBJS)
+errors-t: errors-t.o $(TEST_OBJS)
+priority-t: priority-t.o $(TEST_OBJS)
+description-t: description-t.o $(TEST_OBJS)
+faultlog-t: faultlog-t.o $(TEST_OBJS)
+
+#%-t.o: %-t.c
+# $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
+
+runtests: runtests.o
+# $(CC) -DSOURCE='"tests"' -DBUILD='"tests"' $< -o $@
+
+check: all
+ ./runtests TESTS
+
+
+# Implicit rule to generate a C source file's dependencies.
+%.d: %.c
+ @echo DEPEND $<; \
+ rm -f $@; \
+ $(CC) -MM $(CPPFLAGS) $(CFLAGS) $< > $@.$$$$; \
+ sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
+ rm -f $@.$$$$
+
+ifneq ($(MAKECMDGOALS), clean)
+ifneq ($(MAKECMDGOALS), distclean)
+-include $(DEPEND)
+endif
+endif
diff --git a/tests/mgmt.c b/tests/mgmt.c
new file mode 100644
index 0000000..f3d57f0
--- /dev/null
+++ b/tests/mgmt.c
@@ -0,0 +1,239 @@
+/**
+ * @file mgmt.c
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "mgmt.h"
+
+#include <string.h>
+
+#include "tlv_pack.h"
+#include "tlv.h"
+#include "msg.h"
+
+static const int size_msg_header = 1 + 1 + 2 + 1 + 1 + 2 + 8 + 4 + 10 + 2 + 1 + 1;
+static const int size_mgmt_msg = 10 + 1 + 1 + 1 + 1;
+
+static inline int packMsgHeader(const struct MsgHeader *data, Octet *buf) {
+ int offset = 0;
+ packNibbleUpper(&data->transportSpecific, buf + offset);
+ packEnumeration4Lower(&data->messageType, buf + offset);
+ offset += 1;
+ packReserved(buf + offset, 0);
+ packUInteger4Lower(&data->versionPTP, buf + offset);
+ offset += 1;
+ packUInteger16(&data->messageLength, buf + offset);
+ offset += 2;
+ packUInteger8(&data->domainNumber, buf + offset);
+ offset += 1;
+ packReserved(buf + offset, 1);
+ offset += 1;
+ packOctetArray(data->flagField, buf + offset, 2);
+ offset += 2;
+ packInteger64(&data->correctionField, buf + offset);
+ offset += 8;
+ packReserved(buf + offset, 4);
+ offset += 4;
+ packPortIdentity(&data->sourcePortIdentity, buf + offset);
+ offset += 10;
+ packUInteger16(&data->sequenceId, buf + offset);
+ offset += 2;
+ packUInteger8(&data->controlField, buf + offset);
+ offset += 1;
+ packInteger8(&data->logMessageInterval, buf + offset);
+ offset += 1;
+ return offset;
+}
+
+static inline int packManagementMsg(const struct ManagementMsg *data, Octet *buf) {
+ int offset = 0;
+ packPortIdentity(&data->targetPortIdentity, buf + offset);
+ offset += 10;
+ packUInteger8(&data->startingBoundaryHops, buf + offset);
+ offset += 1;
+ packUInteger8(&data->boundaryHops, buf + offset);
+ offset += 1;
+ packReserved(buf + offset, 0);
+ packEnumeration4Lower(&data->actionField, buf + offset);
+ offset += 1;
+ packReserved(buf + offset, 1);
+ offset += 1;
+ return offset;
+}
+
+static inline int unpackManagementMsg(const Octet *buf, struct ManagementMsg *data) {
+ int offset = 0;
+ unpackPortIdentity(buf + offset, &data->targetPortIdentity);
+ offset += 10;
+ unpackUInteger8(buf + offset, &data->startingBoundaryHops);
+ offset += 1;
+ unpackUInteger8(buf + offset, &data->boundaryHops);
+ offset += 1;
+ unpackEnumeration4Lower(buf + offset, &data->actionField);
+ offset += 1;
+ offset += 1;
+ return offset;
+}
+
+static inline int unpackMsgHeader(const Octet *buf, struct MsgHeader *data) {
+ int offset = 0;
+ unpackNibbleUpper(buf + offset, &data->transportSpecific);
+ unpackEnumeration4Lower(buf + offset, &data->messageType);
+ offset += 1;
+ unpackUInteger4Lower(buf + offset, &data->versionPTP);
+ offset += 1;
+ unpackUInteger16(buf + offset, &data->messageLength);
+ offset += 2;
+ unpackUInteger8(buf + offset, &data->domainNumber);
+ offset += 1;
+ offset += 1;
+ unpackOctetArray(buf + offset, data->flagField, 2);
+ offset += 2;
+ unpackInteger64(buf + offset, &data->correctionField);
+ offset += 8;
+ offset += 4;
+ unpackPortIdentity(buf + offset, &data->sourcePortIdentity);
+ offset += 10;
+ unpackUInteger16(buf + offset, &data->sequenceId);
+ offset += 2;
+ unpackUInteger8(buf + offset, &data->controlField);
+ offset += 1;
+ unpackInteger8(buf + offset, &data->logMessageInterval);
+ offset += 1;
+ return offset;
+}
+
+static void msg_hdr_init(struct MsgHeader *hdr) {
+ hdr->transportSpecific = 0;
+ hdr->messageType = MSG_MANAGEMENT;
+ hdr->versionPTP = 2;
+ /* hdr->messageLength = 0; is set when writing */
+ hdr->domainNumber = 0;
+ hdr->flagField[0] = 0;
+ hdr->flagField[1] = 0;
+ hdr->correctionField = 0;
+ memset(&hdr->sourcePortIdentity.clockIdentity, 0,
+ sizeof(struct ClockIdentity));
+ hdr->sourcePortIdentity.portNumber = 0;
+ hdr->sequenceId = 0;
+ hdr->controlField = CONTROL_MANAGEMENT;
+ hdr->logMessageInterval = 0x7F;
+}
+
+static void msg_init(struct mgmt_msg *m, uint8_t hops, enum management_actions action) {
+ memset(m, 0, sizeof(*m));
+ msg_hdr_init(&m->hdr);
+ /* use the wildcard clock identity by default */
+ memset(&m->msg.targetPortIdentity.clockIdentity, 0xFF, CLOCK_IDENTITY_LENGTH);
+ /* use the wildcard port identity by default */
+ m->msg.targetPortIdentity.portNumber = 0xFFFF;
+ m->msg.startingBoundaryHops = hops;
+ m->msg.boundaryHops = hops;
+ m->msg.actionField = action;
+ /* m->tlv.lengthField = 0; is set when writing */
+}
+
+void mgmt_msg_init(struct mgmt_msg *m, enum management_actions action,
+ enum management_types type)
+{
+ msg_init(m, 0, action);
+ m->tlv.type = TLV_MANAGEMENT;
+ m->tlv.mgmt.id = type;
+ m->tlv.mgmt.empty_body = action == ACTION_GET;
+}
+
+void mgmt_error_msg_init(struct mgmt_msg *m,
+ enum management_actions action,
+ enum management_error_types error,
+ enum management_types type)
+{
+ msg_init(m, 0, action);
+ m->tlv.type = TLV_MANAGEMENT_ERROR_STATUS;
+ m->tlv.error.managementErrorId = error;
+ m->tlv.error.managementId = type;
+}
+
+int mgmt_write_msg(struct mgmt_msg *msg, uint8_t *buf, int len) {
+ int offset;
+ int result;
+ if (msg->hdr.messageType != MSG_MANAGEMENT) {
+ return -1;
+ }
+
+ len -= size_msg_header + size_mgmt_msg;
+ if (len < 0)
+ return -1;
+
+ offset = packMsgHeader(&msg->hdr, buf);
+ offset += packManagementMsg(&msg->msg, buf + offset);
+
+ /* write single TLV */
+ result = tlv_write(&msg->tlv, buf + offset, len - offset);
+ if (result < 0)
+ return -1;
+
+ offset += result;
+
+ /* update message length in both the msg struct and
+ * written buffer.
+ */
+ msg->hdr.messageLength = offset;
+ packUInteger16(&msg->hdr.messageLength, buf + 2);
+ return offset;
+}
+
+int mgmt_read_msg(uint8_t *buf, int len, struct mgmt_msg *msg) {
+ int result;
+ int offset = unpackMsgHeader(buf, &msg->hdr);
+ if (offset > len) return -1;
+ if (msg->hdr.messageType != MSG_MANAGEMENT) return -1;
+ offset += unpackManagementMsg(buf + offset, &msg->msg);
+ if (offset > len) return -1;
+
+ /* read a single TLV */
+ result = tlv_read(buf + offset, len - offset, &msg->tlv);
+ if (result < 0)
+ return -1;
+
+ switch (msg->tlv.type) {
+ case TLV_MANAGEMENT:
+ if (tlv_check_mgmt_action(msg->msg.actionField, msg->tlv.mgmt.id) != 1) {
+ return -1;
+ }
+ if (msg->tlv.mgmt.empty_body && msg->tlv.mgmt.id != MGMT_NULL_MANAGEMENT) {
+ if (msg->msg.actionField == ACTION_SET ||
+ msg->msg.actionField == ACTION_RESPONSE) {
+ /* SET and RESPONSE must have bodies */
+ return -1;
+ }
+ }
+ break;
+ case TLV_MANAGEMENT_ERROR_STATUS:
+ if (msg->msg.actionField != ACTION_RESPONSE &&
+ msg->msg.actionField != ACTION_ACKNOWLEDGE) {
+ return -1;
+ }
+ break;
+ default:
+ return -1;
+ }
+
+ offset += result;
+ /* require that whole buffer is read */
+ if (offset != len)
+ return -1;
+ return offset;
+}
diff --git a/tests/mgmt.h b/tests/mgmt.h
new file mode 100644
index 0000000..1f3067d
--- /dev/null
+++ b/tests/mgmt.h
@@ -0,0 +1,68 @@
+/**
+ * @file mgmt.h
+ * @brief Utils for reading/writing management messages
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef HAVE_TESTS_MGMT_H
+#define HAVE_TESTS_MGMT_H
+
+#include "tlv.h"
+#include "ds.h"
+
+struct MsgHeader {
+ Nibble transportSpecific;
+ Enumeration4 messageType;
+ UInteger4 versionPTP;
+ UInteger16 messageLength;
+ UInteger8 domainNumber;
+ Octet flagField[2];
+ Integer64 correctionField;
+ struct PortIdentity sourcePortIdentity;
+ UInteger16 sequenceId;
+ UInteger8 controlField;
+ Integer8 logMessageInterval;
+};
+
+struct ManagementMsg {
+ struct PortIdentity targetPortIdentity;
+ UInteger8 startingBoundaryHops;
+ UInteger8 boundaryHops;
+ Enumeration4 actionField;
+};
+
+struct mgmt_msg {
+ struct MsgHeader hdr;
+ struct ManagementMsg msg;
+
+ /* Manangement messages contain 1 TLV. Assume profiles don't
+ * add TLVs to management messages. */
+ struct tlv tlv;
+};
+
+void mgmt_msg_init(struct mgmt_msg *m,
+ enum management_actions action,
+ enum management_types type);
+
+void mgmt_error_msg_init(struct mgmt_msg *m,
+ enum management_actions action,
+ enum management_error_types error,
+ enum management_types type);
+
+int mgmt_write_msg(struct mgmt_msg *msg, uint8_t *buf, int len);
+int mgmt_read_msg(uint8_t *buf, int len, struct mgmt_msg *msg);
+
+#endif
diff --git a/tests/priority-t.c b/tests/priority-t.c
new file mode 100644
index 0000000..d958681
--- /dev/null
+++ b/tests/priority-t.c
@@ -0,0 +1,39 @@
+/**
+ * @file priority-t.c
+ * @brief Tests management PRIORITY1 messages
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "tap/basic.h"
+#include "testutil.h"
+
+
+const char *config =
+"[global]\n\
+priority1 42\n\
+";
+
+int main() {
+ struct childproc *proc = test_childproc(config);
+ plan(2);
+
+ struct mgmt_msg out;
+ struct mgmt_msg in;
+ mgmt_msg_init(&out, ACTION_GET, MGMT_PRIORITY1);
+ ok(childproc_send_recv(proc, &out, &in) == 0, "send and recv GET");
+ ok(in.tlv.mgmt.data.dds.priority1 == 42, "priority1 is 42 as in config");
+ return 0;
+}
diff --git a/tests/runtests.c b/tests/runtests.c
new file mode 100644
index 0000000..c361def
--- /dev/null
+++ b/tests/runtests.c
@@ -0,0 +1,1204 @@
+/*
+ * Run a set of tests, reporting results.
+ *
+ * Usage:
+ *
+ * runtests [-b <build-dir>] [-s <source-dir>] <test-list>
+ * runtests -o [-b <build-dir>] [-s <source-dir>] <test>
+ *
+ * In the first case, expects a list of executables located in the given file,
+ * one line per executable. For each one, runs it as part of a test suite,
+ * reporting results. Test output should start with a line containing the
+ * number of tests (numbered from 1 to this number), optionally preceded by
+ * "1..", although that line may be given anywhere in the output. Each
+ * additional line should be in the following format:
+ *
+ * ok <number>
+ * not ok <number>
+ * ok <number> # skip
+ * not ok <number> # todo
+ *
+ * where <number> is the number of the test. An optional comment is permitted
+ * after the number if preceded by whitespace. ok indicates success, not ok
+ * indicates failure. "# skip" and "# todo" are a special cases of a comment,
+ * and must start with exactly that formatting. They indicate the test was
+ * skipped for some reason (maybe because it doesn't apply to this platform)
+ * or is testing something known to currently fail. The text following either
+ * "# skip" or "# todo" and whitespace is the reason.
+ *
+ * As a special case, the first line of the output may be in the form:
+ *
+ * 1..0 # skip some reason
+ *
+ * which indicates that this entire test case should be skipped and gives a
+ * reason.
+ *
+ * Any other lines are ignored, although for compliance with the TAP protocol
+ * all lines other than the ones in the above format should be sent to
+ * standard error rather than standard output and start with #.
+ *
+ * This is a subset of TAP as documented in Test::Harness::TAP or
+ * TAP::Parser::Grammar, which comes with Perl.
+ *
+ * If the -o option is given, instead run a single test and display all of its
+ * output. This is intended for use with failing tests so that the person
+ * running the test suite can get more details about what failed.
+ *
+ * If built with the C preprocessor symbols SOURCE and BUILD defined, C TAP
+ * Harness will export those values in the environment so that tests can find
+ * the source and build directory and will look for tests under both
+ * directories. These paths can also be set with the -b and -s command-line
+ * options, which will override anything set at build time.
+ *
+ * Any bug reports, bug fixes, and improvements are very much welcome and
+ * should be sent to the e-mail address below. This program is part of C TAP
+ * Harness <http://www.eyrie.org/~eagle/software/c-tap-harness/>.
+ *
+ * Copyright 2000, 2001, 2004, 2006, 2007, 2008, 2009, 2010, 2011
+ * Russ Allbery <***@stanford.edu>
+ *
+ * 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.
+*/
+
+/* Required for fdopen(), getopt(), and putenv(). */
+#if defined(__STRICT_ANSI__) || defined(PEDANTIC)
+# ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 500
+# endif
+#endif
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <time.h>
+#include <unistd.h>
+
+/* sys/time.h must be included before sys/resource.h on some platforms. */
+#include <sys/resource.h>
+
+/* AIX doesn't have WCOREDUMP. */
+#ifndef WCOREDUMP
+# define WCOREDUMP(status) ((unsigned)(status) & 0x80)
+#endif
+
+/*
+ * The source and build versions of the tests directory. This is used to set
+ * the SOURCE and BUILD environment variables and find test programs, if set.
+ * Normally, this should be set as part of the build process to the test
+ * subdirectories of $(abs_top_srcdir) and $(abs_top_builddir) respectively.
+ */
+#ifndef SOURCE
+# define SOURCE NULL
+#endif
+#ifndef BUILD
+# define BUILD NULL
+#endif
+
+/* Test status codes. */
+enum test_status {
+ TEST_FAIL,
+ TEST_PASS,
+ TEST_SKIP,
+ TEST_INVALID
+};
+
+/* Indicates the state of our plan. */
+enum plan_status {
+ PLAN_INIT, /* Nothing seen yet. */
+ PLAN_FIRST, /* Plan seen before any tests. */
+ PLAN_PENDING, /* Test seen and no plan yet. */
+ PLAN_FINAL /* Plan seen after some tests. */
+};
+
+/* Error exit statuses for test processes. */
+#define CHILDERR_DUP 100 /* Couldn't redirect stderr or stdout. */
+#define CHILDERR_EXEC 101 /* Couldn't exec child process. */
+#define CHILDERR_STDERR 102 /* Couldn't open stderr file. */
+
+/* Structure to hold data for a set of tests. */
+struct testset {
+ char *file; /* The file name of the test. */
+ char *path; /* The path to the test program. */
+ enum plan_status plan; /* The status of our plan. */
+ unsigned long count; /* Expected count of tests. */
+ unsigned long current; /* The last seen test number. */
+ unsigned int length; /* The length of the last status message. */
+ unsigned long passed; /* Count of passing tests. */
+ unsigned long failed; /* Count of failing lists. */
+ unsigned long skipped; /* Count of skipped tests (passed). */
+ unsigned long allocated; /* The size of the results table. */
+ enum test_status *results; /* Table of results by test number. */
+ unsigned int aborted; /* Whether the set as aborted. */
+ int reported; /* Whether the results were reported. */
+ int status; /* The exit status of the test. */
+ unsigned int all_skipped; /* Whether all tests were skipped. */
+ char *reason; /* Why all tests were skipped. */
+
+ struct testset *next;
+};
+
+/* Structure to hold a linked list of test sets. */
+struct testlist {
+ struct testset *ts;
+ struct testlist *next;
+};
+
+/*
+ * Usage message. Should be used as a printf format with two arguments: the
+ * path to runtests, given twice.
+ */
+static const char usage_message[] = "\
+Usage: %s [-b <build-dir>] [-s <source-dir>] <test-list>\n\
+ %s -o [-b <build-dir>] [-s <source-dir>] <test>\n\
+\n\
+Options:\n\
+ -b <build-dir> Set the build directory to <build-dir>\n\
+ -o Run a single test rather than a list of tests\n\
+ -s <source-dir> Set the source directory to <source-dir>\n\
+\n\
+runtests normally runs each test listed in a file whose path is given as\n\
+its command-line argument. With the -o option, it instead runs a single\n\
+test and shows its complete output.\n";
+
+/*
+ * Header used for test output. %s is replaced by the file name of the list
+ * of tests.
+ */
+static const char banner[] = "\n\
+Running all tests listed in %s. If any tests fail, run the failing\n\
+test program with runtests -o to see more details.\n\n";
+
+/* Header for reports of failed tests. */
+static const char header[] = "\n\
+Failed Set Fail/Total (%) Skip Stat Failing Tests\n\
+-------------------------- -------------- ---- ---- ------------------------";
+
+/* Include the file name and line number in malloc failures. */
+#define xmalloc(size) x_malloc((size), __FILE__, __LINE__)
+#define xrealloc(p, size) x_realloc((p), (size), __FILE__, __LINE__)
+#define xstrdup(p) x_strdup((p), __FILE__, __LINE__)
+
+
+/*
+ * Report a fatal error, including the results of strerror, and exit.
+ */
+static void
+sysdie(const char *format, ...)
+{
+ int oerrno;
+ va_list args;
+
+ oerrno = errno;
+ fflush(stdout);
+ fprintf(stderr, "runtests: ");
+ va_start(args, format);
+ vfprintf(stderr, format, args);
+ va_end(args);
+ fprintf(stderr, ": %s\n", strerror(oerrno));
+ exit(1);
+}
+
+
+/*
+ * Allocate memory, reporting a fatal error and exiting on failure.
+ */
+static void *
+x_malloc(size_t size, const char *file, int line)
+{
+ void *p;
+
+ p = malloc(size);
+ if (p == NULL)
+ sysdie("failed to malloc %lu bytes at %s line %d",
+ (unsigned long) size, file, line);
+ return p;
+}
+
+
+/*
+ * Reallocate memory, reporting a fatal error and exiting on failure.
+ */
+static void *
+x_realloc(void *p, size_t size, const char *file, int line)
+{
+ p = realloc(p, size);
+ if (p == NULL)
+ sysdie("failed to realloc %lu bytes at %s line %d",
+ (unsigned long) size, file, line);
+ return p;
+}
+
+
+/*
+ * Copy a string, reporting a fatal error and exiting on failure.
+ */
+static char *
+x_strdup(const char *s, const char *file, int line)
+{
+ char *p;
+ size_t len;
+
+ len = strlen(s) + 1;
+ p = malloc(len);
+ if (p == NULL)
+ sysdie("failed to strdup %lu bytes at %s line %d",
+ (unsigned long) len, file, line);
+ memcpy(p, s, len);
+ return p;
+}
+
+
+/*
+ * Given a struct timeval, return the number of seconds it represents as a
+ * double. Use difftime() to convert a time_t to a double.
+ */
+static double
+tv_seconds(const struct timeval *tv)
+{
+ return difftime(tv->tv_sec, 0) + tv->tv_usec * 1e-6;
+}
+
+
+/*
+ * Given two struct timevals, return the difference in seconds.
+ */
+static double
+tv_diff(const struct timeval *tv1, const struct timeval *tv0)
+{
+ return tv_seconds(tv1) - tv_seconds(tv0);
+}
+
+
+/*
+ * Given two struct timevals, return the sum in seconds as a double.
+ */
+static double
+tv_sum(const struct timeval *tv1, const struct timeval *tv2)
+{
+ return tv_seconds(tv1) + tv_seconds(tv2);
+}
+
+
+/*
+ * Given a pointer to a string, skip any leading whitespace and return a
+ * pointer to the first non-whitespace character.
+ */
+static const char *
+skip_whitespace(const char *p)
+{
+ while (isspace((unsigned char)(*p)))
+ p++;
+ return p;
+}
+
+
+/*
+ * Start a program, connecting its stdout to a pipe on our end and its stderr
+ * to /dev/null, and storing the file descriptor to read from in the two
+ * argument. Returns the PID of the new process. Errors are fatal.
+ */
+static pid_t
+test_start(const char *path, int *fd)
+{
+ int fds[2], errfd;
+ pid_t child;
+
+ if (pipe(fds) == -1) {
+ puts("ABORTED");
+ fflush(stdout);
+ sysdie("can't create pipe");
+ }
+ child = fork();
+ if (child == (pid_t) -1) {
+ puts("ABORTED");
+ fflush(stdout);
+ sysdie("can't fork");
+ } else if (child == 0) {
+ /* In child. Set up our stdout and stderr. */
+ errfd = open("/dev/null", O_WRONLY);
+ if (errfd < 0)
+ _exit(CHILDERR_STDERR);
+ if (dup2(errfd, 2) == -1)
+ _exit(CHILDERR_DUP);
+ close(fds[0]);
+ if (dup2(fds[1], 1) == -1)
+ _exit(CHILDERR_DUP);
+
+ /* Now, exec our process. */
+ if (execl(path, path, (char *) 0) == -1)
+ _exit(CHILDERR_EXEC);
+ } else {
+ /* In parent. Close the extra file descriptor. */
+ close(fds[1]);
+ }
+ *fd = fds[0];
+ return child;
+}
+
+
+/*
+ * Back up over the output saying what test we were executing.
+ */
+static void
+test_backspace(struct testset *ts)
+{
+ unsigned int i;
+
+ if (!isatty(STDOUT_FILENO))
+ return;
+ for (i = 0; i < ts->length; i++)
+ putchar('\b');
+ for (i = 0; i < ts->length; i++)
+ putchar(' ');
+ for (i = 0; i < ts->length; i++)
+ putchar('\b');
+ ts->length = 0;
+}
+
+
+/*
+ * Read the plan line of test output, which should contain the range of test
+ * numbers. We may initialize the testset structure here if we haven't yet
+ * seen a test. Return true if initialization succeeded and the test should
+ * continue, false otherwise.
+ */
+static int
+test_plan(const char *line, struct testset *ts)
+{
+ unsigned long i;
+ long n;
+
+ /*
+ * Accept a plan without the leading 1.. for compatibility with older
+ * versions of runtests. This will only be allowed if we've not yet seen
+ * a test result.
+ */
+ line = skip_whitespace(line);
+ if (strncmp(line, "1..", 3) == 0)
+ line += 3;
+
+ /*
+ * Get the count, check it for validity, and initialize the struct. If we
+ * have something of the form "1..0 # skip foo", the whole file was
+ * skipped; record that. If we do skip the whole file, zero out all of
+ * our statistics, since they're no longer relevant. strtol is called
+ * with a second argument to advance the line pointer past the count to
+ * make it simpler to detect the # skip case.
+ */
+ n = strtol(line, (char **) &line, 10);
+ if (n == 0) {
+ line = skip_whitespace(line);
+ if (*line == '#') {
+ line = skip_whitespace(line + 1);
+ if (strncasecmp(line, "skip", 4) == 0) {
+ line = skip_whitespace(line + 4);
+ if (*line != '\0') {
+ ts->reason = xstrdup(line);
+ ts->reason[strlen(ts->reason) - 1] = '\0';
+ }
+ ts->all_skipped = 1;
+ ts->aborted = 1;
+ ts->count = 0;
+ ts->passed = 0;
+ ts->skipped = 0;
+ ts->failed = 0;
+ return 0;
+ }
+ }
+ }
+ if (n <= 0) {
+ puts("ABORTED (invalid test count)");
+ ts->aborted = 1;
+ ts->reported = 1;
+ return 0;
+ }
+ if (ts->plan == PLAN_INIT && ts->allocated == 0) {
+ ts->count = n;
+ ts->allocated = n;
+ ts->plan = PLAN_FIRST;
+ ts->results = xmalloc(ts->count * sizeof(enum test_status));
+ for (i = 0; i < ts->count; i++)
+ ts->results[i] = TEST_INVALID;
+ } else if (ts->plan == PLAN_PENDING) {
+ if ((unsigned long) n < ts->count) {
+ printf("ABORTED (invalid test number %lu)\n", ts->count);
+ ts->aborted = 1;
+ ts->reported = 1;
+ return 0;
+ }
+ ts->count = n;
+ if ((unsigned long) n > ts->allocated) {
+ ts->results = xrealloc(ts->results, n * sizeof(enum test_status));
+ for (i = ts->allocated; i < ts->count; i++)
+ ts->results[i] = TEST_INVALID;
+ ts->allocated = n;
+ }
+ ts->plan = PLAN_FINAL;
+ }
+ return 1;
+}
+
+
+/*
+ * Given a single line of output from a test, parse it and return the success
+ * status of that test. Anything printed to stdout not matching the form
+ * /^(not )?ok \d+/ is ignored. Sets ts->current to the test number that just
+ * reported status.
+ */
+static void
+test_checkline(const char *line, struct testset *ts)
+{
+ enum test_status status = TEST_PASS;
+ const char *bail;
+ char *end;
+ long number;
+ unsigned long i, current;
+ int outlen;
+
+ /* Before anything, check for a test abort. */
+ bail = strstr(line, "Bail out!");
+ if (bail != NULL) {
+ bail = skip_whitespace(bail + strlen("Bail out!"));
+ if (*bail != '\0') {
+ size_t length;
+
+ length = strlen(bail);
+ if (bail[length - 1] == '\n')
+ length--;
+ test_backspace(ts);
+ printf("ABORTED (%.*s)\n", (int) length, bail);
+ ts->reported = 1;
+ }
+ ts->aborted = 1;
+ return;
+ }
+
+ /*
+ * If the given line isn't newline-terminated, it was too big for an
+ * fgets(), which means ignore it.
+ */
+ if (line[strlen(line) - 1] != '\n')
+ return;
+
+ /* If the line begins with a hash mark, ignore it. */
+ if (line[0] == '#')
+ return;
+
+ /* If we haven't yet seen a plan, look for one. */
+ if (ts->plan == PLAN_INIT && isdigit((unsigned char)(*line))) {
+ if (!test_plan(line, ts))
+ return;
+ } else if (strncmp(line, "1..", 3) == 0) {
+ if (ts->plan == PLAN_PENDING) {
+ if (!test_plan(line, ts))
+ return;
+ } else {
+ puts("ABORTED (multiple plans)");
+ ts->aborted = 1;
+ ts->reported = 1;
+ return;
+ }
+ }
+
+ /* Parse the line, ignoring something we can't parse. */
+ if (strncmp(line, "not ", 4) == 0) {
+ status = TEST_FAIL;
+ line += 4;
+ }
+ if (strncmp(line, "ok", 2) != 0)
+ return;
+ line = skip_whitespace(line + 2);
+ errno = 0;
+ number = strtol(line, &end, 10);
+ if (errno != 0 || end == line)
+ number = ts->current + 1;
+ current = number;
+ if (number <= 0 || (current > ts->count && ts->plan == PLAN_FIRST)) {
+ test_backspace(ts);
+ printf("ABORTED (invalid test number %lu)\n", current);
+ ts->aborted = 1;
+ ts->reported = 1;
+ return;
+ }
+
+ /* We have a valid test result. Tweak the results array if needed. */
+ if (ts->plan == PLAN_INIT || ts->plan == PLAN_PENDING) {
+ ts->plan = PLAN_PENDING;
+ if (current > ts->count)
+ ts->count = current;
+ if (current > ts->allocated) {
+ unsigned long n;
+
+ n = (ts->allocated == 0) ? 32 : ts->allocated * 2;
+ if (n < current)
+ n = current;
+ ts->results = xrealloc(ts->results, n * sizeof(enum test_status));
+ for (i = ts->allocated; i < n; i++)
+ ts->results[i] = TEST_INVALID;
+ ts->allocated = n;
+ }
+ }
+
+ /*
+ * Handle directives. We should probably do something more interesting
+ * with unexpected passes of todo tests.
+ */
+ while (isdigit((unsigned char)(*line)))
+ line++;
+ line = skip_whitespace(line);
+ if (*line == '#') {
+ line = skip_whitespace(line + 1);
+ if (strncasecmp(line, "skip", 4) == 0)
+ status = TEST_SKIP;
+ if (strncasecmp(line, "todo", 4) == 0)
+ status = (status == TEST_FAIL) ? TEST_SKIP : TEST_FAIL;
+ }
+
+ /* Make sure that the test number is in range and not a duplicate. */
+ if (ts->results[current - 1] != TEST_INVALID) {
+ test_backspace(ts);
+ printf("ABORTED (duplicate test number %lu)\n", current);
+ ts->aborted = 1;
+ ts->reported = 1;
+ return;
+ }
+
+ /* Good results. Increment our various counters. */
+ switch (status) {
+ case TEST_PASS: ts->passed++; break;
+ case TEST_FAIL: ts->failed++; break;
+ case TEST_SKIP: ts->skipped++; break;
+ case TEST_INVALID: break;
+ }
+ ts->current = current;
+ ts->results[current - 1] = status;
+ test_backspace(ts);
+ if (isatty(STDOUT_FILENO)) {
+ outlen = printf("%lu/%lu", current, ts->count);
+ ts->length = (outlen >= 0) ? outlen : 0;
+ fflush(stdout);
+ }
+}
+
+
+/*
+ * Print out a range of test numbers, returning the number of characters it
+ * took up. Takes the first number, the last number, the number of characters
+ * already printed on the line, and the limit of number of characters the line
+ * can hold. Add a comma and a space before the range if chars indicates that
+ * something has already been printed on the line, and print ... instead if
+ * chars plus the space needed would go over the limit (use a limit of 0 to
+ * disable this).
+ */
+static unsigned int
+test_print_range(unsigned long first, unsigned long last, unsigned int chars,
+ unsigned int limit)
+{
+ unsigned int needed = 0;
+ unsigned long n;
+
+ for (n = first; n > 0; n /= 10)
+ needed++;
+ if (last > first) {
+ for (n = last; n > 0; n /= 10)
+ needed++;
+ needed++;
+ }
+ if (chars > 0)
+ needed += 2;
+ if (limit > 0 && chars + needed > limit) {
+ needed = 0;
+ if (chars <= limit) {
+ if (chars > 0) {
+ printf(", ");
+ needed += 2;
+ }
+ printf("...");
+ needed += 3;
+ }
+ } else {
+ if (chars > 0)
+ printf(", ");
+ if (last > first)
+ printf("%lu-", first);
+ printf("%lu", last);
+ }
+ return needed;
+}
+
+
+/*
+ * Summarize a single test set. The second argument is 0 if the set exited
+ * cleanly, a positive integer representing the exit status if it exited
+ * with a non-zero status, and a negative integer representing the signal
+ * that terminated it if it was killed by a signal.
+ */
+static void
+test_summarize(struct testset *ts, int status)
+{
+ unsigned long i;
+ unsigned long missing = 0;
+ unsigned long failed = 0;
+ unsigned long first = 0;
+ unsigned long last = 0;
+
+ if (ts->aborted) {
+ fputs("ABORTED", stdout);
+ if (ts->count > 0)
+ printf(" (passed %lu/%lu)", ts->passed, ts->count - ts->skipped);
+ } else {
+ for (i = 0; i < ts->count; i++) {
+ if (ts->results[i] == TEST_INVALID) {
+ if (missing == 0)
+ fputs("MISSED ", stdout);
+ if (first && i == last)
+ last = i + 1;
+ else {
+ if (first)
+ test_print_range(first, last, missing - 1, 0);
+ missing++;
+ first = i + 1;
+ last = i + 1;
+ }
+ }
+ }
+ if (first)
+ test_print_range(first, last, missing - 1, 0);
+ first = 0;
+ last = 0;
+ for (i = 0; i < ts->count; i++) {
+ if (ts->results[i] == TEST_FAIL) {
+ if (missing && !failed)
+ fputs("; ", stdout);
+ if (failed == 0)
+ fputs("FAILED ", stdout);
+ if (first && i == last)
+ last = i + 1;
+ else {
+ if (first)
+ test_print_range(first, last, failed - 1, 0);
+ failed++;
+ first = i + 1;
+ last = i + 1;
+ }
+ }
+ }
+ if (first)
+ test_print_range(first, last, failed - 1, 0);
+ if (!missing && !failed) {
+ fputs(!status ? "ok" : "dubious", stdout);
+ if (ts->skipped > 0) {
+ if (ts->skipped == 1)
+ printf(" (skipped %lu test)", ts->skipped);
+ else
+ printf(" (skipped %lu tests)", ts->skipped);
+ }
+ }
+ }
+ if (status > 0)
+ printf(" (exit status %d)", status);
+ else if (status < 0)
+ printf(" (killed by signal %d%s)", -status,
+ WCOREDUMP(ts->status) ? ", core dumped" : "");
+ putchar('\n');
+}
+
+
+/*
+ * Given a test set, analyze the results, classify the exit status, handle a
+ * few special error messages, and then pass it along to test_summarize() for
+ * the regular output. Returns true if the test set ran successfully and all
+ * tests passed or were skipped, false otherwise.
+ */
+static int
+test_analyze(struct testset *ts)
+{
+ if (ts->reported)
+ return 0;
+ if (ts->all_skipped) {
+ if (ts->reason == NULL)
+ puts("skipped");
+ else
+ printf("skipped (%s)\n", ts->reason);
+ return 1;
+ } else if (WIFEXITED(ts->status) && WEXITSTATUS(ts->status) != 0) {
+ switch (WEXITSTATUS(ts->status)) {
+ case CHILDERR_DUP:
+ if (!ts->reported)
+ puts("ABORTED (can't dup file descriptors)");
+ break;
+ case CHILDERR_EXEC:
+ if (!ts->reported)
+ puts("ABORTED (execution failed -- not found?)");
+ break;
+ case CHILDERR_STDERR:
+ if (!ts->reported)
+ puts("ABORTED (can't open /dev/null)");
+ break;
+ default:
+ test_summarize(ts, WEXITSTATUS(ts->status));
+ break;
+ }
+ return 0;
+ } else if (WIFSIGNALED(ts->status)) {
+ test_summarize(ts, -WTERMSIG(ts->status));
+ return 0;
+ } else if (ts->plan != PLAN_FIRST && ts->plan != PLAN_FINAL) {
+ puts("ABORTED (no valid test plan)");
+ ts->aborted = 1;
+ return 0;
+ } else {
+ test_summarize(ts, 0);
+ return (ts->failed == 0);
+ }
+}
+
+
+/*
+ * Runs a single test set, accumulating and then reporting the results.
+ * Returns true if the test set was successfully run and all tests passed,
+ * false otherwise.
+ */
+static int
+test_run(struct testset *ts)
+{
+ pid_t testpid, child;
+ int outfd, status;
+ unsigned long i;
+ FILE *output;
+ char buffer[BUFSIZ];
+
+ /* Run the test program. */
+ testpid = test_start(ts->path, &outfd);
+ output = fdopen(outfd, "r");
+ if (!output) {
+ puts("ABORTED");
+ fflush(stdout);
+ sysdie("fdopen failed");
+ }
+
+ /* Pass each line of output to test_checkline(). */
+ while (!ts->aborted && fgets(buffer, sizeof(buffer), output))
+ test_checkline(buffer, ts);
+ if (ferror(output) || ts->plan == PLAN_INIT)
+ ts->aborted = 1;
+ test_backspace(ts);
+
+ /*
+ * Consume the rest of the test output, close the output descriptor,
+ * retrieve the exit status, and pass that information to test_analyze()
+ * for eventual output.
+ */
+ while (fgets(buffer, sizeof(buffer), output))
+ ;
+ fclose(output);
+ child = waitpid(testpid, &ts->status, 0);
+ if (child == (pid_t) -1) {
+ if (!ts->reported) {
+ puts("ABORTED");
+ fflush(stdout);
+ }
+ sysdie("waitpid for %u failed", (unsigned int) testpid);
+ }
+ if (ts->all_skipped)
+ ts->aborted = 0;
+ status = test_analyze(ts);
+
+ /* Convert missing tests to failed tests. */
+ for (i = 0; i < ts->count; i++) {
+ if (ts->results[i] == TEST_INVALID) {
+ ts->failed++;
+ ts->results[i] = TEST_FAIL;
+ status = 0;
+ }
+ }
+ return status;
+}
+
+
+/* Summarize a list of test failures. */
+static void
+test_fail_summary(const struct testlist *fails)
+{
+ struct testset *ts;
+ unsigned int chars;
+ unsigned long i, first, last, total;
+
+ puts(header);
+
+ /* Failed Set Fail/Total (%) Skip Stat Failing (25)
+ -------------------------- -------------- ---- ---- -------------- */
+ for (; fails; fails = fails->next) {
+ ts = fails->ts;
+ total = ts->count - ts->skipped;
+ printf("%-26.26s %4lu/%-4lu %3.0f%% %4lu ", ts->file, ts->failed,
+ total, total ? (ts->failed * 100.0) / total : 0,
+ ts->skipped);
+ if (WIFEXITED(ts->status))
+ printf("%4d ", WEXITSTATUS(ts->status));
+ else
+ printf(" -- ");
+ if (ts->aborted) {
+ puts("aborted");
+ continue;
+ }
+ chars = 0;
+ first = 0;
+ last = 0;
+ for (i = 0; i < ts->count; i++) {
+ if (ts->results[i] == TEST_FAIL) {
+ if (first != 0 && i == last)
+ last = i + 1;
+ else {
+ if (first != 0)
+ chars += test_print_range(first, last, chars, 19);
+ first = i + 1;
+ last = i + 1;
+ }
+ }
+ }
+ if (first != 0)
+ test_print_range(first, last, chars, 19);
+ putchar('\n');
+ free(ts->file);
+ free(ts->path);
+ free(ts->results);
+ if (ts->reason != NULL)
+ free(ts->reason);
+ free(ts);
+ }
+}
+
+
+/*
+ * Given the name of a test, a pointer to the testset struct, and the source
+ * and build directories, find the test. We try first relative to the current
+ * directory, then in the build directory (if not NULL), then in the source
+ * directory. In each of those directories, we first try a "-t" extension and
+ * then a ".t" extension. When we find an executable program, we fill in the
+ * path member of the testset struct. If none of those paths are executable,
+ * just fill in the name of the test with "-t" appended.
+ *
+ * The caller is responsible for freeing the path member of the testset
+ * struct.
+ */
+static void
+find_test(const char *name, struct testset *ts, const char *source,
+ const char *build)
+{
+ char *path;
+ const char *bases[4];
+ unsigned int i;
+
+ bases[0] = ".";
+ bases[1] = build;
+ bases[2] = source;
+ bases[3] = NULL;
+
+ for (i = 0; i < 3; i++) {
+ if (bases[i] == NULL)
+ continue;
+ path = xmalloc(strlen(bases[i]) + strlen(name) + 4);
+ sprintf(path, "%s/%s-t", bases[i], name);
+ if (access(path, X_OK) != 0)
+ path[strlen(path) - 2] = '.';
+ if (access(path, X_OK) == 0)
+ break;
+ free(path);
+ path = NULL;
+ }
+ if (path == NULL) {
+ path = xmalloc(strlen(name) + 3);
+ sprintf(path, "%s-t", name);
+ }
+ ts->path = path;
+}
+
+
+/*
+ * Run a batch of tests from a given file listing each test on a line by
+ * itself. Takes two additional parameters: the root of the source directory
+ * and the root of the build directory. Test programs will be first searched
+ * for in the current directory, then the build directory, then the source
+ * directory. The file must be rewindable. Returns true iff all tests
+ * passed.
+ */
+static int
+test_batch(const char *testlist, const char *source, const char *build)
+{
+ FILE *tests;
+ unsigned int length, i;
+ unsigned int longest = 0;
+ char buffer[BUFSIZ];
+ unsigned int line;
+ struct testset *ts, *tmp, *all_tests = 0;
+ struct timeval start, end;
+ struct rusage stats;
+ struct testlist *failhead = NULL;
+ struct testlist *failtail = NULL;
+ struct testlist *next;
+ unsigned long total = 0;
+ unsigned long passed = 0;
+ unsigned long skipped = 0;
+ unsigned long failed = 0;
+ unsigned long aborted = 0;
+
+ /*
+ * Open our file of tests to run and scan it, checking for lines that
+ * are too long and searching for the longest line.
+ */
+ if (strcmp(testlist, "-") == 0) {
+ tests = stdin;
+ } else {
+ tests = fopen(testlist, "r");
+ }
+ if (!tests)
+ sysdie("can't open %s", testlist);
+ line = 0;
+ while (fgets(buffer, sizeof(buffer), tests)) {
+ line++;
+ length = strlen(buffer) - 1;
+ if (buffer[length] != '\n') {
+ fprintf(stderr, "%s:%u: line too long\n", testlist, line);
+ exit(1);
+ }
+ if (length > longest)
+ longest = length;
+
+ ts = xmalloc(sizeof(struct testset));
+ memset(ts, 0, sizeof(struct testset));
+ buffer[length] = '\0';
+
+ ts->plan = PLAN_INIT;
+ ts->file = xstrdup(buffer);
+ ts->next = NULL;
+ if (all_tests) {
+ tmp = all_tests;
+ while (tmp->next)
+ tmp = tmp->next;
+ tmp->next = ts;
+ } else {
+ all_tests = ts;
+ }
+ }
+
+ /*
+ * Add two to longest and round up to the nearest tab stop. This is how
+ * wide the column for printing the current test name will be.
+ */
+ longest += 2;
+ if (longest % 8)
+ longest += 8 - (longest % 8);
+
+ /* Start the wall clock timer. */
+ gettimeofday(&start, NULL);
+
+ /*
+ * Now, plow through our tests again, running each one. Check line
+ * length again out of paranoia.
+ */
+ line = 0;
+ for(ts = all_tests; ts && (tmp = ts->next, 1); ts = tmp) {
+ line++;
+ length = strlen(ts->file) - 1;
+ fputs(ts->file, stdout);
+ for (i = length; i < longest; i++)
+ putchar('.');
+ if (isatty(STDOUT_FILENO))
+ fflush(stdout);
+ find_test(ts->file, ts, source, build);
+ ts->reason = NULL;
+ if (test_run(ts)) {
+ free(ts->file);
+ free(ts->path);
+ free(ts->results);
+ if (ts->reason != NULL)
+ free(ts->reason);
+ free(ts);
+ } else {
+ if (!failhead) {
+ failhead = xmalloc(sizeof(struct testset));
+ failhead->ts = ts;
+ failhead->next = NULL;
+ failtail = failhead;
+ } else {
+ failtail->next = xmalloc(sizeof(struct testset));
+ failtail = failtail->next;
+ failtail->ts = ts;
+ failtail->next = NULL;
+ }
+ }
+ aborted += ts->aborted;
+ total += ts->count + ts->all_skipped;
+ passed += ts->passed;
+ skipped += ts->skipped + ts->all_skipped;
+ failed += ts->failed;
+ }
+ total -= skipped;
+ fclose(tests);
+
+ /* Stop the timer and get our child resource statistics. */
+ gettimeofday(&end, NULL);
+ getrusage(RUSAGE_CHILDREN, &stats);
+
+ /* Print out our final results. */
+ if (failhead != NULL) {
+ test_fail_summary(failhead);
+ while (failhead != NULL) {
+ next = failhead->next;
+ free(failhead);
+ failhead = next;
+ }
+ }
+ putchar('\n');
+ if (aborted != 0) {
+ if (aborted == 1)
+ printf("Aborted %lu test set", aborted);
+ else
+ printf("Aborted %lu test sets", aborted);
+ printf(", passed %lu/%lu tests", passed, total);
+ }
+ else if (failed == 0)
+ fputs("All tests successful", stdout);
+ else
+ printf("Failed %lu/%lu tests, %.2f%% okay", failed, total,
+ (total - failed) * 100.0 / total);
+ if (skipped != 0) {
+ if (skipped == 1)
+ printf(", %lu test skipped", skipped);
+ else
+ printf(", %lu tests skipped", skipped);
+ }
+ puts(".");
+ printf("Files=%u, Tests=%lu", line, total);
+ printf(", %.2f seconds", tv_diff(&end, &start));
+ printf(" (%.2f usr + %.2f sys = %.2f CPU)\n",
+ tv_seconds(&stats.ru_utime), tv_seconds(&stats.ru_stime),
+ tv_sum(&stats.ru_utime, &stats.ru_stime));
+ return (failed == 0 && aborted == 0);
+}
+
+
+/*
+ * Run a single test case. This involves just running the test program after
+ * having done the environment setup and finding the test program.
+ */
+static void
+test_single(const char *program, const char *source, const char *build)
+{
+ struct testset ts;
+
+ memset(&ts, 0, sizeof(ts));
+ find_test(program, &ts, source, build);
+ if (execl(ts.path, ts.path, (char *) 0) == -1)
+ sysdie("cannot exec %s", ts.path);
+}
+
+
+/*
+ * Main routine. Set the SOURCE and BUILD environment variables and then,
+ * given a file listing tests, run each test listed.
+ */
+int
+main(int argc, char *argv[])
+{
+ int option;
+ int status = 0;
+ int single = 0;
+ char *source_env = NULL;
+ char *build_env = NULL;
+ const char *list;
+ const char *source = SOURCE;
+ const char *build = BUILD;
+
+ while ((option = getopt(argc, argv, "b:hos:")) != EOF) {
+ switch (option) {
+ case 'b':
+ build = optarg;
+ break;
+ case 'h':
+ printf(usage_message, argv[0], argv[0]);
+ exit(0);
+ break;
+ case 'o':
+ single = 1;
+ break;
+ case 's':
+ source = optarg;
+ break;
+ default:
+ exit(1);
+ }
+ }
+ if (argc - optind != 1) {
+ fprintf(stderr, usage_message, argv[0], argv[0]);
+ exit(1);
+ }
+ argc -= optind;
+ argv += optind;
+
+ if (source != NULL) {
+ source_env = xmalloc(strlen("SOURCE=") + strlen(source) + 1);
+ sprintf(source_env, "SOURCE=%s", source);
+ if (putenv(source_env) != 0)
+ sysdie("cannot set SOURCE in the environment");
+ }
+ if (build != NULL) {
+ build_env = xmalloc(strlen("BUILD=") + strlen(build) + 1);
+ sprintf(build_env, "BUILD=%s", build);
+ if (putenv(build_env) != 0)
+ sysdie("cannot set BUILD in the environment");
+ }
+
+ if (single)
+ test_single(argv[0], source, build);
+ else {
+ list = strrchr(argv[0], '/');
+ if (list == NULL)
+ list = argv[0];
+ else
+ list++;
+ if (strcmp(list, "-") == 0) {
+ printf(banner, "stdin");
+ } else {
+ printf(banner, list);
+ }
+ status = test_batch(argv[0], source, build) ? 0 : 1;
+ }
+
+ /* For valgrind cleanliness. */
+ if (source_env != NULL) {
+ putenv((char *) "SOURCE=");
+ free(source_env);
+ }
+ if (build_env != NULL) {
+ putenv((char *) "BUILD=");
+ free(build_env);
+ }
+ exit(status);
+}
diff --git a/tests/tap/basic.c b/tests/tap/basic.c
new file mode 100644
index 0000000..e8196fc
--- /dev/null
+++ b/tests/tap/basic.c
@@ -0,0 +1,629 @@
+/*
+ * Some utility routines for writing tests.
+ *
+ * Here are a variety of utility routines for writing tests compatible with
+ * the TAP protocol. All routines of the form ok() or is*() take a test
+ * number and some number of appropriate arguments, check to be sure the
+ * results match the expected output using the arguments, and print out
+ * something appropriate for that test number. Other utility routines help in
+ * constructing more complex tests, skipping tests, reporting errors, setting
+ * up the TAP output format, or finding things in the test environment.
+ *
+ * This file is part of C TAP Harness. The current version plus supporting
+ * documentation is at <http://www.eyrie.org/~eagle/software/c-tap-harness/>.
+ *
+ * Copyright 2009, 2010, 2011, 2012 Russ Allbery <***@stanford.edu>
+ * Copyright 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2011, 2012
+ * The Board of Trustees of the Leland Stanford Junior University
+ *
+ * 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.
+ */
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+# include <direct.h>
+#else
+# include <sys/stat.h>
+#endif
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <tests/tap/basic.h>
+
+/* Windows provides mkdir and rmdir under different names. */
+#ifdef _WIN32
+# define mkdir(p, m) _mkdir(p)
+# define rmdir(p) _rmdir(p)
+#endif
+
+/*
+ * The test count. Always contains the number that will be used for the next
+ * test status.
+ */
+unsigned long testnum = 1;
+
+/*
+ * Status information stored so that we can give a test summary at the end of
+ * the test case. We store the planned final test and the count of failures.
+ * We can get the highest test count from testnum.
+ *
+ * We also store the PID of the process that called plan() and only summarize
+ * results when that process exits, so as to not misreport results in forked
+ * processes.
+ *
+ * If _lazy is true, we're doing lazy planning and will print out the plan
+ * based on the last test number at the end of testing.
+ */
+static unsigned long _planned = 0;
+static unsigned long _failed = 0;
+static pid_t _process = 0;
+static int _lazy = 0;
+
+
+/*
+ * Our exit handler. Called on completion of the test to report a summary of
+ * results provided we're still in the original process. This also handles
+ * printing out the plan if we used plan_lazy(), although that's suppressed if
+ * we never ran a test (due to an early bail, for example).
+ */
+static void
+finish(void)
+{
+ unsigned long highest = testnum - 1;
+
+ if (_planned == 0 && !_lazy)
+ return;
+ fflush(stderr);
+ if (_process != 0 && getpid() == _process) {
+ if (_lazy && highest > 0) {
+ printf("1..%lu\n", highest);
+ _planned = highest;
+ }
+ if (_planned > highest)
+ printf("# Looks like you planned %lu test%s but only ran %lu\n",
+ _planned, (_planned > 1 ? "s" : ""), highest);
+ else if (_planned < highest)
+ printf("# Looks like you planned %lu test%s but ran %lu extra\n",
+ _planned, (_planned > 1 ? "s" : ""), highest - _planned);
+ else if (_failed > 0)
+ printf("# Looks like you failed %lu test%s of %lu\n", _failed,
+ (_failed > 1 ? "s" : ""), _planned);
+ else if (_planned > 1)
+ printf("# All %lu tests successful or skipped\n", _planned);
+ else
+ printf("# %lu test successful or skipped\n", _planned);
+ }
+}
+
+
+/*
+ * Initialize things. Turns on line buffering on stdout and then prints out
+ * the number of tests in the test suite.
+ */
+void
+plan(unsigned long count)
+{
+ if (setvbuf(stdout, NULL, _IOLBF, BUFSIZ) != 0)
+ fprintf(stderr, "# cannot set stdout to line buffered: %s\n",
+ strerror(errno));
+ fflush(stderr);
+ printf("1..%lu\n", count);
+ testnum = 1;
+ _planned = count;
+ _process = getpid();
+ atexit(finish);
+}
+
+
+/*
+ * Initialize things for lazy planning, where we'll automatically print out a
+ * plan at the end of the program. Turns on line buffering on stdout as well.
+ */
+void
+plan_lazy(void)
+{
+ if (setvbuf(stdout, NULL, _IOLBF, BUFSIZ) != 0)
+ fprintf(stderr, "# cannot set stdout to line buffered: %s\n",
+ strerror(errno));
+ testnum = 1;
+ _process = getpid();
+ _lazy = 1;
+ atexit(finish);
+}
+
+
+/*
+ * Skip the entire test suite and exits. Should be called instead of plan(),
+ * not after it, since it prints out a special plan line.
+ */
+void
+skip_all(const char *format, ...)
+{
+ fflush(stderr);
+ printf("1..0 # skip");
+ if (format != NULL) {
+ va_list args;
+
+ putchar(' ');
+ va_start(args, format);
+ vprintf(format, args);
+ va_end(args);
+ }
+ putchar('\n');
+ exit(0);
+}
+
+
+/*
+ * Print the test description.
+ */
+static void
+print_desc(const char *format, va_list args)
+{
+ printf(" - ");
+ vprintf(format, args);
+}
+
+
+/*
+ * Takes a boolean success value and assumes the test passes if that value
+ * is true and fails if that value is false.
+ */
+void
+ok(int success, const char *format, ...)
+{
+ fflush(stderr);
+ printf("%sok %lu", success ? "" : "not ", testnum++);
+ if (!success)
+ _failed++;
+ if (format != NULL) {
+ va_list args;
+
+ va_start(args, format);
+ print_desc(format, args);
+ va_end(args);
+ }
+ putchar('\n');
+}
+
+
+/*
+ * Same as ok(), but takes the format arguments as a va_list.
+ */
+void
+okv(int success, const char *format, va_list args)
+{
+ fflush(stderr);
+ printf("%sok %lu", success ? "" : "not ", testnum++);
+ if (!success)
+ _failed++;
+ if (format != NULL)
+ print_desc(format, args);
+ putchar('\n');
+}
+
+
+/*
+ * Skip a test.
+ */
+void
+skip(const char *reason, ...)
+{
+ fflush(stderr);
+ printf("ok %lu # skip", testnum++);
+ if (reason != NULL) {
+ va_list args;
+
+ va_start(args, reason);
+ putchar(' ');
+ vprintf(reason, args);
+ va_end(args);
+ }
+ putchar('\n');
+}
+
+
+/*
+ * Report the same status on the next count tests.
+ */
+void
+ok_block(unsigned long count, int status, const char *format, ...)
+{
+ unsigned long i;
+
+ fflush(stderr);
+ for (i = 0; i < count; i++) {
+ printf("%sok %lu", status ? "" : "not ", testnum++);
+ if (!status)
+ _failed++;
+ if (format != NULL) {
+ va_list args;
+
+ va_start(args, format);
+ print_desc(format, args);
+ va_end(args);
+ }
+ putchar('\n');
+ }
+}
+
+
+/*
+ * Skip the next count tests.
+ */
+void
+skip_block(unsigned long count, const char *reason, ...)
+{
+ unsigned long i;
+
+ fflush(stderr);
+ for (i = 0; i < count; i++) {
+ printf("ok %lu # skip", testnum++);
+ if (reason != NULL) {
+ va_list args;
+
+ va_start(args, reason);
+ putchar(' ');
+ vprintf(reason, args);
+ va_end(args);
+ }
+ putchar('\n');
+ }
+}
+
+
+/*
+ * Takes an expected integer and a seen integer and assumes the test passes
+ * if those two numbers match.
+ */
+void
+is_int(long wanted, long seen, const char *format, ...)
+{
+ fflush(stderr);
+ if (wanted == seen)
+ printf("ok %lu", testnum++);
+ else {
+ printf("# wanted: %ld\n# seen: %ld\n", wanted, seen);
+ printf("not ok %lu", testnum++);
+ _failed++;
+ }
+ if (format != NULL) {
+ va_list args;
+
+ va_start(args, format);
+ print_desc(format, args);
+ va_end(args);
+ }
+ putchar('\n');
+}
+
+
+/*
+ * Takes a string and what the string should be, and assumes the test passes
+ * if those strings match (using strcmp).
+ */
+void
+is_string(const char *wanted, const char *seen, const char *format, ...)
+{
+ if (wanted == NULL)
+ wanted = "(null)";
+ if (seen == NULL)
+ seen = "(null)";
+ fflush(stderr);
+ if (strcmp(wanted, seen) == 0)
+ printf("ok %lu", testnum++);
+ else {
+ printf("# wanted: %s\n# seen: %s\n", wanted, seen);
+ printf("not ok %lu", testnum++);
+ _failed++;
+ }
+ if (format != NULL) {
+ va_list args;
+
+ va_start(args, format);
+ print_desc(format, args);
+ va_end(args);
+ }
+ putchar('\n');
+}
+
+
+/*
+ * Takes an expected unsigned long and a seen unsigned long and assumes the
+ * test passes if the two numbers match. Otherwise, reports them in hex.
+ */
+void
+is_hex(unsigned long wanted, unsigned long seen, const char *format, ...)
+{
+ fflush(stderr);
+ if (wanted == seen)
+ printf("ok %lu", testnum++);
+ else {
+ printf("# wanted: %lx\n# seen: %lx\n", (unsigned long) wanted,
+ (unsigned long) seen);
+ printf("not ok %lu", testnum++);
+ _failed++;
+ }
+ if (format != NULL) {
+ va_list args;
+
+ va_start(args, format);
+ print_desc(format, args);
+ va_end(args);
+ }
+ putchar('\n');
+}
+
+
+/*
+ * Bail out with an error.
+ */
+void
+bail(const char *format, ...)
+{
+ va_list args;
+
+ fflush(stderr);
+ fflush(stdout);
+ printf("Bail out! ");
+ va_start(args, format);
+ vprintf(format, args);
+ va_end(args);
+ printf("\n");
+ exit(1);
+}
+
+
+/*
+ * Bail out with an error, appending strerror(errno).
+ */
+void
+sysbail(const char *format, ...)
+{
+ va_list args;
+ int oerrno = errno;
+
+ fflush(stderr);
+ fflush(stdout);
+ printf("Bail out! ");
+ va_start(args, format);
+ vprintf(format, args);
+ va_end(args);
+ printf(": %s\n", strerror(oerrno));
+ exit(1);
+}
+
+
+/*
+ * Report a diagnostic to stderr.
+ */
+void
+diag(const char *format, ...)
+{
+ va_list args;
+
+ fflush(stderr);
+ fflush(stdout);
+ printf("# ");
+ va_start(args, format);
+ vprintf(format, args);
+ va_end(args);
+ printf("\n");
+}
+
+
+/*
+ * Report a diagnostic to stderr, appending strerror(errno).
+ */
+void
+sysdiag(const char *format, ...)
+{
+ va_list args;
+ int oerrno = errno;
+
+ fflush(stderr);
+ fflush(stdout);
+ printf("# ");
+ va_start(args, format);
+ vprintf(format, args);
+ va_end(args);
+ printf(": %s\n", strerror(oerrno));
+}
+
+
+/*
+ * Allocate cleared memory, reporting a fatal error with bail on failure.
+ */
+void *
+bcalloc(size_t n, size_t size)
+{
+ void *p;
+
+ p = calloc(n, size);
+ if (p == NULL)
+ sysbail("failed to calloc %lu", (unsigned long)(n * size));
+ return p;
+}
+
+
+/*
+ * Allocate memory, reporting a fatal error with bail on failure.
+ */
+void *
+bmalloc(size_t size)
+{
+ void *p;
+
+ p = malloc(size);
+ if (p == NULL)
+ sysbail("failed to malloc %lu", (unsigned long) size);
+ return p;
+}
+
+
+/*
+ * Reallocate memory, reporting a fatal error with bail on failure.
+ */
+void *
+brealloc(void *p, size_t size)
+{
+ p = realloc(p, size);
+ if (p == NULL)
+ sysbail("failed to realloc %lu bytes", (unsigned long) size);
+ return p;
+}
+
+
+/*
+ * Copy a string, reporting a fatal error with bail on failure.
+ */
+char *
+bstrdup(const char *s)
+{
+ char *p;
+ size_t len;
+
+ len = strlen(s) + 1;
+ p = malloc(len);
+ if (p == NULL)
+ sysbail("failed to strdup %lu bytes", (unsigned long) len);
+ memcpy(p, s, len);
+ return p;
+}
+
+
+/*
+ * Copy up to n characters of a string, reporting a fatal error with bail on
+ * failure. Don't use the system strndup function, since it may not exist and
+ * the TAP library doesn't assume any portability support.
+ */
+char *
+bstrndup(const char *s, size_t n)
+{
+ const char *p;
+ char *copy;
+ size_t length;
+
+ /* Don't assume that the source string is nul-terminated. */
+ for (p = s; (size_t) (p - s) < n && *p != '\0'; p++)
+ ;
+ length = p - s;
+ copy = malloc(length + 1);
+ if (p == NULL)
+ sysbail("failed to strndup %lu bytes", (unsigned long) length);
+ memcpy(copy, s, length);
+ copy[length] = '\0';
+ return copy;
+}
+
+
+/*
+ * Locate a test file. Given the partial path to a file, look under BUILD and
+ * then SOURCE for the file and return the full path to the file. Returns
+ * NULL if the file doesn't exist. A non-NULL return should be freed with
+ * test_file_path_free().
+ *
+ * This function uses sprintf because it attempts to be independent of all
+ * other portability layers. The use immediately after a memory allocation
+ * should be safe without using snprintf or strlcpy/strlcat.
+ */
+char *
+test_file_path(const char *file)
+{
+ char *base;
+ char *path = NULL;
+ size_t length;
+ const char *envs[] = { "BUILD", "SOURCE", NULL };
+ int i;
+
+ for (i = 0; envs[i] != NULL; i++) {
+ base = getenv(envs[i]);
+ if (base == NULL)
+ continue;
+ length = strlen(base) + 1 + strlen(file) + 1;
+ path = bmalloc(length);
+ sprintf(path, "%s/%s", base, file);
+ if (access(path, R_OK) == 0)
+ break;
+ free(path);
+ path = NULL;
+ }
+ return path;
+}
+
+
+/*
+ * Free a path returned from test_file_path(). This function exists primarily
+ * for Windows, where memory must be freed from the same library domain that
+ * it was allocated from.
+ */
+void
+test_file_path_free(char *path)
+{
+ if (path != NULL)
+ free(path);
+}
+
+
+/*
+ * Create a temporary directory, tmp, under BUILD if set and the current
+ * directory if it does not. Returns the path to the temporary directory in
+ * newly allocated memory, and calls bail on any failure. The return value
+ * should be freed with test_tmpdir_free.
+ *
+ * This function uses sprintf because it attempts to be independent of all
+ * other portability layers. The use immediately after a memory allocation
+ * should be safe without using snprintf or strlcpy/strlcat.
+ */
+char *
+test_tmpdir(void)
+{
+ const char *build;
+ char *path = NULL;
+ size_t length;
+
+ build = getenv("BUILD");
+ if (build == NULL)
+ build = ".";
+ length = strlen(build) + strlen("/tmp") + 1;
+ path = bmalloc(length);
+ sprintf(path, "%s/tmp", build);
+ if (access(path, X_OK) < 0)
+ if (mkdir(path, 0777) < 0)
+ sysbail("error creating temporary directory %s", path);
+ return path;
+}
+
+
+/*
+ * Free a path returned from test_tmpdir() and attempt to remove the
+ * directory. If we can't delete the directory, don't worry; something else
+ * that hasn't yet cleaned up may still be using it.
+ */
+void
+test_tmpdir_free(char *path)
+{
+ rmdir(path);
+ if (path != NULL)
+ free(path);
+}
diff --git a/tests/tap/basic.h b/tests/tap/basic.h
new file mode 100644
index 0000000..fa4adaf
--- /dev/null
+++ b/tests/tap/basic.h
@@ -0,0 +1,134 @@
+/*
+ * Basic utility routines for the TAP protocol.
+ *
+ * This file is part of C TAP Harness. The current version plus supporting
+ * documentation is at <http://www.eyrie.org/~eagle/software/c-tap-harness/>.
+ *
+ * Copyright 2009, 2010, 2011, 2012 Russ Allbery <***@stanford.edu>
+ * Copyright 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2011, 2012
+ * The Board of Trustees of the Leland Stanford Junior University
+ *
+ * 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.
+ */
+
+#ifndef TAP_BASIC_H
+#define TAP_BASIC_H 1
+
+#include <tests/tap/macros.h>
+#include <stdarg.h> /* va_list */
+#include <sys/types.h> /* size_t */
+
+/*
+ * Used for iterating through arrays. ARRAY_SIZE returns the number of
+ * elements in the array (useful for a < upper bound in a for loop) and
+ * ARRAY_END returns a pointer to the element past the end (ISO C99 makes it
+ * legal to refer to such a pointer as long as it's never dereferenced).
+ */
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
+#define ARRAY_END(array) (&(array)[ARRAY_SIZE(array)])
+
+BEGIN_DECLS
+
+/*
+ * The test count. Always contains the number that will be used for the next
+ * test status.
+ */
+extern unsigned long testnum;
+
+/* Print out the number of tests and set standard output to line buffered. */
+void plan(unsigned long count);
+
+/*
+ * Prepare for lazy planning, in which the plan will be printed automatically
+ * at the end of the test program.
+ */
+void plan_lazy(void);
+
+/* Skip the entire test suite. Call instead of plan. */
+void skip_all(const char *format, ...)
+ __attribute__((__noreturn__, __format__(printf, 1, 2)));
+
+/*
+ * Basic reporting functions. The okv() function is the same as ok() but
+ * takes the test description as a va_list to make it easier to reuse the
+ * reporting infrastructure when writing new tests.
+ */
+void ok(int success, const char *format, ...)
+ __attribute__((__format__(printf, 2, 3)));
+void okv(int success, const char *format, va_list args);
+void skip(const char *reason, ...)
+ __attribute__((__format__(printf, 1, 2)));
+
+/* Report the same status on, or skip, the next count tests. */
+void ok_block(unsigned long count, int success, const char *format, ...)
+ __attribute__((__format__(printf, 3, 4)));
+void skip_block(unsigned long count, const char *reason, ...)
+ __attribute__((__format__(printf, 2, 3)));
+
+/* Check an expected value against a seen value. */
+void is_int(long wanted, long seen, const char *format, ...)
+ __attribute__((__format__(printf, 3, 4)));
+void is_string(const char *wanted, const char *seen, const char *format, ...)
+ __attribute__((__format__(printf, 3, 4)));
+void is_hex(unsigned long wanted, unsigned long seen, const char *format, ...)
+ __attribute__((__format__(printf, 3, 4)));
+
+/* Bail out with an error. sysbail appends strerror(errno). */
+void bail(const char *format, ...)
+ __attribute__((__noreturn__, __nonnull__, __format__(printf, 1, 2)));
+void sysbail(const char *format, ...)
+ __attribute__((__noreturn__, __nonnull__, __format__(printf, 1, 2)));
+
+/* Report a diagnostic to stderr prefixed with #. */
+void diag(const char *format, ...)
+ __attribute__((__nonnull__, __format__(printf, 1, 2)));
+void sysdiag(const char *format, ...)
+ __attribute__((__nonnull__, __format__(printf, 1, 2)));
+
+/* Allocate memory, reporting a fatal error with bail on failure. */
+void *bcalloc(size_t, size_t)
+ __attribute__((__alloc_size__(1, 2), __malloc__));
+void *bmalloc(size_t)
+ __attribute__((__alloc_size__(1), __malloc__));
+void *brealloc(void *, size_t)
+ __attribute__((__alloc_size__(2), __malloc__));
+char *bstrdup(const char *)
+ __attribute__((__malloc__, __nonnull__));
+char *bstrndup(const char *, size_t)
+ __attribute__((__malloc__, __nonnull__));
+
+/*
+ * Find a test file under BUILD or SOURCE, returning the full path. The
+ * returned path should be freed with test_file_path_free().
+ */
+char *test_file_path(const char *file)
+ __attribute__((__malloc__, __nonnull__));
+void test_file_path_free(char *path);
+
+/*
+ * Create a temporary directory relative to BUILD and return the path. The
+ * returned path should be freed with test_tmpdir_free.
+ */
+char *test_tmpdir(void)
+ __attribute__((__malloc__));
+void test_tmpdir_free(char *path);
+
+END_DECLS
+
+#endif /* TAP_BASIC_H */
diff --git a/tests/tap/float.c b/tests/tap/float.c
new file mode 100644
index 0000000..67dd555
--- /dev/null
+++ b/tests/tap/float.c
@@ -0,0 +1,67 @@
+/*
+ * Utility routines for writing floating point tests.
+ *
+ * Currently provides only one function, which checks whether a double is
+ * equal to an expected value within a given epsilon. This is broken into a
+ * separate source file from the rest of the basic C TAP library because it
+ * may require linking with -lm on some platforms, and the package may not
+ * otherwise care about floating point.
+ *
+ * This file is part of C TAP Harness. The current version plus supporting
+ * documentation is at <http://www.eyrie.org/~eagle/software/c-tap-harness/>.
+ *
+ * Copyright 2008, 2010, 2012 Russ Allbery <***@stanford.edu>
+ *
+ * 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.
+ */
+
+/* Required for isnan() and isinf(). */
+#if defined(__STRICT_ANSI__) || defined(PEDANTIC)
+# ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 600
+# endif
+#endif
+
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <tests/tap/basic.h>
+#include <tests/tap/float.h>
+
+/*
+ * Takes an expected double and a seen double and assumes the test passes if
+ * those two numbers are within delta of each other.
+ */
+void
+is_double(double wanted, double seen, double epsilon, const char *format, ...)
+{
+ va_list args;
+
+ va_start(args, format);
+ fflush(stderr);
+ if ((isnan(wanted) && isnan(seen))
+ || (isinf(wanted) && isinf(seen) && wanted == seen)
+ || fabs(wanted - seen) <= epsilon)
+ okv(1, format, args);
+ else {
+ printf("# wanted: %g\n# seen: %g\n", wanted, seen);
+ okv(0, format, args);
+ }
+}
diff --git a/tests/tap/float.h b/tests/tap/float.h
new file mode 100644
index 0000000..7464535
--- /dev/null
+++ b/tests/tap/float.h
@@ -0,0 +1,42 @@
+/*
+ * Floating point check function for the TAP protocol.
+ *
+ * This file is part of C TAP Harness. The current version plus supporting
+ * documentation is at <http://www.eyrie.org/~eagle/software/c-tap-harness/>.
+ *
+ * Copyright 2008, 2010, 2012 Russ Allbery <***@stanford.edu>
+ *
+ * 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.
+ */
+
+#ifndef TAP_FLOAT_H
+#define TAP_FLOAT_H 1
+
+#include <tests/tap/macros.h>
+
+BEGIN_DECLS
+
+/* Check an expected value against a seen value within epsilon. */
+void is_double(double wanted, double seen, double epsilon,
+ const char *format, ...)
+ __attribute__((__format__(printf, 4, 5)));
+
+END_DECLS
+
+#endif /* TAP_FLOAT_H */
diff --git a/tests/tap/libtap.sh b/tests/tap/libtap.sh
new file mode 100644
index 0000000..f9347d8
--- /dev/null
+++ b/tests/tap/libtap.sh
@@ -0,0 +1,246 @@
+# Shell function library for test cases.
+#
+# Note that while many of the functions in this library could benefit from
+# using "local" to avoid possibly hammering global variables, Solaris /bin/sh
+# doesn't support local and this library aspires to be portable to Solaris
+# Bourne shell. Instead, all private variables are prefixed with "tap_".
+#
+# This file provides a TAP-compatible shell function library useful for
+# writing test cases. It is part of C TAP Harness, which can be found at
+# <http://www.eyrie.org/~eagle/software/c-tap-harness/>.
+#
+# Written by Russ Allbery <***@stanford.edu>
+# Copyright 2009, 2010, 2011, 2012 Russ Allbery <***@stanford.edu>
+# Copyright 2006, 2007, 2008
+# The Board of Trustees of the Leland Stanford Junior University
+#
+# 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.
+
+# Print out the number of test cases we expect to run.
+plan () {
+ count=1
+ planned="$1"
+ failed=0
+ echo "1..$1"
+ trap finish 0
+}
+
+# Prepare for lazy planning.
+plan_lazy () {
+ count=1
+ planned=0
+ failed=0
+ trap finish 0
+}
+
+# Report the test status on exit.
+finish () {
+ tap_highest=`expr "$count" - 1`
+ if [ "$planned" = 0 ] ; then
+ echo "1..$tap_highest"
+ planned="$tap_highest"
+ fi
+ tap_looks='# Looks like you'
+ if [ "$planned" -gt 0 ] ; then
+ if [ "$planned" -gt "$tap_highest" ] ; then
+ if [ "$planned" -gt 1 ] ; then
+ echo "$tap_looks planned $planned tests but only ran" \
+ "$tap_highest"
+ else
+ echo "$tap_looks planned $planned test but only ran" \
+ "$tap_highest"
+ fi
+ elif [ "$planned" -lt "$tap_highest" ] ; then
+ tap_extra=`expr "$tap_highest" - "$planned"`
+ if [ "$planned" -gt 1 ] ; then
+ echo "$tap_looks planned $planned tests but ran" \
+ "$tap_extra extra"
+ else
+ echo "$tap_looks planned $planned test but ran" \
+ "$tap_extra extra"
+ fi
+ elif [ "$failed" -gt 0 ] ; then
+ if [ "$failed" -gt 1 ] ; then
+ echo "$tap_looks failed $failed tests of $planned"
+ else
+ echo "$tap_looks failed $failed test of $planned"
+ fi
+ elif [ "$planned" -gt 1 ] ; then
+ echo "# All $planned tests successful or skipped"
+ else
+ echo "# $planned test successful or skipped"
+ fi
+ fi
+}
+
+# Skip the entire test suite. Should be run instead of plan.
+skip_all () {
+ tap_desc="$1"
+ if [ -n "$tap_desc" ] ; then
+ echo "1..0 # skip $tap_desc"
+ else
+ echo "1..0 # skip"
+ fi
+ exit 0
+}
+
+# ok takes a test description and a command to run and prints success if that
+# command is successful, false otherwise. The count starts at 1 and is
+# updated each time ok is printed.
+ok () {
+ tap_desc="$1"
+ if [ -n "$tap_desc" ] ; then
+ tap_desc=" - $tap_desc"
+ fi
+ shift
+ if "$@" ; then
+ echo ok "$count$tap_desc"
+ else
+ echo not ok "$count$tap_desc"
+ failed=`expr $failed + 1`
+ fi
+ count=`expr $count + 1`
+}
+
+# Skip the next test. Takes the reason why the test is skipped.
+skip () {
+ echo "ok $count # skip $*"
+ count=`expr $count + 1`
+}
+
+# Report the same status on a whole set of tests. Takes the count of tests,
+# the description, and then the command to run to determine the status.
+ok_block () {
+ tap_i=$count
+ tap_end=`expr $count + $1`
+ shift
+ while [ "$tap_i" -lt "$tap_end" ] ; do
+ ok "$@"
+ tap_i=`expr $tap_i + 1`
+ done
+}
+
+# Skip a whole set of tests. Takes the count and then the reason for skipping
+# the test.
+skip_block () {
+ tap_i=$count
+ tap_end=`expr $count + $1`
+ shift
+ while [ "$tap_i" -lt "$tap_end" ] ; do
+ skip "$@"
+ tap_i=`expr $tap_i + 1`
+ done
+}
+
+# Portable variant of printf '%s\n' "$*". In the majority of cases, this
+# function is slower than printf, because the latter is often implemented
+# as a builtin command. The value of the variable IFS is ignored.
+#
+# This macro must not be called via backticks inside double quotes, since this
+# will result in bizarre escaping behavior and lots of extra backslashes on
+# Solaris.
+puts () {
+ cat << EOH
+$@
+EOH
+}
+
+# Run a program expected to succeed, and print ok if it does and produces the
+# correct output. Takes the description, expected exit status, the expected
+# output, the command to run, and then any arguments for that command.
+# Standard output and standard error are combined when analyzing the output of
+# the command.
+#
+# If the command may contain system-specific error messages in its output,
+# add strip_colon_error before the command to post-process its output.
+ok_program () {
+ tap_desc="$1"
+ shift
+ tap_w_status="$1"
+ shift
+ tap_w_output="$1"
+ shift
+ tap_output=`"$@" 2>&1`
+ tap_status=$?
+ if [ $tap_status = $tap_w_status ] \
+ && [ x"$tap_output" = x"$tap_w_output" ] ; then
+ ok "$tap_desc" true
+ else
+ echo "# saw: ($tap_status) $tap_output"
+ echo "# not: ($tap_w_status) $tap_w_output"
+ ok "$tap_desc" false
+ fi
+}
+
+# Strip a colon and everything after it off the output of a command, as long
+# as that colon comes after at least one whitespace character. (This is done
+# to avoid stripping the name of the program from the start of an error
+# message.) This is used to remove system-specific error messages (coming
+# from strerror, for example).
+strip_colon_error() {
+ tap_output=`"$@" 2>&1`
+ tap_status=$?
+ tap_output=`puts "$tap_output" | sed 's/^\([^ ]* [^:]*\):.*/\1/'`
+ puts "$tap_output"
+ return $tap_status
+}
+
+# Bail out with an error message.
+bail () {
+ echo 'Bail out!' "$@"
+ exit 1
+}
+
+# Output a diagnostic on standard error, preceded by the required # mark.
+diag () {
+ echo '#' "$@"
+}
+
+# Search for the given file first in $BUILD and then in $SOURCE and echo the
+# path where the file was found, or the empty string if the file wasn't
+# found.
+#
+# This macro uses puts, so don't run it using backticks inside double quotes
+# or bizarre quoting behavior will happen with Solaris sh.
+test_file_path () {
+ if [ -n "$BUILD" ] && [ -f "$BUILD/$1" ] ; then
+ puts "$BUILD/$1"
+ elif [ -n "$SOURCE" ] && [ -f "$SOURCE/$1" ] ; then
+ puts "$SOURCE/$1"
+ else
+ echo ''
+ fi
+}
+
+# Create $BUILD/tmp for use by tests for storing temporary files and return
+# the path (via standard output).
+#
+# This macro uses puts, so don't run it using backticks inside double quotes
+# or bizarre quoting behavior will happen with Solaris sh.
+test_tmpdir () {
+ if [ -z "$BUILD" ] ; then
+ tap_tmpdir="./tmp"
+ else
+ tap_tmpdir="$BUILD"/tmp
+ fi
+ if [ ! -d "$tap_tmpdir" ] ; then
+ mkdir "$tap_tmpdir" || bail "Error creating $tap_tmpdir"
+ fi
+ puts "$tap_tmpdir"
+}
diff --git a/tests/tap/macros.h b/tests/tap/macros.h
new file mode 100644
index 0000000..33fee42
--- /dev/null
+++ b/tests/tap/macros.h
@@ -0,0 +1,88 @@
+/*
+ * Helpful macros for TAP header files.
+ *
+ * This is not, strictly speaking, related to TAP, but any TAP add-on is
+ * probably going to need these macros, so define them in one place so that
+ * everyone can pull them in.
+ *
+ * This file is part of C TAP Harness. The current version plus supporting
+ * documentation is at <http://www.eyrie.org/~eagle/software/c-tap-harness/>.
+ *
+ * Copyright 2008, 2012 Russ Allbery <***@stanford.edu>
+ *
+ * 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.
+ */
+
+#ifndef TAP_MACROS_H
+#define TAP_MACROS_H 1
+
+/*
+ * __attribute__ is available in gcc 2.5 and later, but only with gcc 2.7
+ * could you use the __format__ form of the attributes, which is what we use
+ * (to avoid confusion with other macros), and only with gcc 2.96 can you use
+ * the attribute __malloc__. 2.96 is very old, so don't bother trying to get
+ * the other attributes to work with GCC versions between 2.7 and 2.96.
+ */
+#ifndef __attribute__
+# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
+# define __attribute__(spec) /* empty */
+# endif
+#endif
+
+/*
+ * We use __alloc_size__, but it was only available in fairly recent versions
+ * of GCC. Suppress warnings about the unknown attribute if GCC is too old.
+ * We know that we're GCC at this point, so we can use the GCC variadic macro
+ * extension, which will still work with versions of GCC too old to have C99
+ * variadic macro support.
+ */
+#if !defined(__attribute__) && !defined(__alloc_size__)
+# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3)
+# define __alloc_size__(spec, args...) /* empty */
+# endif
+#endif
+
+/*
+ * LLVM and Clang pretend to be GCC but don't support all of the __attribute__
+ * settings that GCC does. For them, suppress warnings about unknown
+ * attributes on declarations. This unfortunately will affect the entire
+ * compilation context, but there's no push and pop available.
+ */
+#if !defined(__attribute__) && (defined(__llvm__) || defined(__clang__))
+# pragma GCC diagnostic ignored "-Wattributes"
+#endif
+
+/* Used for unused parameters to silence gcc warnings. */
+#define UNUSED __attribute__((__unused__))
+
+/*
+ * BEGIN_DECLS is used at the beginning of declarations so that C++
+ * compilers don't mangle their names. END_DECLS is used at the end.
+ */
+#undef BEGIN_DECLS
+#undef END_DECLS
+#ifdef __cplusplus
+# define BEGIN_DECLS extern "C" {
+# define END_DECLS }
+#else
+# define BEGIN_DECLS /* empty */
+# define END_DECLS /* empty */
+#endif
+
+#endif /* TAP_MACROS_H */
diff --git a/tests/testutil.c b/tests/testutil.c
new file mode 100644
index 0000000..3bb3aa1
--- /dev/null
+++ b/tests/testutil.c
@@ -0,0 +1,115 @@
+/**
+ * @file testutil.c
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "testutil.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+
+/* Taken from bytes.com/topic/c/answers/763239-printing-hex-dump-buffer */
+void dump_buffer(FILE *stream, unsigned int n, const void *b) {
+ const unsigned char* buf = b;
+ int on_this_line = 0;
+ while (n-- > 0) {
+ fprintf(stream, "%02X ", *buf++);
+ on_this_line += 1;
+ if (on_this_line == 16 || n == 0) {
+ int i;
+ fputs(" ", stream);
+ for (i = on_this_line; i < 16; i++)
+ fputs(" ", stream);
+ for (i = on_this_line; i > 0; i--)
+ fputc(isprint(buf[-i]) ? buf[-i] : '.', stream);
+ fputs("\n", stream);
+ on_this_line = 0;
+ }
+ }
+}
+
+int cmp_buffers(FILE *stream, unsigned int n, const void *b1, const void *b2) {
+ int result = 0;
+ int on_this_line = 0;
+
+ const unsigned char *buf1 = b1;
+ const unsigned char *buf2 = b2;
+ while (n-- > 0) {
+ if (*buf1 == *buf2) {
+ fprintf(stream, "%02X ", *buf1);
+ } else {
+ result = 1;
+ fprintf(stream, "%02X!%02X ", *buf1, *buf2);
+ }
+ buf1++;
+ buf2++;
+ on_this_line += 1;
+ if (on_this_line == 16 || n == 0) {
+ int i;
+ fputs(" ", stream);
+ for (i = on_this_line; i < 16; i++)
+ fputs(" ", stream);
+ for (i = on_this_line; i > 0; i--)
+ fputc(isprint(buf1[-i]) ? buf1[-i] : '.', stream);
+ fputs("\n", stream);
+ on_this_line = 0;
+ }
+ }
+ return result;
+}
+
+void ptp_text_set(struct PTPText *t, const char *txt) {
+ size_t len;
+ if (txt) {
+ len = strlen(txt);
+ if (len > 255) len = 255;
+ t->length = len;
+ t->text = (Octet*)txt;
+ } else {
+ t->length = 0;
+ t->text = 0;
+ }
+}
+
+static struct childproc *the_child = 0;
+
+static void killchild() {
+ if (the_child) {
+ childproc_kill(the_child);
+ the_child = 0;
+ }
+}
+
+struct childproc *test_childproc(const char *config) {
+ if (the_child == 0) {
+ if (childproc_new(&the_child) != 0) {
+ printf("Failed childproc_new\n");
+ exit(1);
+ }
+ if (childproc_spawn(the_child, config) != 0) {
+ printf("Failed childproc_spawn\n");
+ exit(1);
+ }
+ atexit(killchild);
+ }
+ return the_child;
+}
+
+struct childproc *test_restart_childproc(const char *config) {
+ killchild();
+ return test_childproc(config);
+}
diff --git a/tests/testutil.h b/tests/testutil.h
new file mode 100644
index 0000000..797b602
--- /dev/null
+++ b/tests/testutil.h
@@ -0,0 +1,42 @@
+/**
+ * @file testutil.h
+ * @brief Utilities for tests
+ * @note Copyright (C) 2012 Smart Energy Instruments Inc. <***@se-instruments.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef TEST_UTIL_H
+#define TEST_UTIL_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "mgmt.h"
+#include "childproc.h"
+
+struct sequence_ids {
+ UInteger16 mgmt;
+};
+
+void dump_buffer(FILE *stream, unsigned int n, const void* buf);
+int cmp_buffers(FILE *stream, unsigned int n, const void* buf1, const void* buf2);
+
+void ptp_text_set(struct PTPText *t, const char *txt);
+
+struct childproc *test_childproc(const char *config);
+struct childproc *test_restart_childproc(const char *config);
+#endif
--
1.8.0.2