test: fix operations

Adjust the tests after the refactoring and to use struct gluten_offset

5 files changed, 244 insertions, 274 deletions

diff --git a/tests/unit/Makefile b/tests/unit/Makefile
index ef702dc..202e198 100644
--- a/tests/unit/Makefile
+++ b/tests/unit/Makefile
@@ -2,6 +2,7 @@
 # Copyright 2023 Red Hat GmbH
 # Author: Alice Frosi <afrosi@redhat.com>
 
+MAIN_DIR := ../../
 COMMON_DIR := ../../common
 OP_DIR := ../../
 COOKER_DIR := ../../cooker
@@ -19,8 +20,8 @@ HEADERS_OP_CALL := $(COMMON_DIR)/gluten.h  $(OP_DIR)/operations.h
 SRCS_OP_CALL := $(OP_DIR)/operations.c
 
 HEADERS_OP := $(COMMON_DIR)/gluten.h  $(OP_DIR)/operations.h \
-		   $(COMMON_DIR)/common.h testutil.h
-SRCS_OP := $(COMMON_DIR)/common.c $(OP_DIR)/operations.c util.c
+		   $(COMMON_DIR)/common.h testutil.h $(COMMON_DIR)/util.h
+SRCS_OP := $(COMMON_DIR)/common.c $(OP_DIR)/operations.c util.c $(COMMON_DIR)/util.c
 
 TARGET := $(shell $(CC) -dumpmachine)
 TARGET_ARCH := $(shell echo $(TARGET) | cut -f1 -d- | tr [A-Z] [a-z])
@@ -32,9 +33,9 @@ AUDIT_ARCH := $(shell echo $(AUDIT_ARCH) | sed 's/PPC64/PPC/')
 AUDIT_ARCH := $(shell echo $(AUDIT_ARCH) | sed 's/PPCLE/PPC64LE/')
 
 CFLAGS += -Wall -Wextra -pedantic
-CFLAGS += -I$(COMMON_DIR) -I$(OP_DIR) -I$(COOKER_DIR) -I$(DBG_DIR)
+CFLAGS += -I$(MAIN_DIR) -I$(OP_DIR)  -I$(DBG_DIR)
 CFLAGS += -lcheck
-CFLAGS += -DSEITAN_AUDIT_ARCH=AUDIT_ARCH_$(AUDIT_ARCH) -DTMP_DATA_SIZE=1000000
+CFLAGS += -DSEITAN_AUDIT_ARCH=AUDIT_ARCH_$(AUDIT_ARCH)
 
 test: test-filter test-operations test-op-call
 
diff --git a/tests/unit/test_op_call.c b/tests/unit/test_op_call.c
index 9a89599..7f4b367 100644
--- a/tests/unit/test_op_call.c
+++ b/tests/unit/test_op_call.c
@@ -17,7 +17,7 @@
 
 #include <check.h>
 
-#include "gluten.h"
+#include "common/gluten.h"
 #include "operations.h"
 
 struct args_write_file {
@@ -122,7 +122,7 @@ START_TEST(test_with_open_read_ns)
 		call.context.ns[i].type = NS_NONE;
 	call.context.ns[NS_MOUNT].type = NS_SPEC_PID;
 	pid = create_func_ns(write_file_clone, (void *)&args, call.context.ns);
-	call.context.ns[NS_MOUNT].pid = pid;
+	call.context.ns[NS_MOUNT].id.pid = pid;
 	call.nr = SYS_open;
 	call.args[0] = (void *)&test_file;
 	call.args[1] = (void *)(long)flags;
diff --git a/tests/unit/test_operations.c b/tests/unit/test_operations.c
index e50a256..9c3cf94 100644
--- a/tests/unit/test_operations.c
+++ b/tests/unit/test_operations.c
@@ -25,9 +25,8 @@
 
 #include <check.h>
 
-#include "gluten.h"
 #include "operations.h"
-#include "common.h"
+#include "common/common.h"
 #include "testutil.h"
 
 #define MAX_TEST_PATH 250
@@ -83,237 +82,172 @@ void setup_target_connect()
 	setup();
 }
 
