r19339: Merge my 4.0-unittest branch. This adds an API for more fine-grained

output in the testsuite rather than just True or False for a
set of tests.

The aim is to use this for:
 * known failure lists (run all tests and detect tests that
						started working or started failing). This
   would allow us to get rid of the RPC-SAMBA3-* tests
 * nicer torture output
 * simplification of the testsuite system
 * compatibility with other unit testing systems
 * easier usage of smbtorture (being able to run one test
						and automatically set up the environment for that)

This is still a work-in-progress; expect more updates over the next couple of
days.
(This used to be commit 0eb6097305776325c75081356309115f445a7218)

1 files changed, 287 insertions, 464 deletions

diff --git a/source4/torture/basic/locking.c b/source4/torture/basic/locking.c
index c4aae64ca8..c966c667e6 100644
--- a/source4/torture/basic/locking.c
+++ b/source4/torture/basic/locking.c
@@ -24,6 +24,7 @@
 #include "includes.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/libcli.h"
+#include "torture/ui.h"
 #include "torture/util.h"
 #include "torture/torture.h"
 #include "system/time.h"
@@ -38,150 +39,113 @@
      must not use posix semantics)
   2) support for lock timeouts
  */
-BOOL torture_locktest1(struct torture_context *torture)
+bool torture_locktest1(struct torture_context *tctx, 
+					   struct smbcli_state *cli1,
+					   struct smbcli_state *cli2)
 {
-	struct smbcli_state *cli1, *cli2;
 	const char *fname = BASEDIR "\\lockt1.lck";
 	int fnum1, fnum2, fnum3;
 	time_t t1, t2;
 	uint_t lock_timeout;
 
-	if (!torture_open_connection(&cli1, 0) ||
-	    !torture_open_connection(&cli2, 1)) {
-		return False;
-	}
-
-	printf("starting locktest1\n");
-
 	if (!torture_setup_dir(cli1, BASEDIR)) {
 		return False;
 	}
 
 	fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
-	if (fnum1 == -1) {
-		printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree));
-		return False;
-	}
+	torture_assert(tctx, fnum1 != -1,
+				   talloc_asprintf(tctx, 
+		"open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree)));
 	fnum2 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
-	if (fnum2 == -1) {
-		printf("(%s) open2 of %s failed (%s)\n", 
-		       __location__, fname, smbcli_errstr(cli1->tree));
-		return False;
-	}
+	torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, 
+		"open2 of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree)));
 	fnum3 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
-	if (fnum3 == -1) {
-		printf("open3 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree));
-		return False;
-	}
+	torture_assert(tctx, fnum3 != -1, talloc_asprintf(tctx, 
+		"open3 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree)));
 
-	if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
-		printf("lock1 failed (%s)\n", smbcli_errstr(cli1->tree));
-		return False;
-	}
+	torture_assert_ntstatus_ok(tctx, 
+		smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK),
+		talloc_asprintf(tctx, "lock1 failed (%s)", smbcli_errstr(cli1->tree)));
 
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+		"lock2 succeeded! This is a locking bug\n");
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
-		printf("lock2 succeeded! This is a locking bug\n");
-		return False;
-	} else {
-		if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
-				 NT_STATUS_LOCK_NOT_GRANTED)) return False;
-	}
+	if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
+			 NT_STATUS_LOCK_NOT_GRANTED)) return False;
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
-		printf("lock2 succeeded! This is a locking bug\n");
-		return False;
-	} else {
-		if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
+	torture_assert(tctx,
+		!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+		"lock2 succeeded! This is a locking bug\n");
+
+	if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
 				 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
-	}
 
-	if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 5, 9, 0, WRITE_LOCK))) {
-		printf("lock1 failed (%s)\n", smbcli_errstr(cli1->tree));
-		return False;
-	}
+	torture_assert_ntstatus_ok(tctx, 
+		smbcli_lock(cli1->tree, fnum1, 5, 9, 0, WRITE_LOCK),
+		talloc_asprintf(tctx, 
+		"lock1 failed (%s)", smbcli_errstr(cli1->tree)));
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 5, 9, 0, WRITE_LOCK))) {
-		printf("lock2 succeeded! This is a locking bug\n");
-		return False;
-	} else {
-		if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 5, 9, 0, WRITE_LOCK)),
+		"lock2 succeeded! This is a locking bug");
+	
+	if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
 				 NT_STATUS_LOCK_NOT_GRANTED)) return False;
-	}
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
-		printf("lock2 succeeded! This is a locking bug\n");
-		return False;
-	} else {
-		if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+		"lock2 succeeded! This is a locking bug");
+	
+	if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
 				 NT_STATUS_LOCK_NOT_GRANTED)) return False;
-	}
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
-		printf("lock2 succeeded! This is a locking bug\n");
-		return False;
-	} else {
-		if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
-				 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+		"lock2 succeeded! This is a locking bug");
+
+	if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
+			 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 
 	lock_timeout = (6 + (random() % 20));
-	printf("Testing lock timeout with timeout=%u\n", lock_timeout);
+	torture_comment(tctx, "Testing lock timeout with timeout=%u\n", 
+					lock_timeout);
 	t1 = time(NULL);
-	if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK))) {
-		printf("lock3 succeeded! This is a locking bug\n");
-		return False;
-	} else {
-		if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)),
+		"lock3 succeeded! This is a locking bug\n");
+
+	if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
 				 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
