s4:torture: use torture api instead of printf for RAW-LOCK

metze

1 files changed, 168 insertions, 234 deletions

diff --git a/source4/torture/raw/lock.c b/source4/torture/raw/lock.c
index 7e3ac29809..f756622f8f 100644
--- a/source4/torture/raw/lock.c
+++ b/source4/torture/raw/lock.c
@@ -32,25 +32,28 @@
 
 #define CHECK_STATUS(status, correct) do { \
 	if (!NT_STATUS_EQUAL(status, correct)) { \
-		printf("(%s) Incorrect status %s - should be %s\n", \
-		       __location__, nt_errstr(status), nt_errstr(correct)); \
+		torture_result(tctx, TORTURE_FAIL, \
+			"(%s) Incorrect status %s - should be %s\n", \
+			__location__, nt_errstr(status), nt_errstr(correct)); \
 		ret = false; \
 		goto done; \
 	}} while (0)
 
 #define CHECK_STATUS_CONT(status, correct) do { \
 	if (!NT_STATUS_EQUAL(status, correct)) { \
-		printf("(%s) Incorrect status %s - should be %s\n", \
-		       __location__, nt_errstr(status), nt_errstr(correct)); \
+		torture_result(tctx, TORTURE_FAIL, \
+			"(%s) Incorrect status %s - should be %s\n", \
+			__location__, nt_errstr(status), nt_errstr(correct)); \
 		ret = false; \
 	}} while (0)
 
 #define CHECK_STATUS_OR(status, correct1, correct2) do { \
 	if ((!NT_STATUS_EQUAL(status, correct1)) && \
 	    (!NT_STATUS_EQUAL(status, correct2))) { \
-		printf("(%s) Incorrect status %s - should be %s or %s\n", \
-		       __location__, nt_errstr(status), nt_errstr(correct1), \
-		       nt_errstr(correct2)); \
+		torture_result(tctx, TORTURE_FAIL, \
+			"(%s) Incorrect status %s - should be %s or %s\n", \
+			__location__, nt_errstr(status), nt_errstr(correct1), \
+			nt_errstr(correct2)); \
 		ret = false; \
 		goto done; \
 	}} while (0)
@@ -58,9 +61,10 @@
 #define CHECK_STATUS_OR_CONT(status, correct1, correct2) do { \
 	if ((!NT_STATUS_EQUAL(status, correct1)) && \
 	    (!NT_STATUS_EQUAL(status, correct2))) { \
-		printf("(%s) Incorrect status %s - should be %s or %s\n", \
-		       __location__, nt_errstr(status), nt_errstr(correct1), \
-		       nt_errstr(correct2)); \
+		torture_result(tctx, TORTURE_FAIL, \
+			"(%s) Incorrect status %s - should be %s or %s\n", \
+			__location__, nt_errstr(status), nt_errstr(correct1), \
+			nt_errstr(correct2)); \
 		ret = false; \
 	}} while (0)
 #define BASEDIR "\\testlock"
@@ -82,17 +86,15 @@ static bool test_lock(struct torture_context *tctx, struct smbcli_state *cli)
 		return false;
 	}
 
-	printf("Testing RAW_LOCK_LOCK\n");
+	torture_comment(tctx, "Testing RAW_LOCK_LOCK\n");
 	io.generic.level = RAW_LOCK_LOCK;
 	
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
-	printf("Trying 0/0 lock\n");
+	torture_comment(tctx, "Trying 0/0 lock\n");
 	io.lock.level = RAW_LOCK_LOCK;
 	io.lock.in.file.fnum = fnum;
 	io.lock.in.count = 0;
