From 8773e743c518578584d07d35ffdafdd598af88b0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 16 Oct 2006 13:06:41 +0000 Subject: 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) --- source4/torture/rpc/echo.c | 379 ++++++++++++++++++--------------------------- 1 file changed, 149 insertions(+), 230 deletions(-) (limited to 'source4/torture/rpc/echo.c') diff --git a/source4/torture/rpc/echo.c b/source4/torture/rpc/echo.c index 02f255e5f8..fef9eb8c2b 100644 --- a/source4/torture/rpc/echo.c +++ b/source4/torture/rpc/echo.c @@ -31,49 +31,40 @@ /* test the AddOne interface */ -#define TEST_ADDONE(value) do { \ +#define TEST_ADDONE(tctx, value) do { \ n = i = value; \ r.in.in_data = n; \ r.out.out_data = &n; \ - status = dcerpc_echo_AddOne(p, mem_ctx, &r); \ - if (!NT_STATUS_IS_OK(status)) { \ - printf("AddOne(%d) failed - %s\n", i, nt_errstr(status)); \ - return False; \ - } \ - if (n != i+1) { \ - printf("%d + 1 != %u (should be %u)\n", i, n, i+1); \ - ret = False; \ - } else { \ - printf("%d + 1 = %u\n", i, n); \ - } \ + status = dcerpc_echo_AddOne(p, tctx, &r); \ + torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "AddOne(%d) failed", i)); \ + torture_assert (tctx, n == i+1, talloc_asprintf(tctx, "%d + 1 != %u (should be %u)\n", i, n, i+1)); \ + torture_comment (tctx, "%d + 1 = %u\n", i, n); \ } while(0) -static BOOL test_addone(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +static bool test_addone(struct torture_context *tctx, + struct dcerpc_pipe *p) { - BOOL ret = True; uint32_t i; NTSTATUS status; uint32_t n; struct echo_AddOne r; - printf("\nTesting AddOne\n"); - for (i=0;i<10;i++) { - TEST_ADDONE(i); + TEST_ADDONE(tctx, i); } - TEST_ADDONE(0x7FFFFFFE); - TEST_ADDONE(0xFFFFFFFE); - TEST_ADDONE(0xFFFFFFFF); - TEST_ADDONE(random() & 0xFFFFFFFF); - - return ret; + TEST_ADDONE(tctx, 0x7FFFFFFE); + TEST_ADDONE(tctx, 0xFFFFFFFE); + TEST_ADDONE(tctx, 0xFFFFFFFF); + TEST_ADDONE(tctx, random() & 0xFFFFFFFF); + return true; } /* test the EchoData interface */ -static BOOL test_echodata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +static bool test_echodata(struct torture_context *tctx, + struct dcerpc_pipe *p) { int i; NTSTATUS status; @@ -81,17 +72,15 @@ static BOOL test_echodata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) int len; struct echo_EchoData r; - if (lp_parm_bool(-1, "torture", "quick", False) && + if (torture_setting_bool(tctx, "quick", false) && (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) { len = 1 + (random() % 500); } else { len = 1 + (random() % 5000); } - printf("\nTesting EchoData\n"); - - data_in = talloc_size(mem_ctx, len); - data_out = talloc_size(mem_ctx, len); + data_in = talloc_size(tctx, len); + data_out = talloc_size(tctx, len); for (i=0;iconn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) { len = 100 + (random() % 500); } else { len = 200000 + (random() % 5000); } - printf("\nTesting SourceData\n"); - r.in.len = len; - status = dcerpc_echo_SourceData(p, mem_ctx, &r); - if (!NT_STATUS_IS_OK(status)) { - printf("SourceData(%d) failed - %s\n", len, nt_errstr(status)); - return False; - } + status = dcerpc_echo_SourceData(p, tctx, &r); + torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, + "SourceData(%d) failed", len)); for (i=0;iconn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) { len = 100 + (random() % 5000); } else { len = 200000 + (random() % 5000); } - printf("\nTesting SinkData\n"); - - data_in = talloc_size(mem_ctx, len); + data_in = talloc_size(tctx, len); for (i=0;istate == RPC_REQUEST_DONE) { total_done++; @@ -302,46 +263,39 @@ static BOOL test_sleep(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) rcv[i] = timeval_current(); diff[i] = timeval_until(&snd[i], &rcv[i]); status = dcerpc_ndr_request_recv(req[i]); - if (!NT_STATUS_IS_OK(status)) { - printf("TestSleep(%d) failed - %s\n", - i, nt_errstr(status)); - ret = False; - } else if (r[i].out.result != r[i].in.seconds) { - printf("Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)\n", - r[i].out.result, r[i].in.seconds, (uint_t)diff[i].tv_sec); - ret = False; + torture_assert_ntstatus_ok(tctx, status, + talloc_asprintf(tctx, "TestSleep(%d) failed", i)); + torture_assert(tctx, r[i].out.result == r[i].in.seconds, + talloc_asprintf(tctx, "Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)", + r[i].out.result, r[i].in.seconds, (uint_t)diff[i].tv_sec)); + torture_assert(tctx, r[i].out.result <= diff[i].tv_sec, + talloc_asprintf(tctx, "Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)", + r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec)); + if (r[i].out.result+1 == diff[i].tv_sec) { + torture_comment(tctx, "Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n", + r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec); + } else if (r[i].out.result == diff[i].tv_sec) { + torture_comment(tctx, "Slept for %u seconds (reply takes %u.%06u seconds - ok)\n", + r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec); } else { - if (r[i].out.result > diff[i].tv_sec) { - printf("Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)\n", - r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec); - } else if (r[i].out.result+1 == diff[i].tv_sec) { - printf("Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n", - r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec); - } else if (r[i].out.result == diff[i].tv_sec) { - printf("Slept for %u seconds (reply takes %u.%06u seconds - ok)\n", - r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec); - } else { - printf("(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)\n", - r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec); - /* TODO: let the test fail here, when we support async rpc on ncacn_np - ret = False;*/ - } + torture_comment(tctx, "(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)", + r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec); + /* TODO: let the test fail here, when we support async rpc on ncacn_np */ } } } } - - return ret; + return true; } /* test enum handling */ -static BOOL test_enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +static bool test_enum(struct torture_context *tctx, + struct dcerpc_pipe *p) { NTSTATUS status; struct echo_TestEnum r; - BOOL ret = True; enum echo_Enum1 v = ECHO_ENUM1; struct echo_Enum2 e2; union echo_Enum3 e3; @@ -357,56 +311,45 @@ static BOOL test_enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) e2.e2 = ECHO_ENUM1_32; e3.e1 = ECHO_ENUM2; - printf("\nTesting TestEnum\n"); - status = dcerpc_echo_TestEnum(p, mem_ctx, &r); - if (!NT_STATUS_IS_OK(status)) { - printf("TestEnum failed - %s\n", nt_errstr(status)); - ret = False; - } - - return ret; + status = dcerpc_echo_TestEnum(p, tctx, &r); + torture_assert_ntstatus_ok(tctx, status, "TestEnum failed"); + return true; } /* test surrounding conformant array handling */ -static BOOL test_surrounding(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +static bool test_surrounding(struct torture_context *tctx, + struct dcerpc_pipe *p) { NTSTATUS status; struct echo_TestSurrounding r; - BOOL ret = True; ZERO_STRUCT(r); - r.in.data = talloc(mem_ctx, struct echo_Surrounding); + r.in.data = talloc(tctx, struct echo_Surrounding); r.in.data->x = 20; - r.in.data->surrounding = talloc_zero_array(mem_ctx, uint16_t, r.in.data->x); + r.in.data->surrounding = talloc_zero_array(tctx, uint16_t, r.in.data->x); - r.out.data = talloc(mem_ctx, struct echo_Surrounding); + r.out.data = talloc(tctx, struct echo_Surrounding); - printf("\nTesting TestSurrounding\n"); - status = dcerpc_echo_TestSurrounding(p, mem_ctx, &r); - if (!NT_STATUS_IS_OK(status)) { - printf("TestSurrounding failed - %s\n", nt_errstr(status)); - return False; - } + status = dcerpc_echo_TestSurrounding(p, tctx, &r); + torture_assert_ntstatus_ok(tctx, status, "TestSurrounding failed"); - if (r.out.data->x != 2 * r.in.data->x) { - printf("TestSurrounding did not make the array twice as large\n"); - ret = False; - } + torture_assert(tctx, r.out.data->x == 2 * r.in.data->x, + "TestSurrounding did not make the array twice as large"); - return ret; + return true; } /* test multiple levels of pointers */ -static BOOL test_doublepointer(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +static bool test_doublepointer(struct torture_context *tctx, + struct dcerpc_pipe *p) { NTSTATUS status; struct echo_TestDoublePointer r; - BOOL ret = True; uint16_t value = 12; uint16_t *pvalue = &value; uint16_t **ppvalue = &pvalue; @@ -414,112 +357,88 @@ static BOOL test_doublepointer(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) ZERO_STRUCT(r); r.in.data = &ppvalue; - printf("\nTesting TestDoublePointer\n"); - status = dcerpc_echo_TestDoublePointer(p, mem_ctx, &r); - if (!NT_STATUS_IS_OK(status)) { - printf("TestDoublePointer failed - %s\n", nt_errstr(status)); - ret = False; - } + status = dcerpc_echo_TestDoublePointer(p, tctx, &r); + torture_assert_ntstatus_ok(tctx, status, "TestDoublePointer failed"); - if (value != r.out.result) { - printf("TestDoublePointer did not return original value (%d != %d)\n", value, r.out.result); - ret = False; - } - - return ret; + torture_assert_int_equal(tctx, value, r.out.result, + "TestDoublePointer did not return original value"); + return true; } /* test request timeouts */ -static BOOL test_timeout(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +static bool test_timeout(struct torture_context *tctx, + struct dcerpc_pipe *p) { NTSTATUS status; struct rpc_request *req; struct echo_TestSleep r; int timeout_saved = p->request_timeout; - if (lp_parm_bool(-1, "torture", "quick", False)) { - printf("timeout testing disabled - use \"torture:quick=no\" to enable\n"); - return True; + if (torture_setting_bool(tctx, "quick", false)) { + torture_skip(tctx, "timeout testing disabled - use \"torture:quick=no\" to enable\n"); } - printf("testing request timeouts\n"); + torture_comment(tctx, "testing request timeouts\n"); r.in.seconds = 2; p->request_timeout = 1; - req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r); - if (!req) { - printf("Failed to send async sleep request\n"); - goto failed; - } + torture_assert(tctx, req = dcerpc_echo_TestSleep_send(p, tctx, &r), + "Failed to send async sleep request"); status = dcerpc_ndr_request_recv(req); - if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) { - printf("request should have timed out - %s\n", nt_errstr(status)); - goto failed; - } + torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT, + "request should have timed out"); - printf("testing request destruction\n"); - req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r); + torture_comment(tctx, "testing request destruction\n"); + req = dcerpc_echo_TestSleep_send(p, tctx, &r); if (!req) { - printf("Failed to send async sleep request\n"); + torture_comment(tctx, "Failed to send async sleep request\n"); goto failed; } talloc_free(req); - req = dcerpc_echo_TestSleep_send(p, mem_ctx, &r); + req = dcerpc_echo_TestSleep_send(p, tctx, &r); if (!req) { - printf("Failed to send async sleep request\n"); + torture_comment(tctx, "Failed to send async sleep request\n"); goto failed; } status = dcerpc_ndr_request_recv(req); - if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) { - printf("request should have timed out - %s\n", nt_errstr(status)); - goto failed; - } + torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT, + "request should have timed out"); p->request_timeout = timeout_saved; - return test_addone(p, mem_ctx); + + return test_addone(tctx, p); failed: p->request_timeout = timeout_saved; - return False; + return false; } -BOOL torture_rpc_echo(struct torture_context *torture) +struct torture_suite *torture_rpc_echo(void) { - NTSTATUS status; - struct dcerpc_pipe *p; - TALLOC_CTX *mem_ctx; - BOOL ret = True; - - mem_ctx = talloc_init("torture_rpc_echo"); - - status = torture_rpc_connection(mem_ctx, - &p, - &dcerpc_table_rpcecho); - if (!NT_STATUS_IS_OK(status)) { - return False; - } - - ret &= test_addone(p, mem_ctx); - ret &= test_sinkdata(p, mem_ctx); - ret &= test_echodata(p, mem_ctx); - ret &= test_sourcedata(p, mem_ctx); - ret &= test_testcall(p, mem_ctx); - ret &= test_testcall2(p, mem_ctx); - ret &= test_enum(p, mem_ctx); - ret &= test_surrounding(p, mem_ctx); - ret &= test_doublepointer(p, mem_ctx); - ret &= test_sleep(p, mem_ctx); - ret &= test_timeout(p, mem_ctx); - - printf("\n"); - - talloc_free(mem_ctx); - - return ret; + struct torture_suite *suite = torture_suite_create( + talloc_autofree_context(), "ECHO"); + struct torture_tcase *tcase; + + tcase = torture_suite_add_rpc_iface_tcase(suite, "echo", + &dcerpc_table_rpcecho); + + torture_rpc_tcase_add_test(tcase, "addone", test_addone); + torture_rpc_tcase_add_test(tcase, "sinkdata", test_sinkdata); + torture_rpc_tcase_add_test(tcase, "echodata", test_echodata); + torture_rpc_tcase_add_test(tcase, "sourcedata", test_sourcedata); + torture_rpc_tcase_add_test(tcase, "testcall", test_testcall); + torture_rpc_tcase_add_test(tcase, "testcall2", test_testcall2); + torture_rpc_tcase_add_test(tcase, "enum", test_enum); + torture_rpc_tcase_add_test(tcase, "surrounding", test_surrounding); + torture_rpc_tcase_add_test(tcase, "doublepointer", test_doublepointer); + torture_rpc_tcase_add_test(tcase, "sleep", test_sleep); + torture_rpc_tcase_add_test(tcase, "timeout", test_timeout); + + return suite; } -- cgit