-	}
 	t2 = time(NULL);
 
 	if (t2 - t1 < 5) {
-		printf("error: This server appears not to support timed lock requests\n");
+		torture_fail(tctx, 
+			"error: This server appears not to support timed lock requests");
 	}
-	printf("server slept for %u seconds for a %u second timeout\n",
+	torture_comment(tctx, "server slept for %u seconds for a %u second timeout\n",
 	       (uint_t)(t2-t1), lock_timeout);
 
-	if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum2))) {
-		printf("close1 failed (%s)\n", smbcli_errstr(cli1->tree));
-		return False;
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum2),
+		talloc_asprintf(tctx, "close1 failed (%s)", smbcli_errstr(cli1->tree)));
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
-		printf("lock4 succeeded! This is a locking bug\n");
-		return False;
-	} else {
-		if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
-				 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
-	}
-
-	if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
-		printf("close2 failed (%s)\n", smbcli_errstr(cli1->tree));
-		return False;
-	}
-
-	if (NT_STATUS_IS_ERR(smbcli_close(cli2->tree, fnum3))) {
-		printf("close3 failed (%s)\n", smbcli_errstr(cli2->tree));
-		return False;
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+		"lock4 succeeded! This is a locking bug");
+		
+	if (!check_error(__location__, cli2, ERRDOS, ERRlock, 
+			 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 
-	if (NT_STATUS_IS_ERR(smbcli_unlink(cli1->tree, fname))) {
-		printf("unlink failed (%s)\n", smbcli_errstr(cli1->tree));
-		return False;
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
+		talloc_asprintf(tctx, "close2 failed (%s)", smbcli_errstr(cli1->tree)));
 
+	torture_assert_ntstatus_ok(tctx, smbcli_close(cli2->tree, fnum3),
+		talloc_asprintf(tctx, "close3 failed (%s)", smbcli_errstr(cli2->tree)));
 
-	if (!torture_close_connection(cli1)) {
-		return False;
-	}
-
-	if (!torture_close_connection(cli2)) {
-		return False;
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_unlink(cli1->tree, fname),
+		talloc_asprintf(tctx, "unlink failed (%s)", smbcli_errstr(cli1->tree)));
 
-	printf("Passed locktest1\n");
-	return True;
+	return true;
 }
 
 
@@ -196,139 +160,110 @@ BOOL torture_locktest1(struct torture_context *torture)
 
   3) the server denies unlock requests by an incorrect client PID
 */
-BOOL torture_locktest2(struct torture_context *torture)
+bool torture_locktest2(struct torture_context *tctx,
+					   struct smbcli_state *cli)
 {
-	struct smbcli_state *cli;
 	const char *fname = BASEDIR "\\lockt2.lck";
 	int fnum1, fnum2, fnum3;
-	BOOL correct = True;
-
-	if (!torture_open_connection(&cli, 0)) {
-		return False;
-	}
-
-	printf("starting locktest2\n");
 
 	if (!torture_setup_dir(cli, BASEDIR)) {
 		return False;
 	}
 
-	printf("Testing pid context\n");
+	torture_comment(tctx, "Testing pid context\n");
 	
 	cli->session->pid = 1;
 
 	fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
-	if (fnum1 == -1) {
-		printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
-		return False;
-	}
+	torture_assert(tctx, fnum1 != -1, 
+		talloc_asprintf(tctx, 
+		"open of %s failed (%s)", fname, smbcli_errstr(cli->tree)));
 
 	fnum2 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
-	if (fnum2 == -1) {
-		printf("(%s) open2 of %s failed (%s)\n", 
-		       __location__, fname, smbcli_errstr(cli->tree));
-		return False;
-	}
+	torture_assert(tctx, fnum2 != -1,
+		talloc_asprintf(tctx, "open2 of %s failed (%s)", 
+		       fname, smbcli_errstr(cli->tree)));
 
 	cli->session->pid = 2;
 
 	fnum3 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
-	if (fnum3 == -1) {
-		printf("open3 of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
-		return False;
-	}
+	torture_assert(tctx, fnum3 != -1,
+		talloc_asprintf(tctx, 
+		"open3 of %s failed (%s)\n", fname, smbcli_errstr(cli->tree)));
 
 	cli->session->pid = 1;
 
-	if (NT_STATUS_IS_ERR(smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
-		printf("lock1 failed (%s)\n", smbcli_errstr(cli->tree));
-		return False;
-	}
+	torture_assert_ntstatus_ok(tctx, 
+		smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK),
+		talloc_asprintf(tctx, 
+		"lock1 failed (%s)", smbcli_errstr(cli->tree)));
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
-		printf("WRITE lock1 succeeded! This is a locking bug\n");
-		correct = False;
-	} else {
-		if (!check_error(__location__, cli, ERRDOS, ERRlock, 
-				 NT_STATUS_LOCK_NOT_GRANTED)) return False;
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK)),
+		"WRITE lock1 succeeded! This is a locking bug");
+		
+	if (!check_error(__location__, cli, ERRDOS, ERRlock, 
+			 NT_STATUS_LOCK_NOT_GRANTED)) return False;
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, WRITE_LOCK))) {
-		printf("WRITE lock2 succeeded! This is a locking bug\n");
-		correct = False;
-	} else {
-		if (!check_error(__location__, cli, ERRDOS, ERRlock, 
-				 NT_STATUS_LOCK_NOT_GRANTED)) return False;
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, WRITE_LOCK)),
+		"WRITE lock2 succeeded! This is a locking bug");
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, READ_LOCK))) {
-		printf("READ lock2 succeeded! This is a locking bug\n");
-		correct = False;
-	} else {
-		if (!check_error(__location__, cli, ERRDOS, ERRlock, 
-				 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
-	}
+	if (!check_error(__location__, cli, ERRDOS, ERRlock, 
+			 NT_STATUS_LOCK_NOT_GRANTED)) return False;
 
-	if (NT_STATUS_IS_ERR(smbcli_lock(cli->tree, fnum1, 100, 4, 0, WRITE_LOCK))) {
-		printf("lock at 100 failed (%s)\n", smbcli_errstr(cli->tree));
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, READ_LOCK)),
+		"READ lock2 succeeded! This is a locking bug");
+
+	if (!check_error(__location__, cli, ERRDOS, ERRlock, 
+			 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
+
+	torture_assert_ntstatus_ok(tctx, 
+		smbcli_lock(cli->tree, fnum1, 100, 4, 0, WRITE_LOCK),
+		talloc_asprintf(tctx, 
+		"lock at 100 failed (%s)", smbcli_errstr(cli->tree)));
 
 	cli->session->pid = 2;
 
-	if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 100, 4))) {
-		printf("unlock at 100 succeeded! This is a locking bug\n");
-		correct = False;
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 100, 4)),
+		"unlock at 100 succeeded! This is a locking bug");
 