-START_TEST(test_act_continue)
+START_TEST(test_op_continue)
 {
-	struct op operations[] = {
-		{ .type = OP_CONT },
-	};
-	int ret = do_operations(NULL, operations, &req,
-				sizeof(operations) / sizeof(operations[0]),
-				notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
+	ck_assert_msg(op_continue(&req, notifyfd, NULL, NULL) == 0,
+		      strerror(errno));
 	ck_assert_int_eq(at->err, 0);
 }
 END_TEST
 
-START_TEST(test_act_block)
+START_TEST(test_op_block)
 {
-	struct op operations[] = {
-		{
-			.type = OP_BLOCK,
-			.block = { .error = -1 },
-		},
-	};
-	int ret = do_operations(NULL, operations, &req,
-				sizeof(operations) / sizeof(operations[0]),
-				notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
+	struct op_block op = { -1 };
+
+	ck_assert_msg(op_block(&req, notifyfd, NULL, &op) == 0,
+		      strerror(errno));
 	/*
 	 * The tests use getpid that returns the error with ret and it is always
 	 * successful
 	 */
-	check_target_result(operations[0].block.error, 1, false);
+	check_target_result(op.error, 1, false);
 }
 END_TEST
 
-START_TEST(test_act_return)
+static void test_op_return(enum gluten_offset_type type, uint16_t offset)
 {
-	struct op operations[] = {
-		{
-			.type = OP_RETURN,
-			.ret = { .type = IMMEDIATE, .value = 1 },
-		},
-	};
-	int ret = do_operations(NULL, operations, &req,
-				sizeof(operations) / sizeof(operations[0]),
-				notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
-	check_target_result(1, 0, false);
+	struct op_return op = { { type, offset } };
+	int64_t v = 2;
+
+	ck_write_gluten(gluten, op.val, v);
+	ck_assert_msg(op_return(&req, notifyfd, &gluten, &op) == 0,
+		      strerror(errno));
+	check_target_result(v, 0, false);
 }
-END_TEST
 
-START_TEST(test_act_return_ref)
+START_TEST(test_op_return_ro_data)
 {
-	int64_t v = 2;
-	uint16_t offset = 4;
-	struct op operations[] = {
-		{
-			.type = OP_RETURN,
-			.ret = { .type = REFERENCE, .value_off = offset },
-		},
-	};
-	memcpy((uint16_t *)&tmp_data + offset, &v, sizeof(v));
+	test_op_return(OFFSET_RO_DATA, 4);
+}
+END_TEST
 
-	int ret = do_operations(&tmp_data, operations, &req,
-				sizeof(operations) / sizeof(operations[0]),
-				notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
-	check_target_result(v, 0, false);
+START_TEST(test_op_return_data)
+{
+	test_op_return(OFFSET_DATA, 4);
 }
 END_TEST
 
-START_TEST(test_act_call)
+START_TEST(test_op_call)
 {
 	struct op operations[] = {
-		{
-			.type = OP_CALL,
-			.call = { .nr = __NR_getppid, .has_ret = false },
-		},
-		{ .type = OP_CONT },
+		{ OP_CALL, { .call = { __NR_getppid, false } } },
+		{ OP_CONT, { { 0 } } },
+		{ OP_END, { { 0 } } },
+		{ 0 },
 	};
-	int ret = do_operations(NULL, operations, &req,
-				sizeof(operations) / sizeof(operations[0]),
-				notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
+
+	eval(&gluten, operations, &req, notifyfd);
 	check_target_result(1, 0, true);
 }
 END_TEST
 
-START_TEST(test_act_call_ret)
+START_TEST(test_op_call_ret)
 {
+	long r;
 	struct op operations[] = {
-		{
-			.type = OP_CALL,
-			.call = { .nr = __NR_getppid,
-				  .has_ret = true,
-				  .ret_off = 2 },
-		},
-		{ .type = OP_CONT },
+		{ OP_CALL,
+		  { .call = { __NR_getppid, true,
+			      .ret = { .type = OFFSET_DATA, .offset = 0 } } } },
+		{ OP_CONT, { { 0 } } },
+		{ OP_END, { { 0 } } },
+		{ 0 },
 	};
-	int ret = do_operations(&tmp_data, operations, &req,
-				sizeof(operations) / sizeof(operations[0]),
-				notifyfd);
-	long r;
-	ck_assert_msg(ret == 0, strerror(errno));
+
+	eval(&gluten, operations, &req, notifyfd);
 	check_target_result(1, 0, true);
-	memcpy(&r, &tmp_data[2], sizeof(r));
-	ck_assert_int_eq(r, getpid());
+	ck_read_gluten(gluten, operations[0].op.call.ret, r);
+	ck_assert(r == getpid());
 }
 END_TEST
 
-static void test_inject(struct op operations[], int n, bool reference)
+static void test_inject(enum gluten_offset_type type, bool atomic)
 {
-	uint16_t new_off = 2, old_off = 4;
-	int fd_inj;
+	struct op_inject op = { { type, 0 }, { type, 4 } };
 	int test_fd = 3;
-	int ret;
+	int fd_inj;
 
 	fd_inj = create_test_fd();
 	ck_assert_int_ge(fd_inj, 0);
-	if (reference) {
-		memcpy((uint16_t *)&tmp_data + new_off, &fd_inj,
-		       sizeof(fd_inj));
-		memcpy((uint16_t *)&tmp_data + old_off, &test_fd,
-		       sizeof(test_fd));
-
-		operations[0].inj.newfd.fd_off = new_off;
-		operations[0].inj.newfd.type = REFERENCE;
-		operations[0].inj.oldfd.fd_off = old_off;
-		operations[0].inj.oldfd.type = REFERENCE;
-	} else {
-		operations[0].inj.newfd.fd = fd_inj;
-		operations[0].inj.newfd.type = IMMEDIATE;
-		operations[0].inj.oldfd.fd = test_fd;
-		operations[0].inj.oldfd.type = IMMEDIATE;
-	}
-
-	ret = do_operations(&tmp_data, operations, &req, n, notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
+	ck_write_gluten(gluten, op.old_fd, test_fd);
+	ck_write_gluten(gluten, op.new_fd, fd_inj);
+
+	if (atomic)
+		op_inject(&req, notifyfd, &gluten, &op);
+	else
+		op_inject_a(&req, notifyfd, &gluten, &op);
 	check_target_fd(pid, test_fd);
 }
 
-START_TEST(test_act_inject_a)
+START_TEST(test_op_inject_a)
 {
-	struct op operations[] = { { .type = OP_INJECT_A } };
-	test_inject(operations, sizeof(operations) / sizeof(operations[0]), false);
+	test_inject(OFFSET_RO_DATA, true);
 }
 END_TEST
 
-START_TEST(test_act_inject_a_ref)
+START_TEST(test_op_inject_a_ref)
 {
-	struct op operations[] = { { .type = OP_INJECT_A } };
-	test_inject(operations, sizeof(operations) / sizeof(operations[0]), true);
+	test_inject(OFFSET_DATA, true);
 }
 END_TEST
 
-START_TEST(test_act_inject)
+START_TEST(test_op_inject)
 {
-	struct op operations[] = { { .type = OP_INJECT } };
-	test_inject(operations, sizeof(operations) / sizeof(operations[0]), false);
+	test_inject(OFFSET_RO_DATA, false);
 }
 END_TEST
 
-START_TEST(test_act_inject_ref)
+START_TEST(test_op_inject_ref)
 {
-	struct op operations[] = { { .type = OP_INJECT } };
-	test_inject(operations, sizeof(operations) / sizeof(operations[0]), true);
+	test_inject(OFFSET_DATA, false);
 }
 END_TEST
 
-START_TEST(test_op_copy)
+START_TEST(test_op_load)
 {
 	struct op operations[] = {
-		{ .type = OP_COPY_ARGS },
-		{
-			.type = OP_RETURN,
-			.ret = { .type = IMMEDIATE, .value = 0 },
-		},
+		{ OP_LOAD,
+		  { .load = { { OFFSET_SECCOMP_DATA, 1 },
+			      { OFFSET_DATA, 0 },
+			      sizeof(struct sockaddr_un) } } },
+		{ OP_RETURN,
+		  { .ret = { { OFFSET_DATA, sizeof(struct sockaddr_un) } } } },
+		{ OP_END, { { 0 } } },
+		{ 0 },
 	};
-	struct op_copy_args *o = &operations[0].copy;
-	struct sockaddr_un *addr;
-	socklen_t *len, expect;
-	int ret;
-
-	o->args[0] = (struct copy_arg){ .args_off = 0,
-					.type = IMMEDIATE,
-					.size = sizeof(int) };
-	o->args[1] =
-		(struct copy_arg){ .args_off = sizeof(int) / sizeof(uint16_t),
-				   .type = REFERENCE,
-				   .size = sizeof(struct sockaddr_un) };
-	o->args[2] = (struct copy_arg){ .args_off = o->args[1].args_off +
-						    sizeof(struct sockaddr_un) /
-							    sizeof(uint16_t),
-					.type = IMMEDIATE,
-					.size = sizeof(socklen_t) };
-	ret = do_operations(&tmp_data, operations, &req,
-			    sizeof(operations) / sizeof(operations[0]),
-			    notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
-	check_target_result(0, 0, false);
-	addr = (struct sockaddr_un *)(tmp_data + o->args[1].args_off);
-	ck_assert_str_eq(addr->sun_path, "/tmp/test.sock");
-	ck_assert(addr->sun_family == AF_UNIX);
-	expect = sizeof(addr->sun_path);
-	len = (socklen_t *)(tmp_data + o->args[2].args_off);
-	ck_assert_msg(*len == expect, "expect len %x to be equal to %x", *len,
-		      expect);
+	struct sockaddr_un addr;
+	int v = 2;
+
+	ck_write_gluten(gluten, operations[1].op.ret.val, v);
+	eval(&gluten, operations, &req, notifyfd);
+	check_target_result(v, 0, false);
+
+	ck_read_gluten(gluten, operations[0].op.load.dst, addr);
+	ck_assert_str_eq(addr.sun_path, "/tmp/test.sock");
+	ck_assert(addr.sun_family == AF_UNIX);
 }
 END_TEST
 
 static void test_op_cmp_int(int a, int b, enum op_cmp_type cmp)
 {
 	struct op operations[] = {
-		{ .type = OP_CMP,
-		  .cmp = { .s1_off = 0,
-			   .s2_off = sizeof(a) / sizeof(uint16_t),
-			   .size = sizeof(a),
-			   .cmp = cmp,
-			   .jmp = 2 } },
-		{ .type = OP_CONT },
-		{ .type = OP_END },
-		{ .type = OP_BLOCK, .block = { .error = -1 } },
+		{ OP_CMP,
+		  { .cmp = { { OFFSET_DATA, 0 },
+			     { OFFSET_DATA, 10 },
+			     sizeof(int),
+			     cmp,
+			     3 } } },
+		{ OP_BLOCK, { .block = { -1 } } },
+		{ OP_END, { { 0 } } },
+		{ OP_CONT, { { 0 } } },
+		{ OP_END, { { 0 } } },
+		{ 0 },
 	};
-	int ret;
 
-	memcpy((uint16_t *)&tmp_data + operations[0].cmp.s1_off, &a, sizeof(a));
-	memcpy((uint16_t *)&tmp_data + operations[0].cmp.s2_off, &b, sizeof(b));
+	ck_write_gluten(gluten, operations[0].op.cmp.x, a);
+	ck_write_gluten(gluten, operations[0].op.cmp.y, b);
 
-	ret = do_operations(&tmp_data, operations, &req,
-			    sizeof(operations) / sizeof(operations[0]),
-			    notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
-	ck_assert_int_eq(at->err, 0);
+	eval(&gluten, operations, &req, notifyfd);
+	check_target_result_nonegative();
 }
 
 START_TEST(test_op_cmp_int_eq)
@@ -330,7 +264,7 @@ END_TEST
 
 START_TEST(test_op_cmp_int_gt)
 {
-	test_op_cmp_int(1, 2, CMP_GT);
+	test_op_cmp_int(2, 1, CMP_GT);
 }
 END_TEST
 
@@ -342,7 +276,7 @@ END_TEST
 
 START_TEST(test_op_cmp_int_lt)
 {
-	test_op_cmp_int(2, 1, CMP_LT);
+	test_op_cmp_int(1, 2, CMP_LT);
 }
 END_TEST
 
@@ -354,82 +288,74 @@ END_TEST
 
 START_TEST(test_op_cmp_string_eq)
 {
-	char s[30] = "Hello Test!!";
+	char s1[30] = "Hello Test!!";
+	char s2[30] = "Hello Test!!";
 	struct op operations[] = {
-		{ .type = OP_CMP,
-		  .cmp = { .s1_off = 0,
-			   .s2_off = sizeof(s) / sizeof(uint16_t),
-			   .size = sizeof(s),
-			   .cmp = CMP_EQ,
-			   .jmp = 2 } },
-		{ .type = OP_CONT },
-		{ .type = OP_END },
-		{ .type = OP_BLOCK, .block = { .error = -1 } },
+		{ OP_CMP,
+		  { .cmp = { { OFFSET_DATA, 0 },
+			     { OFFSET_DATA, 30 },
+			     sizeof(s1),
+			     CMP_EQ,
+			     3 } } },
+		{ OP_BLOCK, { .block = { -1 } } },
+		{ OP_END, { { 0 } } },
+		{ OP_CONT, { { 0 } } },
+		{ OP_END, { { 0 } } },
+		{ 0 },
 	};
-	int ret;
-
-	memcpy((uint16_t *)&tmp_data + operations[0].cmp.s1_off, &s, sizeof(s));
-	memcpy((uint16_t *)&tmp_data + operations[0].cmp.s2_off, &s, sizeof(s));
+	ck_write_gluten(gluten, operations[0].op.cmp.x, s1);
+	ck_write_gluten(gluten, operations[0].op.cmp.y, s2);
 
-	ret = do_operations(&tmp_data, operations, &req,
-			    sizeof(operations) / sizeof(operations[0]),
-			    notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
-	ck_assert_int_eq(at->err, 0);
+	eval(&gluten, operations, &req, notifyfd);
+	check_target_result_nonegative();
 }
 END_TEST
 
 START_TEST(test_op_cmp_string_false)
 {
 	char s1[30] = "Hello Test!!";
-	char s2[30] = "Hello World!!";
+	char s2[30] = "Hello Tost!!";
 	struct op operations[] = {
-		{ .type = OP_CMP,
-		  .cmp = { .s1_off = 0,
-			   .s2_off = sizeof(s1) / sizeof(uint16_t),
-			   .size = sizeof(s1),
-			   .cmp = CMP_EQ,
-			   .jmp = 2 } },
-		{ .type = OP_BLOCK, .block = { .error = -1 } },
-		{ .type = OP_END },
-		{ .type = OP_CONT },
+		{ OP_CMP,
+		  { .cmp = { { OFFSET_DATA, 0 },
+			     { OFFSET_DATA, 30 },
+			     sizeof(s1),
+			     CMP_EQ,
+			     2 } } },
+		{ OP_CONT, { { 0 } } },
+		{ OP_END, { { 0 } } },
+		{ OP_BLOCK, { .block = { -1 } } },
+		{ OP_END, { { 0 } } },
+		{ 0 },
 	};
-	int ret;
 
-	memcpy((uint16_t *)&tmp_data + operations[0].cmp.s1_off, &s1,
-	       sizeof(s1));
-	memcpy((uint16_t *)&tmp_data + operations[0].cmp.s2_off, &s2,
-	       sizeof(s2));
+	ck_write_gluten(gluten, operations[0].op.cmp.x, s1);
+	ck_write_gluten(gluten, operations[0].op.cmp.y, s2);
 
-	ret = do_operations(&tmp_data, operations, &req,
-			    sizeof(operations) / sizeof(operations[0]),
-			    notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
-	ck_assert_int_eq(at->err, 0);
+	eval(&gluten, operations, &req, notifyfd);
+	check_target_result_nonegative();
 }
 END_TEST
 
 START_TEST(test_op_resolvedfd_eq)
 {
 	struct op operations[] = {
-		{ .type = OP_RESOLVEDFD,
-		  .resfd = { .fd_off = 0,
-			     .path_off = sizeof(int) / sizeof(uint16_t),
-			     .path_size = sizeof(path),
-			     .jmp = 2 } },
-		{ .type = OP_CONT },
-		{ .type = OP_END },
-		{ .type = OP_BLOCK, .block = { .error = -1 } },
+		{ OP_RESOLVEDFD,
+		  { .resfd = { { OFFSET_DATA, 0 },
+			       { OFFSET_DATA, 4 },
+			       sizeof(path),
+			       3 } } },
+		{ OP_BLOCK, { .block = { -1 } } },
+		{ OP_END, { { 0 } } },
+		{ OP_CONT, { { 0 } } },
+		{ OP_END, { { 0 } } },
+		{ 0 },
 	};
 
-	memcpy((uint16_t *)&tmp_data + operations[0].resfd.fd_off, &at->fd,
-	       sizeof(at->fd));
-	memcpy((uint16_t *)&tmp_data + operations[0].resfd.path_off, &path,
-	       sizeof(path));
-	int ret = do_operations(&tmp_data, operations, &req,
-				sizeof(operations) / sizeof(operations[0]),
-				notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
+	ck_write_gluten(gluten, operations[0].op.resfd.fd, at->fd);
+	ck_write_gluten(gluten, operations[0].op.resfd.path, path);
+
+	eval(&gluten, operations, &req, notifyfd);
 	check_target_result(-1, 1, false);
 }
 END_TEST
@@ -438,27 +364,26 @@ START_TEST(test_op_resolvedfd_neq)
 {
 	char path2[] = "/tmp/seitan-test-wrong";
 	struct op operations[] = {
-		{ .type = OP_RESOLVEDFD,
-		  .resfd = { .fd_off = 0,
-			     .path_off = sizeof(int) / sizeof(uint16_t),
-			     .path_size = sizeof(path2),
-			     .jmp = 2 } },
-		{ .type = OP_CONT },
-		{ .type = OP_END },
-		{ .type = OP_BLOCK, .block = { .error = -1 } },
+		{ OP_RESOLVEDFD,
+		  { .resfd = { { OFFSET_DATA, 0 },
+			       { OFFSET_DATA, 4 },
+			       sizeof(path),
+			       3 } } },
+		{ OP_BLOCK, { .block = { -1 } } },
+		{ OP_END, { { 0 } } },
+		{ OP_CONT, { { 0 } } },
+		{ OP_END, { { 0 } } },
+		{ 0 },
 	};
-	memcpy((uint16_t *)&tmp_data + operations[0].resfd.fd_off, &at->fd,
-	       sizeof(at->fd));
-	memcpy((uint16_t *)&tmp_data + operations[0].resfd.path_off, &path2,
-	       sizeof(path2));
-	int ret = do_operations(&tmp_data, operations, &req,
-				sizeof(operations) / sizeof(operations[0]),
-				notifyfd);
-	ck_assert_msg(ret == 0, strerror(errno));
+
+	ck_write_gluten(gluten, operations[0].op.resfd.fd, at->fd);
+	ck_write_gluten(gluten, operations[0].op.resfd.path, path2);
+
+	eval(&gluten, operations, &req, notifyfd);
+	check_target_result(-1, 1, false);
 }
 END_TEST
 
-
 Suite *op_call_suite(void)
 {
 	Suite *s;
@@ -466,55 +391,55 @@ Suite *op_call_suite(void)
 	TCase *cont, *block, *ret, *call, *resolvedfd;
 	TCase *cmp, *cmpint;
 	TCase *inject, *inject_a;
-	TCase *copy;
+	TCase *load;
 
 	s = suite_create("Perform operations");
 
-	cont = tcase_create("a_continue");
+	cont = tcase_create("op_continue");
 	tcase_add_checked_fixture(cont, setup_without_fd, teardown);
 	tcase_set_timeout(cont, timeout);
-	tcase_add_test(cont, test_act_continue);
+	tcase_add_test(cont, test_op_continue);
 	suite_add_tcase(s, cont);
 
-	ret = tcase_create("a_return");
-	tcase_add_checked_fixture(ret, setup_without_fd, teardown);
-	tcase_set_timeout(ret, timeout);
-	tcase_add_test(ret, test_act_return);
-	tcase_add_test(ret, test_act_return_ref);
-	suite_add_tcase(s, ret);
-
-	block = tcase_create("a_block");
+	block = tcase_create("op_block");
 	tcase_add_checked_fixture(block, setup_without_fd, teardown);
 	tcase_set_timeout(block, timeout);
-	tcase_add_test(block, test_act_block);
+	tcase_add_test(block, test_op_block);
 	suite_add_tcase(s, block);
 
-	call = tcase_create("a_call");
+	ret = tcase_create("op_return");
+	tcase_add_checked_fixture(ret, setup_without_fd, teardown);
+	tcase_set_timeout(ret, timeout);
+	tcase_add_test(ret, test_op_return_ro_data);
+	tcase_add_test(ret, test_op_return_data);
+	suite_add_tcase(s, ret);
+
+	call = tcase_create("op_call");
 	tcase_add_checked_fixture(call, setup_without_fd, teardown);
 	tcase_set_timeout(call, timeout);
-	tcase_add_test(call, test_act_call);
-	tcase_add_test(call, test_act_call_ret);
+	tcase_add_test(call, test_op_call);
+	tcase_add_test(call, test_op_call_ret);
 	suite_add_tcase(s, call);
 
-	inject = tcase_create("a_inject");
+	inject = tcase_create("op_inject");
 	tcase_add_checked_fixture(inject, setup_fd, teardown);
 	tcase_set_timeout(inject, timeout);
-	tcase_add_test(inject, test_act_inject);
-	tcase_add_test(inject, test_act_inject_ref);
+	tcase_add_test(inject, test_op_inject);
+	tcase_add_test(inject, test_op_inject_ref);
 	suite_add_tcase(s, inject);
 
-	inject_a = tcase_create("a_inject_a");
+	inject_a = tcase_create("op_inject_a");
 	tcase_add_checked_fixture(inject_a, setup_fd, teardown);
 	tcase_set_timeout(inject_a, timeout);
-	tcase_add_test(inject_a, test_act_inject_a);
-	tcase_add_test(inject_a, test_act_inject_a_ref);
+	tcase_add_test(inject_a, test_op_inject_a);
+	tcase_add_test(inject_a, test_op_inject_a_ref);
 	suite_add_tcase(s, inject_a);
 
-	copy = tcase_create("op_copy");
-	tcase_add_checked_fixture(copy, setup_target_connect, teardown);
-	tcase_set_timeout(copy, 120);
-	tcase_add_test(copy, test_op_copy);
-	suite_add_tcase(s, copy);
+	load = tcase_create("op_load");
+	tcase_add_checked_fixture(load, setup_target_connect, teardown);
+	tcase_set_timeout(load, 120);
+	tcase_add_test(load, test_op_load);
+	suite_add_tcase(s, load);
 
 	cmp = tcase_create("op_cmp");
 	tcase_add_checked_fixture(cmp, setup_without_fd, teardown);
diff --git a/tests/unit/testutil.h b/tests/unit/testutil.h
index d6a1c46..45fe08f 100644
--- a/tests/unit/testutil.h
+++ b/tests/unit/testutil.h
@@ -8,10 +8,44 @@
 #include <limits.h>
 
 #include <check.h>
-#include "filter.h"
+#include "cooker/filter.h"
+
+#ifndef SEITAN_TEST
+#define SEITAN_TEST
+#endif
+#include "common/gluten.h"
 
 #define STACK_SIZE (1024 * 1024 / 8)
 
+static inline void *test_gluten_write_ptr(struct gluten *g,
+					  const struct gluten_offset x)
+{
+	switch (x.type) {
+	case OFFSET_DATA:
+		return (char *)g->data + x.offset;
+	case OFFSET_RO_DATA:
+		return (char *)g->ro_data + x.offset;
+	case OFFSET_INSTRUCTION:
+		return (struct op *)(g->inst) + x.offset;
+	default:
+		return NULL;
+	}
+}
+
+#define ck_write_gluten(gluten, value, ref)                            \
+	do {                                                           \
+		void *p = test_gluten_write_ptr(&gluten, value);       \
+		ck_assert_ptr_nonnull(p);                              \
+		memcpy(p, &ref, sizeof(ref));                          \
+	} while (0)
+
+#define ck_read_gluten(gluten, value, ref)                       \
+	do {                                                     \
+		void *p = test_gluten_write_ptr(&gluten, value); \
+		ck_assert_ptr_nonnull(p);                        \
+		memcpy(&ref, p, sizeof(ref));                    \
+	} while (0)
+
 struct args_target {
         long ret;
         int err;
@@ -32,7 +66,7 @@ extern int pipefd[2];
 extern pid_t pid;
 extern char path[PATH_MAX];
 
-extern uint16_t tmp_data[TMP_DATA_SIZE];
+extern struct gluten gluten;
 
 int target();
 pid_t do_clone(int (*fn)(void *), void *arg);
@@ -48,5 +82,5 @@ int install_notification_filter(struct args_target *at);
 void continue_target();
 void mock_syscall_target();
 void set_args_no_check(struct args_target *at);
-
+void check_target_result_nonegative();
 #endif /* TESTUTIL_H */
diff --git a/tests/unit/util.c b/tests/unit/util.c
index f552ea2..45171f2 100644
--- a/tests/unit/util.c
+++ b/tests/unit/util.c
@@ -21,8 +21,7 @@
 #include <sys/socket.h>
 
 #include "testutil.h"
-#include "common.h"
-#include "filter.h"
+#include "common/common.h"
 
 struct seccomp_notif req;
 int notifyfd;
@@ -30,7 +29,7 @@ struct args_target *at;
 int pipefd[2];
 pid_t pid;
 char path[PATH_MAX] = "/tmp/test-seitan";
-uint16_t tmp_data[TMP_DATA_SIZE];
+struct gluten gluten;
 
 int install_notification_filter(struct args_target *at)
 {
@@ -155,6 +154,17 @@ void check_target_result(long ret, int err, bool ignore_ret)
 	ck_assert_int_eq(close(pipefd[0]), 0);
 }
 
+void check_target_result_nonegative()
+{
+	int buf;
+
+	read(pipefd[0], &buf, 1);
+	ck_assert_msg(at->ret > -1,
+		      "expect return value %ld to be greater then -1", at->ret);
+	ck_assert_int_eq(at->err, 0);
+	ck_assert_int_eq(close(pipefd[0]), 0);
+}
+
 void continue_target()
 {
 	struct seccomp_notif_resp resp;