@@ -107,7 +109,7 @@ static bool test_lock(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
-	printf("Trying 0/1 lock\n");
+	torture_comment(tctx, "Trying 0/1 lock\n");
 	io.lock.level = RAW_LOCK_LOCK;
 	io.lock.in.file.fnum = fnum;
 	io.lock.in.count = 1;
@@ -125,7 +127,7 @@ static bool test_lock(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying 0xEEFFFFFF lock\n");
+	torture_comment(tctx, "Trying 0xEEFFFFFF lock\n");
 	io.lock.level = RAW_LOCK_LOCK;
 	io.lock.in.file.fnum = fnum;
 	io.lock.in.count = 4000;
@@ -143,7 +145,7 @@ static bool test_lock(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying 0xEF000000 lock\n");
+	torture_comment(tctx, "Trying 0xEF000000 lock\n");
 	io.lock.level = RAW_LOCK_LOCK;
 	io.lock.in.file.fnum = fnum;
 	io.lock.in.count = 4000;
@@ -161,7 +163,7 @@ static bool test_lock(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying max lock\n");
+	torture_comment(tctx, "Trying max lock\n");
 	io.lock.level = RAW_LOCK_LOCK;
 	io.lock.in.file.fnum = fnum;
 	io.lock.in.count = 4000;
@@ -179,7 +181,7 @@ static bool test_lock(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying wrong pid unlock\n");
+	torture_comment(tctx, "Trying wrong pid unlock\n");
 	io.lock.level = RAW_LOCK_LOCK;
 	io.lock.in.file.fnum = fnum;
 	io.lock.in.count = 4002;
@@ -218,15 +220,13 @@ static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
 		return false;
 	}
 
-	printf("Testing RAW_LOCK_LOCKX\n");
+	torture_comment(tctx, "Testing RAW_LOCK_LOCKX\n");
 	io.generic.level = RAW_LOCK_LOCKX;
 	
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
@@ -242,7 +242,7 @@ static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 
-	printf("Trying 0xEEFFFFFF lock\n");
+	torture_comment(tctx, "Trying 0xEEFFFFFF lock\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	lock[0].count = 4000;
@@ -260,7 +260,7 @@ static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying 0xEF000000 lock\n");
+	torture_comment(tctx, "Trying 0xEF000000 lock\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	lock[0].count = 4000;
@@ -278,7 +278,7 @@ static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying zero lock\n");
+	torture_comment(tctx, "Trying zero lock\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	lock[0].count = 0;
@@ -296,7 +296,7 @@ static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying max lock\n");
+	torture_comment(tctx, "Trying max lock\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	lock[0].count = 0;
@@ -314,7 +314,7 @@ static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying 2^63\n");
+	torture_comment(tctx, "Trying 2^63\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	lock[0].count = 1;
@@ -333,7 +333,7 @@ static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying 2^63 - 1\n");
+	torture_comment(tctx, "Trying 2^63 - 1\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	lock[0].count = 1;
@@ -353,7 +353,7 @@ static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	printf("Trying max lock 2\n");
+	torture_comment(tctx, "Trying max lock 2\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	lock[0].count = 1;
@@ -408,20 +408,20 @@ static bool test_pidhigh(struct torture_context *tctx,
 		return false;
 	}
 
-	printf("Testing high pid\n");
+	torture_comment(tctx, "Testing high pid\n");
 	io.generic.level = RAW_LOCK_LOCKX;
 
 	cli->session->pid = 1;
 	
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
 	if (smbcli_write(cli->tree, fnum, 0, &c, 0, 1) != 1) {
-		printf("Failed to write 1 byte - %s\n", smbcli_errstr(cli->tree));
+		torture_result(tctx, TORTURE_FAIL,
+			"Failed to write 1 byte - %s\n",
+			smbcli_errstr(cli->tree));
 		ret = false;
 		goto done;
 	}
@@ -440,7 +440,9 @@ static bool test_pidhigh(struct torture_context *tctx,
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	if (smbcli_read(cli->tree, fnum, &c, 0, 1) != 1) {
-		printf("Failed to read 1 byte - %s\n", smbcli_errstr(cli->tree));
+		torture_result(tctx, TORTURE_FAIL,
+			"Failed to read 1 byte - %s\n",
+			smbcli_errstr(cli->tree));
 		ret = false;
 		goto done;
 	}
@@ -448,7 +450,8 @@ static bool test_pidhigh(struct torture_context *tctx,
 	cli->session->pid = 2;
 
 	if (smbcli_read(cli->tree, fnum, &c, 0, 1) == 1) {
-		printf("pid is incorrect handled for read with lock!\n");
+		torture_result(tctx, TORTURE_FAIL,
+			"pid is incorrect handled for read with lock!\n");
 		ret = false;
 		goto done;
 	}
@@ -456,10 +459,11 @@ static bool test_pidhigh(struct torture_context *tctx,
 	cli->session->pid = 0x10001;
 
 	if (smbcli_read(cli->tree, fnum, &c, 0, 1) != 1) {
-		printf("High pid is used on this server!\n");
+		torture_result(tctx, TORTURE_FAIL,
+			"High pid is used on this server!\n");
 		ret = false;
 	} else {
-		printf("High pid is not used on this server (correct)\n");
+		torture_warning(tctx, "High pid is not used on this server (correct)\n");
 	}
 
 done:
@@ -497,15 +501,13 @@ static bool test_async(struct torture_context *tctx,
 
 	lp_smbcli_session_options(tctx->lp_ctx, &options);
 
-	printf("Testing LOCKING_ANDX_CANCEL_LOCK\n");
+	torture_comment(tctx, "Testing LOCKING_ANDX_CANCEL_LOCK\n");
 	io.generic.level = RAW_LOCK_LOCKX;
 
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
@@ -522,16 +524,13 @@ static bool test_async(struct torture_context *tctx,
 
 	t = time(NULL);
 
-	printf("testing cancel by CANCEL_LOCK\n");
+	torture_comment(tctx, "testing cancel by CANCEL_LOCK\n");
 
 	/* setup a timed lock */
 	io.lockx.in.timeout = 10000;
 	req = smb_raw_lock_send(cli->tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	/* cancel the wrong range */
 	lock[0].offset = 0;
@@ -558,13 +557,10 @@ static bool test_async(struct torture_context *tctx,
 	status = smbcli_request_simple_recv(req);
 	CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
 
-	if (time(NULL) > t+2) {
-		printf("lock cancel was not immediate (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) > t+2), talloc_asprintf(tctx,
+		       "lock cancel was not immediate (%s)\n", __location__));
 
-	printf("testing cancel by unlock\n");
+	torture_comment(tctx, "testing cancel by unlock\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
@@ -574,11 +570,8 @@ static bool test_async(struct torture_context *tctx,
 
 	io.lockx.in.timeout = 5000;
 	req = smb_raw_lock_send(cli->tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	io.lockx.in.ulock_cnt = 1;
 	io.lockx.in.lock_cnt = 0;
@@ -589,14 +582,11 @@ static bool test_async(struct torture_context *tctx,
 	status = smbcli_request_simple_recv(req);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
-	if (time(NULL) > t+2) {
-		printf("lock cancel by unlock was not immediate (%s) - took %d secs\n", 
-		       __location__, (int)(time(NULL)-t));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) > t+2), talloc_asprintf(tctx,
+		       "lock cancel by unlock was not immediate (%s) - took %d secs\n",
+		       __location__, (int)(time(NULL)-t)));
 
-	printf("testing cancel by close\n");
+	torture_comment(tctx, "testing cancel by close\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
@@ -607,11 +597,8 @@ static bool test_async(struct torture_context *tctx,
 	t = time(NULL);
 	io.lockx.in.timeout = 10000;
 	req = smb_raw_lock_send(cli->tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	status = smbcli_close(cli->tree, fnum);
 	CHECK_STATUS(status, NT_STATUS_OK);
@@ -619,13 +606,10 @@ static bool test_async(struct torture_context *tctx,
 	status = smbcli_request_simple_recv(req);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	if (time(NULL) > t+2) {
-		printf("lock cancel by close was not immediate (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) > t+2), talloc_asprintf(tctx,
+		       "lock cancel by close was not immediate (%s)\n", __location__));
 
-	printf("create a new sessions\n");
+	torture_comment(tctx, "create a new sessions\n");
 	session = smbcli_session_init(cli->transport, tctx, false, options);
 	setup.in.sesskey = cli->transport->negotiate.sesskey;
 	setup.in.capabilities = cli->transport->negotiate.capabilities;
@@ -636,7 +620,7 @@ static bool test_async(struct torture_context *tctx,
 	CHECK_STATUS(status, NT_STATUS_OK);
 	session->vuid = setup.out.vuid;
 
-	printf("create new tree context\n");
+	torture_comment(tctx, "create new tree context\n");
 	share = torture_setting_string(tctx, "share", NULL);
 	host  = torture_setting_string(tctx, "host", NULL);
 	tree = smbcli_tree_init(session, tctx, false);
@@ -649,14 +633,13 @@ static bool test_async(struct torture_context *tctx,
 	CHECK_STATUS(status, NT_STATUS_OK);
 	tree->tid = tcon.tconx.out.tid;
 
-	printf("testing cancel by exit\n");
+	torture_comment(tctx, "testing cancel by exit\n");
 	fname = BASEDIR "\\test_exit.txt";
 	fnum = smbcli_open(tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to reopen %s - %s\n", fname, smbcli_errstr(tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to reopen %s - %s\n",
+		       fname, smbcli_errstr(tree)));
+
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
 	io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
@@ -680,11 +663,8 @@ static bool test_async(struct torture_context *tctx,
 	io.lockx.in.timeout = 10000;
 	t = time(NULL);
 	req = smb_raw_lock_send(tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	status = smb_raw_exit(session);
 	CHECK_STATUS(status, NT_STATUS_OK);
@@ -692,20 +672,16 @@ static bool test_async(struct torture_context *tctx,
 	status = smbcli_request_simple_recv(req);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	if (time(NULL) > t+2) {
-		printf("lock cancel by exit was not immediate (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) > t+2), talloc_asprintf(tctx,
+		       "lock cancel by exit was not immediate (%s)\n", __location__));
 
-	printf("testing cancel by ulogoff\n");
+	torture_comment(tctx, "testing cancel by ulogoff\n");
 	fname = BASEDIR "\\test_ulogoff.txt";
 	fnum = smbcli_open(tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to reopen %s - %s\n", fname, smbcli_errstr(tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to reopen %s - %s\n",
+		       fname, smbcli_errstr(tree)));
+
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
 	io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
@@ -729,18 +705,16 @@ static bool test_async(struct torture_context *tctx,
 	io.lockx.in.timeout = 10000;
 	t = time(NULL);
 	req = smb_raw_lock_send(tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	status = smb_raw_ulogoff(session);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	status = smbcli_request_simple_recv(req);
 	if (NT_STATUS_EQUAL(NT_STATUS_FILE_LOCK_CONFLICT, status)) {
-		printf("lock not canceled by ulogoff - %s (ignored because of vfs_vifs fails it)\n",
+		torture_result(tctx, TORTURE_FAIL,
+			"lock not canceled by ulogoff - %s (ignored because of vfs_vifs fails it)\n",
 			nt_errstr(status));
 		smb_tree_disconnect(tree);
 		smb_raw_exit(session);
@@ -748,22 +722,18 @@ static bool test_async(struct torture_context *tctx,
 	}
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	if (time(NULL) > t+2) {
-		printf("lock cancel by ulogoff was not immediate (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) > t+2), talloc_asprintf(tctx,
+		       "lock cancel by ulogoff was not immediate (%s)\n", __location__));
 
-	printf("testing cancel by tdis\n");
+	torture_comment(tctx, "testing cancel by tdis\n");
 	tree->session = cli->session;
 
 	fname = BASEDIR "\\test_tdis.txt";
 	fnum = smbcli_open(tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to reopen %s - %s\n", fname, smbcli_errstr(tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to reopen %s - %s\n",
+		       fname, smbcli_errstr(tree)));
+
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
 	io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
@@ -783,11 +753,8 @@ static bool test_async(struct torture_context *tctx,
 	io.lockx.in.timeout = 10000;
 	t = time(NULL);
 	req = smb_raw_lock_send(tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	status = smb_tree_disconnect(tree);
 	CHECK_STATUS(status, NT_STATUS_OK);
@@ -795,11 +762,8 @@ static bool test_async(struct torture_context *tctx,
 	status = smbcli_request_simple_recv(req);
 	CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
-	if (time(NULL) > t+2) {
-		printf("lock cancel by tdis was not immediate (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) > t+2), talloc_asprintf(tctx,
+		       "lock cancel by tdis was not immediate (%s)\n", __location__));
 
 done:
 	smb_raw_exit(cli->session);
@@ -828,9 +792,9 @@ static bool test_errorcode(struct torture_context *tctx,
 		return false;
 	}
 
-	printf("Testing LOCK_NOT_GRANTED vs. FILE_LOCK_CONFLICT\n");
+	torture_comment(tctx, "Testing LOCK_NOT_GRANTED vs. FILE_LOCK_CONFLICT\n");
 
-	printf("testing with timeout = 0\n");
+	torture_comment(tctx, "testing with timeout = 0\n");
 	fname = BASEDIR "\\test0.txt";
 	t = 0;
 
@@ -1126,7 +1090,7 @@ next_run:
 	/* end of the loop */
 	if (t == 0) {
 		smb_raw_exit(cli->session);
-		printf("testing with timeout > 0 (=1)\n");
+		torture_comment(tctx, "testing with timeout > 0 (=1)\n");
 		fname = BASEDIR "\\test1.txt";
 		t = 1;
 		goto next_run;
@@ -1138,14 +1102,13 @@ next_run:
 	 * to the client (after the timeout went by)
 	 */
 	smb_raw_exit(cli->session);
-	printf("testing a conflict while a lock is pending\n");
+	torture_comment(tctx, "testing a conflict while a lock is pending\n");
 	fname = BASEDIR "\\test2.txt";
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to reopen %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to reopen %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
+
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
 	io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
@@ -1162,11 +1125,8 @@ next_run:
 	start = time(NULL);
 	io.lockx.in.timeout = 1000;
 	req = smb_raw_lock_send(cli->tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	io.lockx.in.timeout = 0;
 	lock[0].offset = 105;
@@ -1180,20 +1140,16 @@ next_run:
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
 
-	if (time(NULL) < start+1) {
-		printf("lock comes back to early (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) < start+1), talloc_asprintf(tctx,
+		       "lock comes back to early (%s)\n", __location__));
 
 	smbcli_close(cli->tree, fnum);
 	fname = BASEDIR "\\test3.txt";
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to reopen %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to reopen %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
+
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
 	io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
@@ -1210,11 +1166,8 @@ next_run:
 	start = time(NULL);
 	io.lockx.in.timeout = 1000;
 	req = smb_raw_lock_send(cli->tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	io.lockx.in.timeout = 0;
 	lock[0].offset = 105;
@@ -1230,20 +1183,16 @@ next_run:
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
 
-	if (time(NULL) < start+1) {
-		printf("lock comes back to early (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) < start+1), talloc_asprintf(tctx,
+		       "lock comes back to early (%s)\n", __location__));
 
 	smbcli_close(cli->tree, fnum);
 	fname = BASEDIR "\\test4.txt";
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to reopen %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to reopen %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
+
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
 	io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
@@ -1260,11 +1209,8 @@ next_run:
 	start = time(NULL);
 	io.lockx.in.timeout = 1000;
 	req = smb_raw_lock_send(cli->tree, &io);
-	if (req == NULL) {
-		printf("Failed to setup timed lock (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
+		       "Failed to setup timed lock (%s)\n", __location__));
 
 	io.lockx.in.timeout = 0;
 	status = smb_raw_lock(cli->tree, &io);
@@ -1276,11 +1222,8 @@ next_run:
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
 
-	if (time(NULL) < start+1) {
-		printf("lock comes back to early (%s)\n", __location__);
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,!(time(NULL) < start+1), talloc_asprintf(tctx,
+		       "lock comes back to early (%s)\n", __location__));
 
 done:
 	smb_raw_exit(cli->session);
@@ -1307,15 +1250,13 @@ static bool test_changetype(struct torture_context *tctx,
 		return false;
 	}
 
-	printf("Testing LOCKING_ANDX_CHANGE_LOCKTYPE\n");
+	torture_comment(tctx, "Testing LOCKING_ANDX_CHANGE_LOCKTYPE\n");
 	io.generic.level = RAW_LOCK_LOCKX;
 	
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
 	io.lockx.level = RAW_LOCK_LOCKX;
 	io.lockx.in.file.fnum = fnum;
@@ -1331,7 +1272,8 @@ static bool test_changetype(struct torture_context *tctx,
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	if (smbcli_write(cli->tree, fnum, 0, &c, 100, 1) == 1) {
-		printf("allowed write on read locked region (%s)\n", __location__);
+		torture_result(tctx, TORTURE_FAIL,
+			"allowed write on read locked region (%s)\n", __location__);
 		ret = false;
 		goto done;
 	}
@@ -1342,7 +1284,8 @@ static bool test_changetype(struct torture_context *tctx,
 	CHECK_STATUS(status, NT_STATUS_DOS(ERRDOS, ERRnoatomiclocks));
 
 	if (smbcli_write(cli->tree, fnum, 0, &c, 100, 1) == 1) {
-		printf("allowed write after lock change (%s)\n", __location__);
+		torture_result(tctx, TORTURE_FAIL,
+			"allowed write after lock change (%s)\n", __location__);
 		ret = false;
 		goto done;
 	}
@@ -1403,7 +1346,7 @@ static bool test_zerobytelocks(struct torture_context *tctx, struct smbcli_state
 	int fnum, i;
 	const char *fname = BASEDIR "\\zero.txt";
 
-	printf("Testing zero length byte range locks:\n");
+	torture_comment(tctx, "Testing zero length byte range locks:\n");
 
 	if (!torture_setup_dir(cli, BASEDIR)) {
 		return false;
@@ -1412,11 +1355,9 @@ static bool test_zerobytelocks(struct torture_context *tctx, struct smbcli_state
 	io.generic.level = RAW_LOCK_LOCKX;
 
 	fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
 	/* Setup initial parameters */
 	io.lockx.level = RAW_LOCK_LOCKX;
@@ -1430,7 +1371,7 @@ static bool test_zerobytelocks(struct torture_context *tctx, struct smbcli_state
 	for (i = 0;
 	     i < sizeof(zero_byte_tests) / sizeof(struct double_lock_test);
 	     i++) {
-		printf("  ... {%d, %llu, %llu} + {%d, %llu, %llu} = %s\n",
+		torture_comment(tctx, "  ... {%d, %llu, %llu} + {%d, %llu, %llu} = %s\n",
 		    zero_byte_tests[i].lock1.pid,
 		    zero_byte_tests[i].lock1.offset,
 		    zero_byte_tests[i].lock1.count,
@@ -1494,24 +1435,21 @@ static bool test_unlock(struct torture_context *tctx, struct smbcli_state *cli)
 	struct smb_lock_entry lock1;
 	struct smb_lock_entry lock2;
 
-	printf("Testing LOCKX unlock:\n");
+	torture_comment(tctx, "Testing LOCKX unlock:\n");
 
 	if (!torture_setup_dir(cli, BASEDIR)) {
 		return false;
 	}
 
 	fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum1 == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum1 != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
+
 	fnum2 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum2 == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum2 != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
 	/* Setup initial parameters */
 	io.lockx.level = RAW_LOCK_LOCKX;
@@ -1527,7 +1465,7 @@ static bool test_unlock(struct torture_context *tctx, struct smbcli_state *cli)
 	/**
 	 * Take exclusive lock, then unlock it with a shared-unlock call.
 	 */
-	printf("  taking exclusive lock.\n");
+	torture_comment(tctx, "  taking exclusive lock.\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	io.lockx.in.mode = 0;
@@ -1536,7 +1474,7 @@ static bool test_unlock(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
-	printf("  unlock the exclusive with a shared unlock call.\n");
+	torture_comment(tctx, "  unlock the exclusive with a shared unlock call.\n");
 	io.lockx.in.ulock_cnt = 1;
 	io.lockx.in.lock_cnt = 0;
 	io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
@@ -1545,7 +1483,7 @@ static bool test_unlock(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
-	printf("  try shared lock on pid2/fnum2, testing the unlock.\n");
+	torture_comment(tctx, "  try shared lock on pid2/fnum2, testing the unlock.\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
@@ -1557,7 +1495,7 @@ static bool test_unlock(struct torture_context *tctx, struct smbcli_state *cli)
 	/**
 	 * Unlock a shared lock with an exclusive-unlock call.
 	 */
-	printf("  unlock new shared lock with exclusive unlock call.\n");
+	torture_comment(tctx, "  unlock new shared lock with exclusive unlock call.\n");
 	io.lockx.in.ulock_cnt = 1;
 	io.lockx.in.lock_cnt = 0;
 	io.lockx.in.mode = 0;
@@ -1566,7 +1504,7 @@ static bool test_unlock(struct torture_context *tctx, struct smbcli_state *cli)
 	status = smb_raw_lock(cli->tree, &io);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
-	printf("  try exclusive lock on pid1, testing the unlock.\n");
+	torture_comment(tctx, "  try exclusive lock on pid1, testing the unlock.\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	io.lockx.in.mode = 0;
@@ -1585,7 +1523,7 @@ static bool test_unlock(struct torture_context *tctx, struct smbcli_state *cli)
 	 * Test unlocking of 0-byte locks.
 	 */
 
-	printf("  lock shared and exclusive 0-byte locks, testing that Windows "
+	torture_comment(tctx, "  lock shared and exclusive 0-byte locks, testing that Windows "
 	    "always unlocks the exclusive first.\n");
 	lock1.pid = cli->session->pid;
 	lock1.offset = 10;
@@ -1680,18 +1618,16 @@ static bool test_multiple_unlock(struct torture_context *tctx, struct smbcli_sta
 	struct smb_lock_entry lock2;
 	struct smb_lock_entry locks[2];
 
-	printf("Testing LOCKX multiple unlock:\n");
+	torture_comment(tctx, "Testing LOCKX multiple unlock:\n");
 
 	if (!torture_setup_dir(cli, BASEDIR)) {
 		return false;
 	}
 
 	fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum1 == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum1 != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
 	/* Setup initial parameters */
 	io.lockx.level = RAW_LOCK_LOCKX;
@@ -1711,7 +1647,7 @@ static bool test_multiple_unlock(struct torture_context *tctx, struct smbcli_sta
 	io.lockx.in.mode = 0; /* exclusive */
 
 	/** Test1: Take second lock, but not first. */
-	printf("  unlock 2 locks, first one not locked. Expect no locks "
+	torture_comment(tctx, "  unlock 2 locks, first one not locked. Expect no locks "
 	    "unlocked. \n");
 
 	io.lockx.in.ulock_cnt = 0;
@@ -1743,7 +1679,7 @@ static bool test_multiple_unlock(struct torture_context *tctx, struct smbcli_sta
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	/** Test2: Take first lock, but not second. */
-	printf("  unlock 2 locks, second one not locked. Expect first lock "
+	torture_comment(tctx, "  unlock 2 locks, second one not locked. Expect first lock "
 	    "unlocked.\n");
 
 	io.lockx.in.ulock_cnt = 0;
@@ -1796,7 +1732,7 @@ static bool test_stacking(struct torture_context *tctx, struct smbcli_state *cli
 	struct smb_lock_entry lock1;
 	struct smb_lock_entry lock2;
 
-	printf("Testing stacking:\n");
+	torture_comment(tctx, "Testing stacking:\n");
 
 	if (!torture_setup_dir(cli, BASEDIR)) {
 		return false;
@@ -1805,11 +1741,9 @@ static bool test_stacking(struct torture_context *tctx, struct smbcli_state *cli
 	io.generic.level = RAW_LOCK_LOCKX;
 
 	fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
-	if (fnum1 == -1) {
-		printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
-		ret = false;
-		goto done;
-	}
+	torture_assert(tctx,(fnum1 != -1), talloc_asprintf(tctx,
+		       "Failed to create %s - %s\n",
+		       fname, smbcli_errstr(cli->tree)));
 
 	/* Setup initial parameters */
 	io.lockx.level = RAW_LOCK_LOCKX;
@@ -1825,7 +1759,7 @@ static bool test_stacking(struct torture_context *tctx, struct smbcli_state *cli
 	/**
 	 * Try to take a shared lock, then stack an exclusive.
 	 */
-	printf("  stacking an exclusive on top of a shared lock fails.\n");
+	torture_comment(tctx, "  stacking an exclusive on top of a shared lock fails.\n");
 	io.lockx.in.file.fnum = fnum1;
 	io.lockx.in.locks = &lock1;
 
@@ -1851,7 +1785,7 @@ static bool test_stacking(struct torture_context *tctx, struct smbcli_state *cli
 	/**
 	 * Prove that two exclusive locks do not stack.
 	 */
-	printf("  two exclusive locks do not stack.\n");
+	torture_comment(tctx, "  two exclusive locks do not stack.\n");
 	io.lockx.in.ulock_cnt = 0;
 	io.lockx.in.lock_cnt = 1;
 	io.lockx.in.mode = 0;