-	if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 4))) {
-		printf("unlock1 succeeded! This is a locking bug\n");
-		correct = False;
-	} else {
-		if (!check_error(__location__, cli, 
-				 ERRDOS, ERRnotlocked, 
-				 NT_STATUS_RANGE_NOT_LOCKED)) return False;
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 4)),
+		"unlock1 succeeded! This is a locking bug");
 
-	if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 8))) {
-		printf("unlock2 succeeded! This is a locking bug\n");
-		correct = False;
-	} else {
-		if (!check_error(__location__, cli, 
+	if (!check_error(__location__, cli, 
 				 ERRDOS, ERRnotlocked, 
 				 NT_STATUS_RANGE_NOT_LOCKED)) return False;
-	}
 
-	if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
-		printf("lock3 succeeded! This is a locking bug\n");
-		correct = False;
-	} else {
-		if (!check_error(__location__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 8)),
+		"unlock2 succeeded! This is a locking bug");
 
-	cli->session->pid = 1;
+	if (!check_error(__location__, cli, 
+			 ERRDOS, ERRnotlocked, 
+			 NT_STATUS_RANGE_NOT_LOCKED)) return False;
 
-	if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum1))) {
-		printf("close1 failed (%s)\n", smbcli_errstr(cli->tree));
-		return False;
-	}
+	torture_assert(tctx, 
+		!NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+		"lock3 succeeded! This is a locking bug");
 
-	if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum2))) {
-		printf("close2 failed (%s)\n", smbcli_errstr(cli->tree));
-		return False;
-	}
+	if (!check_error(__location__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
 
-	if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum3))) {
-		printf("close3 failed (%s)\n", smbcli_errstr(cli->tree));
-		return False;
-	}
+	cli->session->pid = 1;
 
-	if (!torture_close_connection(cli)) {
-		correct = False;
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_close(cli->tree, fnum1), 
+		talloc_asprintf(tctx, "close1 failed (%s)", smbcli_errstr(cli->tree)));
 
-	printf("locktest2 finished\n");
+	torture_assert_ntstatus_ok(tctx, smbcli_close(cli->tree, fnum2),
+		talloc_asprintf(tctx, "close2 failed (%s)", smbcli_errstr(cli->tree)));
 
-	return correct;
+	torture_assert_ntstatus_ok(tctx, smbcli_close(cli->tree, fnum3),
+		talloc_asprintf(tctx, "close3 failed (%s)", smbcli_errstr(cli->tree)));
+
+	return true;
 }
 
 
@@ -337,157 +272,113 @@ BOOL torture_locktest2(struct torture_context *torture)
 
   1) the server supports the full offset range in lock requests
 */
-BOOL torture_locktest3(struct torture_context *torture)
+bool torture_locktest3(struct torture_context *tctx, 
+					   struct smbcli_state *cli1,
+					   struct smbcli_state *cli2)
 {
-	struct smbcli_state *cli1, *cli2;
 	const char *fname = BASEDIR "\\lockt3.lck";
 	int fnum1, fnum2, i;
 	uint32_t offset;
-	BOOL correct = True;
 	extern int torture_numops;
 
 #define NEXT_OFFSET offset += (~(uint32_t)0) / torture_numops
 
-	if (!torture_open_connection(&cli1, 0) ||
-	    !torture_open_connection(&cli2, 1)) {
-		return False;
-	}
-
-	printf("starting locktest3\n");
-
-	printf("Testing 32 bit offset ranges\n");
+	torture_comment(tctx, "Testing 32 bit offset ranges");
 
 	if (!torture_setup_dir(cli1, BASEDIR)) {
 		return False;
 	}
 
 	fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
-	if (fnum1 == -1) {
-		printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree));
-		return False;
-	}
+	torture_assert(tctx, fnum1 != -1, 
+		talloc_asprintf(tctx, "open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree)));
 	fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
-	if (fnum2 == -1) {
-		printf("open2 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree));
-		return False;
-	}
+	torture_assert(tctx, fnum2 != -1,
+		talloc_asprintf(tctx, "open2 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree)));
 
-	printf("Establishing %d locks\n", torture_numops);
+	torture_comment(tctx, "Establishing %d locks\n", torture_numops);
 
 	for (offset=i=0;i<torture_numops;i++) {
 		NEXT_OFFSET;
-		if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK))) {
-			printf("lock1 %d failed (%s)\n", 
-			       i,
-			       smbcli_errstr(cli1->tree));
-			return False;
-		}
+		torture_assert_ntstatus_ok(tctx, 
+			smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK),
+			talloc_asprintf(tctx, "lock1 %d failed (%s)", i, smbcli_errstr(cli1->tree)));
 
-		if (NT_STATUS_IS_ERR(smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK))) {
-			printf("lock2 %d failed (%s)\n", 
-			       i,
-			       smbcli_errstr(cli1->tree));
-			return False;
-		}
+		torture_assert_ntstatus_ok(tctx, 
+			smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK),
+			talloc_asprintf(tctx, "lock2 %d failed (%s)", 
+			       i, smbcli_errstr(cli1->tree)));
 	}
 
