test suite for echo rpc operations
Copyright (C) Andrew Tridgell 2003
+ Copyright (C) Stefan (metze) Metzmacher 2005
+ Copyright (C) Jelmer Vernooij 2005
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
+#include "torture/rpc/torture_rpc.h"
+#include "lib/events/events.h"
+#include "librpc/gen_ndr/ndr_echo_c.h"
/*
test the AddOne interface
*/
-static BOOL test_addone(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+#define TEST_ADDONE(tctx, value) do { \
+ n = i = value; \
+ r.in.in_data = n; \
+ r.out.out_data = &n; \
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_AddOne_r(b, tctx, &r), \
+ 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 torture_context *tctx,
+ struct dcerpc_pipe *p)
{
- int i;
- NTSTATUS status;
-
- printf("\nTesting AddOne\n");
+ uint32_t i;
+ uint32_t n;
+ struct echo_AddOne r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
for (i=0;i<10;i++) {
- int n;
- status = dcerpc_rpcecho_addone(p, i, &n);
- if (!NT_STATUS_IS_OK(status)) {
- printf("AddOne(%d) failed - %s\n", i, nt_errstr(status));
- return False;
- }
- printf("%d + 1 = %d\n", i, n);
+ TEST_ADDONE(tctx, i);
}
- return True;
+ 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;
- char *data_in, *data_out;
- int len = 1 + (random() % 5000);
- int len_out;
+ uint8_t *data_in, *data_out;
+ int len;
+ struct echo_EchoData r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+
+ if (torture_setting_bool(tctx, "quick", false) &&
+ (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
+ len = 1 + (random() % 500);
+ } else {
+ len = 1 + (random() % 5000);
+ }
+
+ data_in = talloc_array(tctx, uint8_t, len);
+ data_out = talloc_array(tctx, uint8_t, len);
+ for (i=0;i<len;i++) {
+ data_in[i] = i;
+ }
+
+ r.in.len = len;
+ r.in.in_data = data_in;
+
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_EchoData_r(b, tctx, &r),
+ talloc_asprintf(tctx, "EchoData(%d) failed\n", len));
- printf("\nTesting EchoData\n");
+ data_out = r.out.out_data;
- data_in = talloc(mem_ctx, len);
for (i=0;i<len;i++) {
- data_in[i] = i+1;
+ if (data_in[i] != data_out[i]) {
+ torture_comment(tctx, "Bad data returned for len %d at offset %d\n",
+ len, i);
+ torture_comment(tctx, "in:\n");
+ dump_data(0, data_in+i, MIN(len-i, 16));
+ torture_comment(tctx, "out:\n");
+ dump_data(0, data_out+i, MIN(len-1, 16));
+ return false;
+ }
}
+ return true;
+}
+
+/*
+ test the SourceData interface
+*/
+static bool test_sourcedata(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ int i;
+ int len;
+ struct echo_SourceData r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+
+ if (torture_setting_bool(tctx, "quick", false) &&
+ (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
+ len = 100 + (random() % 500);
+ } else {
+ len = 200000 + (random() % 5000);
+ }
+
+ r.in.len = len;
+
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_SourceData_r(b, tctx, &r),
+ talloc_asprintf(tctx, "SourceData(%d) failed", len));
+
+ for (i=0;i<len;i++) {
+ uint8_t *v = (uint8_t *)r.out.data;
+ torture_assert(tctx, v[i] == (i & 0xFF),
+ talloc_asprintf(tctx,
+ "bad data 0x%x at %d\n", (uint8_t)r.out.data[i], i));
+ }
+ return true;
+}
- status = dcerpc_rpcecho_echodata(p, mem_ctx,
- len,
- data_in,
- &len_out,
- &data_out);
- if (!NT_STATUS_IS_OK(status)) {
- printf("EchoData(%d) failed - %s\n", len, nt_errstr(status));
- return False;
+/*
+ test the SinkData interface
+*/
+static bool test_sinkdata(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ int i;
+ uint8_t *data_in;
+ int len;
+ struct echo_SinkData r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+
+ if (torture_setting_bool(tctx, "quick", false) &&
+ (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {
+ len = 100 + (random() % 5000);
+ } else {
+ len = 200000 + (random() % 5000);
}
- printf("EchoData(%d) returned %d bytes\n", len, len_out);
- if (memcmp(data_in, data_out, len) != 0) {
- printf("Bad data returned!\n");
- return False;
+ data_in = talloc_array(tctx, uint8_t, len);
+ for (i=0;i<len;i++) {
+ data_in[i] = i+1;
}
+ r.in.len = len;
+ r.in.data = data_in;
- return True;
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_SinkData_r(b, tctx, &r),
+ talloc_asprintf(tctx, "SinkData(%d) failed", len));
+
+ torture_comment(tctx, "sunk %d bytes\n", len);
+ return true;
}
/*
- test the SourceData interface
+ test the testcall interface
*/
-static BOOL test_sourcedata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_testcall(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
+ struct echo_TestCall r;
+ const char *s = NULL;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+
+ r.in.s1 = "input string";
+ r.out.s2 = &s;
+
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestCall_r(b, tctx, &r),
+ "TestCall failed");
+
+ torture_assert_str_equal(tctx, s, "input string", "Didn't receive back same string");
+
+ return true;
+}
+
+/*
+ test the testcall interface
+*/
+static bool test_testcall2(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ struct echo_TestCall2 r;
int i;
- NTSTATUS status;
- char *data_out;
- int len = 200000 + (random() % 5000);
- int len_out;
+ struct dcerpc_binding_handle *b = p->binding_handle;
- printf("\nTesting SourceData\n");
+ for (i=1;i<=7;i++) {
+ r.in.level = i;
+ r.out.info = talloc(tctx, union echo_Info);
- status = dcerpc_rpcecho_sourcedata(p, mem_ctx,
- len,
- &len_out,
- &data_out);
- if (!NT_STATUS_IS_OK(status)) {
- printf("SourceData(%d) failed - %s\n", len, nt_errstr(status));
- return False;
+ torture_comment(tctx, "Testing TestCall2 level %d\n", i);
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestCall2_r(b, tctx, &r),
+ "TestCall2 failed");
+ torture_assert_ntstatus_ok(tctx, r.out.result, "TestCall2 failed");
}
- printf("SourceData(%d) returned %d bytes\n", len, len_out);
+ return true;
+}
- for (i=0;i<len;i++) {
- unsigned char *v = (unsigned char *)data_out;
- if (v[i] != (i & 0xFF)) {
- printf("bad data 0x%x at %d\n", data_out[i], i);
- return False;
+static void test_sleep_done(struct tevent_req *subreq)
+{
+ bool *done1 = (bool *)tevent_req_callback_data_void(subreq);
+ *done1 = true;
+}
+
+/*
+ test the TestSleep interface
+*/
+static bool test_sleep(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ int i;
+#define ASYNC_COUNT 3
+ struct tevent_req *req[ASYNC_COUNT];
+ struct echo_TestSleep r[ASYNC_COUNT];
+ bool done1[ASYNC_COUNT];
+ bool done2[ASYNC_COUNT];
+ struct timeval snd[ASYNC_COUNT];
+ struct timeval rcv[ASYNC_COUNT];
+ struct timeval diff[ASYNC_COUNT];
+ int total_done = 0;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+ enum dcerpc_transport_t transport;
+ uint32_t assoc_group_id;
+ struct dcerpc_pipe *p2 = NULL;
+ NTSTATUS status;
+
+ if (torture_setting_bool(tctx, "quick", false)) {
+ torture_skip(tctx, "TestSleep disabled - use \"torture:quick=no\" to enable\n");
+ }
+ torture_comment(tctx, "Testing TestSleep - use \"torture:quick=yes\" to disable\n");
+
+ transport = dcerpc_binding_get_transport(p->binding);
+ assoc_group_id = dcerpc_binding_get_assoc_group_id(p->binding);
+
+ torture_comment(tctx, "connect echo connection 2 with "
+ "DCERPC_CONCURRENT_MULTIPLEX\n");
+ status = torture_rpc_connection_transport(tctx, &p2,
+ &ndr_table_rpcecho,
+ transport,
+ assoc_group_id,
+ DCERPC_CONCURRENT_MULTIPLEX);
+ torture_assert_ntstatus_ok(tctx, status, "opening echo connection 2");
+ b = p2->binding_handle;
+
+ for (i=0;i<ASYNC_COUNT;i++) {
+ done1[i] = false;
+ done2[i] = false;
+ snd[i] = timeval_current();
+ rcv[i] = timeval_zero();
+ r[i].in.seconds = ASYNC_COUNT-i;
+ req[i] = dcerpc_echo_TestSleep_r_send(tctx, tctx->ev, b, &r[i]);
+ torture_assert(tctx, req[i], "Failed to send async sleep request\n");
+ tevent_req_set_callback(req[i], test_sleep_done, &done1[i]);
+ }
+
+ while (total_done < ASYNC_COUNT) {
+ torture_assert(tctx, tevent_loop_once(tctx->ev) == 0,
+ "Event context loop failed");
+ for (i=0;i<ASYNC_COUNT;i++) {
+ if (done2[i] == false && done1[i] == true) {
+ int rounded_tdiff;
+ total_done++;
+ done2[i] = true;
+ rcv[i] = timeval_current();
+ diff[i] = timeval_until(&snd[i], &rcv[i]);
+ rounded_tdiff = (int)(0.5 + diff[i].tv_sec + (1.0e-6*diff[i].tv_usec));
+ torture_comment(tctx, "rounded_tdiff=%d\n", rounded_tdiff);
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_echo_TestSleep_r_recv(req[i], tctx),
+ 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, (unsigned int)diff[i].tv_sec));
+ torture_assert(tctx, r[i].out.result <= rounded_tdiff,
+ talloc_asprintf(tctx, "Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)",
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec));
+ if (r[i].out.result+1 == rounded_tdiff) {
+ torture_comment(tctx, "Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n",
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
+ } else if (r[i].out.result == rounded_tdiff) {
+ torture_comment(tctx, "Slept for %u seconds (reply takes %u.%06u seconds - ok)\n",
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
+ } else {
+ torture_fail(tctx, talloc_asprintf(tctx,
+ "(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)\n",
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec));
+ }
+ }
}
}
+ torture_comment(tctx, "\n");
+ return true;
+}
- return True;
+/*
+ test enum handling
+*/
+static bool test_enum(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ struct echo_TestEnum r;
+ enum echo_Enum1 v = ECHO_ENUM1;
+ struct echo_Enum2 e2;
+ union echo_Enum3 e3;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+
+ r.in.foo1 = &v;
+ r.in.foo2 = &e2;
+ r.in.foo3 = &e3;
+ r.out.foo1 = &v;
+ r.out.foo2 = &e2;
+ r.out.foo3 = &e3;
+
+ e2.e1 = 76;
+ e2.e2 = ECHO_ENUM1_32;
+ e3.e1 = ECHO_ENUM2;
+
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestEnum_r(b, tctx, &r),
+ "TestEnum failed");
+ return true;
}
/*
- test the SinkData interface
+ test surrounding conformant array handling
*/
-static BOOL test_sinkdata(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_surrounding(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
- int i;
+ struct echo_TestSurrounding r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+
+ ZERO_STRUCT(r);
+ r.in.data = talloc(tctx, struct echo_Surrounding);
+
+ r.in.data->x = 20;
+ r.in.data->surrounding = talloc_zero_array(tctx, uint16_t, r.in.data->x);
+
+ r.out.data = talloc(tctx, struct echo_Surrounding);
+
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestSurrounding_r(b, tctx, &r),
+ "TestSurrounding failed");
+
+ torture_assert(tctx, r.out.data->x == 2 * r.in.data->x,
+ "TestSurrounding did not make the array twice as large");
+
+ return true;
+}
+
+/*
+ test multiple levels of pointers
+*/
+static bool test_doublepointer(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ struct echo_TestDoublePointer r;
+ uint16_t value = 12;
+ uint16_t *pvalue = &value;
+ uint16_t **ppvalue = &pvalue;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+
+ ZERO_STRUCT(r);
+ r.in.data = &ppvalue;
+
+ torture_assert_ntstatus_ok(tctx, dcerpc_echo_TestDoublePointer_r(b, tctx, &r),
+ "TestDoublePointer failed");
+
+ torture_assert_int_equal(tctx, value, r.out.result,
+ "TestDoublePointer did not return original value");
+ return true;
+}
+
+static bool test_bytepipein(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ struct dcerpc_binding_handle *b = p->binding_handle;
+ struct echo_TestBytePipeIn r;
+ struct echo_BytePipe_chunk chunk;
+ struct echo_BytePipe *in_pipe;
+ struct tevent_req *subreq1;
+ struct tevent_req *subreq2;
+ size_t i;
+ uint8_t bytes[0x8000];
NTSTATUS status;
- char *data_in;
- int len = 200000 + (random() % 5000);
- printf("\nTesting SinkData\n");
+ in_pipe = dcerpc_echo_BytePipe_create(tctx);
- data_in = talloc(mem_ctx, len);
- for (i=0;i<len;i++) {
- data_in[i] = i+1;
- }
+ ZERO_STRUCT(r);
+ r.in.num_chunks = 1;
+ r.in.chunk_size = sizeof(bytes);
+ r.in.in_pipe = in_pipe;
+
+ ZERO_STRUCT(chunk);
+
+ subreq1 = dcerpc_echo_TestBytePipeIn_r_send(tctx, tctx->ev, b, &r);
+ for (i=0; i <= r.in.num_chunks; i++) {
+ struct timeval tv = timeval_current_ofs(0, 100);
- status = dcerpc_rpcecho_sinkdata(p, mem_ctx,
- len,
- data_in);
- if (!NT_STATUS_IS_OK(status)) {
- printf("SinkData(%d) failed - %s\n", len, nt_errstr(status));
- return False;
+ memset(bytes, i, sizeof(bytes));
+ chunk.count = r.in.chunk_size;
+ chunk.array = bytes;
+
+ if (i == r.in.num_chunks) {
+ chunk.count = 0;
+ }
+
+ subreq2 = tevent_wakeup_send(tctx, tctx->ev, tv);
+ tevent_req_poll(subreq2, tctx->ev);
+ tevent_wakeup_recv(subreq2);
+ TALLOC_FREE(subreq2);
+
+ torture_comment(tctx, "chunk[%u] count[%u]\n", (unsigned)i, (unsigned)chunk.count);
+ subreq2 = dcerpc_echo_BytePipe_chunk_push_send(tctx, tctx->ev, in_pipe, &chunk);
+ tevent_req_poll(subreq2, tctx->ev);
+ status = dcerpc_echo_BytePipe_chunk_push_recv(subreq2);
+ TALLOC_FREE(subreq2);
+ torture_assert_ntstatus_ok(tctx, status, __location__);
}
- printf("sunk %d bytes\n", len);
+ tevent_req_poll(subreq1, tctx->ev);
+ status = dcerpc_echo_TestBytePipeIn_r_recv(subreq1, tctx);
+ TALLOC_FREE(subreq1);
+ torture_assert_ntstatus_ok(tctx, status, __location__);
- return True;
+ return true;
}
-BOOL torture_rpc_echo(int dummy)
+static bool test_bytepipeout(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- mem_ctx = talloc_init("torture_rpc_echo");
+ struct dcerpc_binding_handle *b = p->binding_handle;
+ struct echo_TestBytePipeOut r;
+ struct echo_BytePipe_chunk *chunk;
+ struct echo_BytePipe *out_pipe;
+ struct tevent_req *subreq1;
+ struct tevent_req *subreq2;
+ size_t i;
+ NTSTATUS status;
- status = torture_rpc_connection(&p, "rpcecho");
- if (!NT_STATUS_IS_OK(status)) {
- return False;
+ out_pipe = dcerpc_echo_BytePipe_create(tctx);
+
+ ZERO_STRUCT(r);
+ r.in.num_chunks = 100;
+ r.in.chunk_size = 0x80000;
+ r.out.out_pipe = out_pipe;
+
+ ZERO_STRUCT(chunk);
+
+ dcerpc_binding_handle_set_timeout(b, UINT32_MAX);
+ subreq1 = dcerpc_echo_TestBytePipeOut_r_send(tctx, tctx->ev, b, &r);
+ for (i=0; ; i++) {
+ //struct timeval tv = timeval_current_ofs(0, 100);
+
+ //subreq2 = tevent_wakeup_send(tctx, tctx->ev, tv);
+ //tevent_req_poll(subreq2, tctx->ev);
+ //tevent_wakeup_recv(subreq2);
+ //TALLOC_FREE(subreq2);
+
+ subreq2 = dcerpc_echo_BytePipe_chunk_pull_send(tctx, tctx->ev, out_pipe);
+ tevent_req_poll(subreq2, tctx->ev);
+ status = dcerpc_echo_BytePipe_chunk_pull_recv(subreq2, tctx, &chunk);
+ TALLOC_FREE(subreq2);
+ torture_assert_ntstatus_ok(tctx, status, __location__);
+ torture_comment(tctx, "chunk[%u] count[%u]\n", (unsigned)i, (unsigned)chunk->count);
+ if (chunk->count == 0) {
+ TALLOC_FREE(chunk);
+ break;
+ }
+ TALLOC_FREE(chunk);
}
- if (!test_addone(p, mem_ctx)) {
- ret = False;
+ tevent_req_poll(subreq1, tctx->ev);
+ status = dcerpc_echo_TestBytePipeOut_r_recv(subreq1, tctx);
+ TALLOC_FREE(subreq1);
+ torture_assert_ntstatus_ok(tctx, status, __location__);
+
+ return true;
+}
+/*
+ test request timeouts
+*/
+#if 0 /* this test needs fixing to work over ncacn_np */
+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 (torture_setting_bool(tctx, "quick", false)) {
+ torture_skip(tctx, "timeout testing disabled - use \"torture:quick=no\" to enable\n");
}
- if (!test_echodata(p, mem_ctx)) {
- ret = False;
+ torture_comment(tctx, "testing request timeouts\n");
+ r.in.seconds = 2;
+ p->request_timeout = 1;
+
+ req = dcerpc_echo_TestSleep_send(p, tctx, &r);
+ if (!req) {
+ torture_comment(tctx, "Failed to send async sleep request\n");
+ goto failed;
}
+ req->ignore_timeout = true;
+
+ status = dcerpc_echo_TestSleep_recv(req);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT,
+ "request should have timed out");
- if (!test_sourcedata(p, mem_ctx)) {
- ret = False;
+ torture_comment(tctx, "testing request destruction\n");
+ req = dcerpc_echo_TestSleep_send(p, tctx, &r);
+ if (!req) {
+ torture_comment(tctx, "Failed to send async sleep request\n");
+ goto failed;
}
+ talloc_free(req);
- if (!test_sinkdata(p, mem_ctx)) {
- ret = False;
+ req = dcerpc_echo_TestSleep_send(p, tctx, &r);
+ if (!req) {
+ torture_comment(tctx, "Failed to send async sleep request\n");
+ goto failed;
}
+ req->ignore_timeout = true;
+ status = dcerpc_echo_TestSleep_recv(req);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_IO_TIMEOUT,
+ "request should have timed out");
- printf("\n");
+ p->request_timeout = timeout_saved;
- torture_rpc_close(p);
- return ret;
+ return test_addone(tctx, p);
+
+failed:
+ p->request_timeout = timeout_saved;
+ return false;
+}
+#endif
+
+struct torture_suite *torture_rpc_echo(TALLOC_CTX *mem_ctx)
+{
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "echo");
+ struct torture_rpc_tcase *tcase;
+
+ tcase = torture_suite_add_rpc_iface_tcase(suite, "echo",
+ &ndr_table_rpcecho);
+
+ if (0) torture_rpc_tcase_add_test(tcase, "addone", test_addone);
+ if (0) torture_rpc_tcase_add_test(tcase, "sinkdata", test_sinkdata);
+ if (0) torture_rpc_tcase_add_test(tcase, "echodata", test_echodata);
+ if (0) torture_rpc_tcase_add_test(tcase, "sourcedata", test_sourcedata);
+ if (0) torture_rpc_tcase_add_test(tcase, "testcall", test_testcall);
+ if (0) torture_rpc_tcase_add_test(tcase, "testcall2", test_testcall2);
+ if (0) torture_rpc_tcase_add_test(tcase, "enum", test_enum);
+ if (0) torture_rpc_tcase_add_test(tcase, "surrounding", test_surrounding);
+ if (0) torture_rpc_tcase_add_test(tcase, "doublepointer", test_doublepointer);
+ if (0) torture_rpc_tcase_add_test(tcase, "sleep", test_sleep);
+ torture_rpc_tcase_add_test(tcase, "bytepipein", test_bytepipein);
+ torture_rpc_tcase_add_test(tcase, "bytepipeout", test_bytepipeout);
+#if 0 /* this test needs fixing to work over ncacn_np */
+ torture_rpc_tcase_add_test(tcase, "timeout", test_timeout);
+#endif
+
+ return suite;
}
git.samba.org / metze / samba / wip.git / blobdiff