-	printf("Testing %d locks\n", torture_numops);
+	torture_comment(tctx, "Testing %d locks\n", torture_numops);
 
 	for (offset=i=0;i<torture_numops;i++) {
 		NEXT_OFFSET;
 
-		if (NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-2, 1, 0, WRITE_LOCK))) {
-			printf("error: lock1 %d succeeded!\n", i);
-			return False;
-		}
+		torture_assert(tctx, 
+			!NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-2, 1, 0, WRITE_LOCK)),
+			talloc_asprintf(tctx, "error: lock1 %d succeeded!", i));
 
-		if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-1, 1, 0, WRITE_LOCK))) {
-			printf("error: lock2 %d succeeded!\n", i);
-			return False;
-		}
+		torture_assert(tctx, 
+			!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-1, 1, 0, WRITE_LOCK)),
+			talloc_asprintf(tctx, "error: lock2 %d succeeded!", i));
 
-		if (NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK))) {
-			printf("error: lock3 %d succeeded!\n", i);
-			return False;
-		}
+		torture_assert(tctx, 
+			!NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK)),
+			talloc_asprintf(tctx, "error: lock3 %d succeeded!", i));
 
-		if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK))) {
-			printf("error: lock4 %d succeeded!\n", i);
-			return False;
-		}
+		torture_assert(tctx, 
+			!NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK)),
+			talloc_asprintf(tctx, "error: lock4 %d succeeded!", i));
 	}
 
-	printf("Removing %d locks\n", torture_numops);
+	torture_comment(tctx, "Removing %d locks\n", torture_numops);
 
 	for (offset=i=0;i<torture_numops;i++) {
 		NEXT_OFFSET;
 
-		if (NT_STATUS_IS_ERR(smbcli_unlock(cli1->tree, fnum1, offset-1, 1))) {
-			printf("unlock1 %d failed (%s)\n", 
+		torture_assert_ntstatus_ok(tctx, 
+					smbcli_unlock(cli1->tree, fnum1, offset-1, 1),
+					talloc_asprintf(tctx, "unlock1 %d failed (%s)", 
 			       i,
-			       smbcli_errstr(cli1->tree));
-			return False;
-		}
+			       smbcli_errstr(cli1->tree)));
 
-		if (NT_STATUS_IS_ERR(smbcli_unlock(cli2->tree, fnum2, offset-2, 1))) {
-			printf("unlock2 %d failed (%s)\n", 
+		torture_assert_ntstatus_ok(tctx, 
+			smbcli_unlock(cli2->tree, fnum2, offset-2, 1),
+			talloc_asprintf(tctx, "unlock2 %d failed (%s)", 
 			       i,
-			       smbcli_errstr(cli1->tree));
-			return False;
-		}
-	}
-
-	if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
-		printf("close1 failed (%s)\n", smbcli_errstr(cli1->tree));
-		return False;
-	}
-
-	if (NT_STATUS_IS_ERR(smbcli_close(cli2->tree, fnum2))) {
-		printf("close2 failed (%s)\n", smbcli_errstr(cli2->tree));
-		return False;
+			       smbcli_errstr(cli1->tree)));
 	}
 
-	if (NT_STATUS_IS_ERR(smbcli_unlink(cli1->tree, fname))) {
-		printf("unlink failed (%s)\n", smbcli_errstr(cli1->tree));
-		return False;
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
+		talloc_asprintf(tctx, "close1 failed (%s)", smbcli_errstr(cli1->tree)));
 
-	if (!torture_close_connection(cli1)) {
-		correct = False;
-	}
-	
-	if (!torture_close_connection(cli2)) {
-		correct = False;
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_close(cli2->tree, fnum2),
+		talloc_asprintf(tctx, "close2 failed (%s)", smbcli_errstr(cli2->tree)));
 
-	printf("finished locktest3\n");
+	torture_assert_ntstatus_ok(tctx, smbcli_unlink(cli1->tree, fname),
+		talloc_asprintf(tctx, "unlink failed (%s)", smbcli_errstr(cli1->tree)));
 
-	return correct;
+	return true;
 }
 
 #define EXPECTED(ret, v) if ((ret) != (v)) { \
-        printf("** "); correct = False; \
+        torture_comment(tctx, "** "); correct = False; \
         }
 
 /*
   looks at overlapping locks
 */
-BOOL torture_locktest4(struct torture_context *torture)
+BOOL torture_locktest4(struct torture_context *tctx, 
+					   struct smbcli_state *cli1,
+					   struct smbcli_state *cli2)
 {
-	struct smbcli_state *cli1, *cli2;
 	const char *fname = BASEDIR "\\lockt4.lck";
 	int fnum1, fnum2, f;
 	BOOL ret;
 	uint8_t buf[1000];
 	BOOL correct = True;
 
-	if (!torture_open_connection(&cli1, 0) ||
-	    !torture_open_connection(&cli2, 1)) {
-		return False;
-	}
-
-	printf("starting locktest4\n");
-
 	if (!torture_setup_dir(cli1, BASEDIR)) {
 		return False;
 	}
@@ -498,7 +389,7 @@ BOOL torture_locktest4(struct torture_context *torture)
 	memset(buf, 0, sizeof(buf));
 
 	if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
-		printf("Failed to create file\n");
+		torture_comment(tctx, "Failed to create file\n");
 		correct = False;
 		goto fail;
 	}
@@ -506,74 +397,74 @@ BOOL torture_locktest4(struct torture_context *torture)
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 2, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, False);
-	printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s set overlapping write locks\n", ret?"can":"cannot");
 	    
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 10, 4, 0, READ_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 12, 4, 0, READ_LOCK));
 	EXPECTED(ret, True);
-	printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s set overlapping read locks\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 20, 4, 0, WRITE_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 22, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, False);
-	printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
+	torture_comment(tctx, "a different connection %s set overlapping write locks\n", ret?"can":"cannot");
 	    
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 30, 4, 0, READ_LOCK)) &&
 		NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 32, 4, 0, READ_LOCK));
 	EXPECTED(ret, True);
-	printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
+	torture_comment(tctx, "a different connection %s set overlapping read locks\n", ret?"can":"cannot");
 	
 	ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 40, 4, 0, WRITE_LOCK))) &&
 	      NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 42, 4, 0, WRITE_LOCK)));
 	EXPECTED(ret, False);
-	printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
+	torture_comment(tctx, "a different pid %s set overlapping write locks\n", ret?"can":"cannot");
 	    
 	ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 50, 4, 0, READ_LOCK))) &&
 	      NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 52, 4, 0, READ_LOCK)));
 	EXPECTED(ret, True);
-	printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
+	torture_comment(tctx, "a different pid %s set overlapping read locks\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK));
 	EXPECTED(ret, True);
-	printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s set the same read lock twice\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, False);
-	printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s set the same write lock twice\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 80, 4, 0, READ_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 80, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, False);
-	printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 90, 4, 0, WRITE_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 90, 4, 0, READ_LOCK));
 	EXPECTED(ret, True);
-	printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 100, 4, 0, WRITE_LOCK))) &&
 	      NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 100, 4, 0, READ_LOCK)));
 	EXPECTED(ret, False);
-	printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
+	torture_comment(tctx, "a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 110, 4, 0, READ_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 112, 4, 0, READ_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 110, 6));
 	EXPECTED(ret, False);
-	printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s coalesce read locks\n", ret?"can":"cannot");
 
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 120, 4, 0, WRITE_LOCK)) &&
 	      (smbcli_read(cli2->tree, fnum2, buf, 120, 4) == 4);
 	EXPECTED(ret, False);
-	printf("this server %s strict write locking\n", ret?"doesn't do":"does");
+	torture_comment(tctx, "this server %s strict write locking\n", ret?"doesn't do":"does");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK)) &&
 	      (smbcli_write(cli2->tree, fnum2, 0, buf, 130, 4) == 4);
 	EXPECTED(ret, False);
-	printf("this server %s strict read locking\n", ret?"doesn't do":"does");
+	torture_comment(tctx, "this server %s strict read locking\n", ret?"doesn't do":"does");
 
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 140, 4, 0, READ_LOCK)) &&
@@ -581,7 +472,7 @@ BOOL torture_locktest4(struct torture_context *torture)
 	      NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 140, 4)) &&
 	      NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 140, 4));
 	EXPECTED(ret, True);
-	printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
+	torture_comment(tctx, "this server %s do recursive read locking\n", ret?"does":"doesn't");
 
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 150, 4, 0, WRITE_LOCK)) &&
@@ -591,21 +482,21 @@ BOOL torture_locktest4(struct torture_context *torture)
 	      !(smbcli_write(cli2->tree, fnum2, 0, buf, 150, 4) == 4) &&
 	      NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 150, 4));
 	EXPECTED(ret, True);
-	printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
+	torture_comment(tctx, "this server %s do recursive lock overlays\n", ret?"does":"doesn't");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 160, 4, 0, READ_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 160, 4)) &&
 	      (smbcli_write(cli2->tree, fnum2, 0, buf, 160, 4) == 4) &&		
 	      (smbcli_read(cli2->tree, fnum2, buf, 160, 4) == 4);		
 	EXPECTED(ret, True);
-	printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 170, 4, 0, WRITE_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 170, 4)) &&
 	      (smbcli_write(cli2->tree, fnum2, 0, buf, 170, 4) == 4) &&		
 	      (smbcli_read(cli2->tree, fnum2, buf, 170, 4) == 4);		
 	EXPECTED(ret, True);
-	printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 190, 4, 0, WRITE_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 190, 4, 0, READ_LOCK)) &&
@@ -613,7 +504,7 @@ BOOL torture_locktest4(struct torture_context *torture)
 	      !(smbcli_write(cli2->tree, fnum2, 0, buf, 190, 4) == 4) &&		
 	      (smbcli_read(cli2->tree, fnum2, buf, 190, 4) == 4);		
 	EXPECTED(ret, True);
-	printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
+	torture_comment(tctx, "the same process %s remove the first lock first\n", ret?"does":"doesn't");
 
 	smbcli_close(cli1->tree, fnum1);
 	smbcli_close(cli2->tree, fnum2);
@@ -627,38 +518,28 @@ BOOL torture_locktest4(struct torture_context *torture)
         smbcli_close(cli1->tree, f);
 	smbcli_close(cli1->tree, fnum1);
 	EXPECTED(ret, True);
-	printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
+	torture_comment(tctx, "the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
 
  fail:
 	smbcli_close(cli1->tree, fnum1);
 	smbcli_close(cli2->tree, fnum2);
 	smbcli_unlink(cli1->tree, fname);
-	torture_close_connection(cli1);
-	torture_close_connection(cli2);
 
-	printf("finished locktest4\n");
 	return correct;
 }
 
 /*
   looks at lock upgrade/downgrade.
 */
-BOOL torture_locktest5(struct torture_context *torture)
+BOOL torture_locktest5(struct torture_context *tctx, struct smbcli_state *cli1, 
+					   struct smbcli_state *cli2)
 {
-	struct smbcli_state *cli1, *cli2;
 	const char *fname = BASEDIR "\\lockt5.lck";
 	int fnum1, fnum2, fnum3;
 	BOOL ret;
 	uint8_t buf[1000];
 	BOOL correct = True;
 
-	if (!torture_open_connection(&cli1, 0) ||
-	    !torture_open_connection(&cli2, 1)) {
-		return False;
-	}
-
-	printf("starting locktest5\n");
-
 	if (!torture_setup_dir(cli1, BASEDIR)) {
 		return False;
 	}
@@ -669,11 +550,8 @@ BOOL torture_locktest5(struct torture_context *torture)
 
 	memset(buf, 0, sizeof(buf));
 
-	if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
-		printf("Failed to create file\n");
-		correct = False;
-		goto fail;
-	}
+	torture_assert(tctx, smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) == sizeof(buf),
+		"Failed to create file");
 
 	/* Check for NT bug... */
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 8, 0, READ_LOCK)) &&
@@ -682,7 +560,7 @@ BOOL torture_locktest5(struct torture_context *torture)
 	fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 7, 1, 0, WRITE_LOCK));
 	EXPECTED(ret, True);
-	printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
+	torture_comment(tctx, "this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
 	smbcli_close(cli1->tree, fnum1);
 	fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 	smbcli_unlock(cli1->tree, fnum3, 0, 1);
@@ -690,12 +568,12 @@ BOOL torture_locktest5(struct torture_context *torture)
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) &&
 	      NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 1, 1, 0, READ_LOCK));
 	EXPECTED(ret, True);
-	printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
 
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK));
 	EXPECTED(ret, False);
 
-	printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
+	torture_comment(tctx, "a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
 
 	/* Unlock the process 2 lock. */
 	smbcli_unlock(cli2->tree, fnum2, 0, 4);
@@ -703,7 +581,7 @@ BOOL torture_locktest5(struct torture_context *torture)
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum3, 0, 4, 0, READ_LOCK));
 	EXPECTED(ret, False);
 
-	printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
 
 	/* Unlock the process 1 fnum3 lock. */
 	smbcli_unlock(cli1->tree, fnum3, 0, 4);
@@ -713,7 +591,7 @@ BOOL torture_locktest5(struct torture_context *torture)
 		  NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, READ_LOCK));
 
 	EXPECTED(ret, True);
-	printf("the same process %s stack read locks\n", ret?"can":"cannot");
+	torture_comment(tctx, "the same process %s stack read locks\n", ret?"can":"cannot");
 
 	/* Unlock the first process lock, then check this was the WRITE lock that was
 		removed. */
@@ -722,7 +600,7 @@ ret = NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4)) &&
 	NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK));
 
 	EXPECTED(ret, True);
-	printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
+	torture_comment(tctx, "the first unlock removes the %s lock\n", ret?"WRITE":"READ");
 
 	/* Unlock the process 2 lock. */
 	smbcli_unlock(cli2->tree, fnum2, 0, 4);
@@ -734,32 +612,23 @@ ret = NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4)) &&
 		  NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4));
 
 	EXPECTED(ret, True);
-	printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot"); 
+	torture_comment(tctx, "the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot"); 
 
 	/* Ensure the next unlock fails. */
 	ret = NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4));
 	EXPECTED(ret, False);
-	printf("the same process %s count the lock stack\n", !ret?"can":"cannot"); 
+	torture_comment(tctx, "the same process %s count the lock stack\n", !ret?"can":"cannot"); 
 
 	/* Ensure connection 2 can get a write lock. */
 	ret = NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, True);
 
-	printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
+	torture_comment(tctx, "a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
 
 
- fail:
 	smbcli_close(cli1->tree, fnum1);
 	smbcli_close(cli2->tree, fnum2);
 	smbcli_unlink(cli1->tree, fname);
-	if (!torture_close_connection(cli1)) {
-		correct = False;
-	}
-	if (!torture_close_connection(cli2)) {
-		correct = False;
-	}
-
-	printf("finished locktest5\n");
        
 	return correct;
 }
@@ -767,51 +636,42 @@ ret = NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4)) &&
 /*
   tries the unusual lockingX locktype bits
 */
-BOOL torture_locktest6(struct torture_context *torture)
+BOOL torture_locktest6(struct torture_context *tctx, 
+					   struct smbcli_state *cli)
 {
-	struct smbcli_state *cli;
 	const char *fname[1] = { "\\lock6.txt" };
 	int i;
 	int fnum;
 	NTSTATUS status;
 
-	if (!torture_open_connection(&cli, 0)) {
-		return False;
-	}
-
 	if (!torture_setup_dir(cli, BASEDIR)) {
 		return False;
 	}
 
-	printf("starting locktest6\n");
-
 	for (i=0;i<1;i++) {
-		printf("Testing %s\n", fname[i]);
+		torture_comment(tctx, "Testing %s\n", fname[i]);
 
 		smbcli_unlink(cli->tree, fname[i]);
 
 		fnum = smbcli_open(cli->tree, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 		status = smbcli_locktype(cli->tree, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
 		smbcli_close(cli->tree, fnum);
-		printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
+		torture_comment(tctx, "CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
 
 		fnum = smbcli_open(cli->tree, fname[i], O_RDWR, DENY_NONE);
 		status = smbcli_locktype(cli->tree, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
 		smbcli_close(cli->tree, fnum);
-		printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
+		torture_comment(tctx, "CANCEL_LOCK gave %s\n", nt_errstr(status));
 
 		smbcli_unlink(cli->tree, fname[i]);
 	}
 
-	torture_close_connection(cli);
-
-	printf("finished locktest6\n");
 	return True;
 }
 
-BOOL torture_locktest7(struct torture_context *torture)
+BOOL torture_locktest7(struct torture_context *tctx, 
+					   struct smbcli_state *cli1)
 {
-	struct smbcli_state *cli1;
 	const char *fname = BASEDIR "\\lockt7.lck";
 	int fnum1;
 	int fnum2 = -1;
@@ -819,158 +679,109 @@ BOOL torture_locktest7(struct torture_context *torture)
 	uint8_t buf[200];
 	BOOL correct = False;
 
-	if (!torture_open_connection(&cli1, 0)) {
-		return False;
-	}
-
-	printf("starting locktest7\n");
-
-	if (!torture_setup_dir(cli1, BASEDIR)) {
-		return False;
-	}
+	torture_assert(tctx, torture_setup_dir(cli1, BASEDIR),
+				   talloc_asprintf(tctx, "Unable to set up %s", BASEDIR));
 
 	fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
 
 	memset(buf, 0, sizeof(buf));
 
-	if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
-		printf("Failed to create file (%s)\n", __location__);
-		goto fail;
-	}
+	torture_assert(tctx, smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) == sizeof(buf),
+		"Failed to create file");
 
 	cli1->session->pid = 1;
 
-	if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK))) {
-		printf("Unable to apply read lock on range 130:4, error was %s (%s)\n", 
-		       smbcli_errstr(cli1->tree), __location__);
-		goto fail;
-	} else {
-		printf("pid1 successfully locked range 130:4 for READ\n");
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK),
+		talloc_asprintf(tctx, "Unable to apply read lock on range 130:4, error was %s", 
+		       smbcli_errstr(cli1->tree)));
 
-	if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
-		printf("pid1 unable to read the range 130:4, error was %s (%s)\n", 
-		       smbcli_errstr(cli1->tree), __location__);
-		goto fail;
-	} else {
-		printf("pid1 successfully read the range 130:4\n");
-	}
+	torture_comment(tctx, "pid1 successfully locked range 130:4 for READ\n");
+
+	torture_assert(tctx, smbcli_read(cli1->tree, fnum1, buf, 130, 4) == 4, 
+		 	talloc_asprintf(tctx, "pid1 unable to read the range 130:4, error was %s)", 
+		       smbcli_errstr(cli1->tree)));
+
+	torture_comment(tctx, "pid1 successfully read the range 130:4\n");
 
 	if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
-		printf("pid1 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
-		if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT)) {
-			printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n", 
-			       __location__);
-			goto fail;
-		}
+		torture_comment(tctx, "pid1 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
+		torture_assert_ntstatus_equal(tctx, smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT,
+			"Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)");
 	} else {
-		printf("pid1 successfully wrote to the range 130:4 (should be denied) (%s)\n", 
-		       __location__);
-		goto fail;
+		torture_fail(tctx, "pid1 successfully wrote to the range 130:4 (should be denied)");
 	}
 
 	cli1->session->pid = 2;
 
 	if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
-		printf("pid2 unable to read the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
+		torture_comment(tctx, "pid2 unable to read the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
 	} else {
-		printf("pid2 successfully read the range 130:4\n");
+		torture_comment(tctx, "pid2 successfully read the range 130:4\n");
 	}
 
 	if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
-		printf("pid2 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
-		if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT)) {
-			printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
-			       __location__);
-			goto fail;
-		}
+		torture_comment(tctx, "pid2 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
+		torture_assert_ntstatus_equal(tctx, smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT, 
+			"Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)");
 	} else {
-		printf("pid2 successfully wrote to the range 130:4 (should be denied) (%s)\n", 
-		       __location__);
-		goto fail;
+		torture_fail(tctx, "pid2 successfully wrote to the range 130:4 (should be denied)"); 
 	}
 
 	cli1->session->pid = 1;
 	smbcli_unlock(cli1->tree, fnum1, 130, 4);
 
-	if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, WRITE_LOCK))) {
-		printf("Unable to apply write lock on range 130:4, error was %s (%s)\n", 
-		       smbcli_errstr(cli1->tree), __location__);
-		goto fail;
-	} else {
-		printf("pid1 successfully locked range 130:4 for WRITE\n");
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_lock(cli1->tree, fnum1, 130, 4, 0, WRITE_LOCK),
+		talloc_asprintf(tctx, "Unable to apply write lock on range 130:4, error was %s", 
+		       smbcli_errstr(cli1->tree)));
+	torture_comment(tctx, "pid1 successfully locked range 130:4 for WRITE\n");
 
-	if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
-		printf("pid1 unable to read the range 130:4, error was %s (%s)\n", 
-		       smbcli_errstr(cli1->tree), __location__);
-		goto fail;
-	} else {
-		printf("pid1 successfully read the range 130:4\n");
-	}
+	torture_assert(tctx, smbcli_read(cli1->tree, fnum1, buf, 130, 4) == 4, 
+		talloc_asprintf(tctx, "pid1 unable to read the range 130:4, error was %s", 
+		       smbcli_errstr(cli1->tree)));
+	torture_comment(tctx, "pid1 successfully read the range 130:4\n");
 
-	if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
-		printf("pid1 unable to write to the range 130:4, error was %s (%s)\n", 
-		       smbcli_errstr(cli1->tree), __location__);
-		goto fail;
-	} else {
-		printf("pid1 successfully wrote to the range 130:4\n");
-	}
+	torture_assert(tctx, smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) == 4, 
+		talloc_asprintf(tctx, "pid1 unable to write to the range 130:4, error was %s",
+		       smbcli_errstr(cli1->tree)));
+	torture_comment(tctx, "pid1 successfully wrote to the range 130:4\n");
 
 	cli1->session->pid = 2;
 
 	if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
-		printf("pid2 unable to read the range 130:4, error was %s\n", 
+		torture_comment(tctx, "pid2 unable to read the range 130:4, error was %s\n", 
 		       smbcli_errstr(cli1->tree));
-		if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT)) {
-			printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
-			       __location__);
-			goto fail;
-		}
+		torture_assert_ntstatus_equal(tctx, smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT, 
+			"Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)");
 	} else {
-		printf("pid2 successfully read the range 130:4 (should be denied) (%s)\n", 
-		       __location__);
-		goto fail;
+		torture_fail(tctx, "pid2 successfully read the range 130:4 (should be denied)");
 	}
 
 	if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
-		printf("pid2 unable to write to the range 130:4, error was %s\n", 
+		torture_comment(tctx, "pid2 unable to write to the range 130:4, error was %s\n", 
 		       smbcli_errstr(cli1->tree));
 		if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT)) {
-			printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
+			torture_comment(tctx, "Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
 			       __location__);
 			goto fail;
 		}
 	} else {
-		printf("pid2 successfully wrote to the range 130:4 (should be denied) (%s)\n", 
+		torture_comment(tctx, "pid2 successfully wrote to the range 130:4 (should be denied) (%s)\n", 
 		       __location__);
 		goto fail;
 	}
 
-	printf("Testing truncate of locked file.\n");
+	torture_comment(tctx, "Testing truncate of locked file.\n");
 
 	fnum2 = smbcli_open(cli1->tree, fname, O_RDWR|O_TRUNC, DENY_NONE);
 
-	if (fnum2 == -1) {
-		printf("Unable to truncate locked file (%s)\n", __location__);
-		correct = False;
-		goto fail;
-	} else {
-		printf("Truncated locked file.\n");
-	}
+	torture_assert(tctx, fnum2 != -1, "Unable to truncate locked file");
 
-	if (NT_STATUS_IS_ERR(smbcli_getatr(cli1->tree, fname, NULL, &size, NULL))) {
-		printf("getatr failed (%s) (%s)\n", smbcli_errstr(cli1->tree), __location__);
-		correct = False;
-		goto fail;
-	}
+	torture_comment(tctx, "Truncated locked file.\n");
 
-	if (size != 0) {
-		printf("Unable to truncate locked file. Size was %u (%s)\n", 
-		       (unsigned)size, __location__);
-		correct = False;
-		goto fail;
-	}
+	torture_assert_ntstatus_ok(tctx, smbcli_getatr(cli1->tree, fname, NULL, &size, NULL), 
+		talloc_asprintf(tctx, "getatr failed (%s)", smbcli_errstr(cli1->tree)));
+
+	torture_assert(tctx, size == 0, talloc_asprintf(tctx, "Unable to truncate locked file. Size was %u", (unsigned)size));
 
 	cli1->session->pid = 1;
 
@@ -981,9 +792,21 @@ fail:
 	smbcli_close(cli1->tree, fnum1);
 	smbcli_close(cli1->tree, fnum2);
 	smbcli_unlink(cli1->tree, fname);
-	torture_close_connection(cli1);
 
-	printf("finished locktest7\n");
 	return correct;
 }
 
+struct torture_suite *torture_base_locktest(void)
+{
+	struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), 
+													   "LOCK");
+	torture_suite_add_2smb_test(suite, "LOCK1", torture_locktest1);
+	torture_suite_add_1smb_test(suite, "LOCK2", torture_locktest2);
+	torture_suite_add_2smb_test(suite, "LOCK3", torture_locktest3);
+	torture_suite_add_2smb_test(suite, "LOCK4",  torture_locktest4);
+	torture_suite_add_2smb_test(suite, "LOCK5",  torture_locktest5);
+	torture_suite_add_1smb_test(suite, "LOCK6",  torture_locktest6);
+	torture_suite_add_1smb_test(suite, "LOCK7",  torture_locktest7);
+
+	return suite;
+}