s4-smbtorture: Make test names lowercase and dot-separated.

[kai/samba-autobuild/.git] / source4 / torture / rpc / initshutdown.c

diff --git a/source4/torture/rpc/initshutdown.c b/source4/torture/rpc/initshutdown.c
index 56bf74de5183f287ec7e9df9b27ae6f60e7abeb1..28eaacd5e5fd828d098bb44bafdebaaea72a8b92 100644 (file)
--- a/source4/torture/rpc/initshutdown.c
+++ b/source4/torture/rpc/initshutdown.c
@@ -20,124 +20,97 @@
 */
 
 #include "includes.h"
-#include "torture/torture.h"
 #include "librpc/gen_ndr/ndr_initshutdown_c.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
 
-static void init_initshutdown_String(TALLOC_CTX *mem_ctx, struct initshutdown_String *name, const char *s)
+static void init_lsa_StringLarge(struct lsa_StringLarge *name, const char *s)
 {
-       name->name = talloc(mem_ctx, struct initshutdown_String_sub);
-       name->name->name = s;
+       name->string = s;
 }
 
-static BOOL test_Init(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                       const char *msg, uint32_t timeout)
+
+static bool test_Abort(struct torture_context *tctx, 
+                                          struct dcerpc_pipe *p)
 {
-       struct initshutdown_Init r;
+       struct initshutdown_Abort r;
        NTSTATUS status;
-       uint16_t hostname = 0x0;
-       
-       r.in.hostname = &hostname;
-       r.in.message = talloc(mem_ctx, struct initshutdown_String);
-       init_initshutdown_String(mem_ctx, r.in.message, msg);
-       r.in.force_apps = 1;
-       r.in.timeout = timeout;
-       r.in.reboot = 1;
+       uint16_t server = 0x0;
+       struct dcerpc_binding_handle *b = p->binding_handle;
 
-       status = dcerpc_initshutdown_Init(p, mem_ctx, &r);
+       r.in.server = &server;
+       
+       status = dcerpc_initshutdown_Abort_r(b, tctx, &r);
 
-       if (!NT_STATUS_IS_OK(status)) {
-               printf("initshutdown_Init failed - %s\n", nt_errstr(status));
-               return False;
-       }
+       torture_assert_ntstatus_ok(tctx, status, 
+                                                          "initshutdown_Abort failed");
 
-       if (!W_ERROR_IS_OK(r.out.result)) {
-               printf("initshutdown_Init failed - %s\n", win_errstr(r.out.result));
-               return False;
-       }
+       torture_assert_werr_ok(tctx, r.out.result, "initshutdown_Abort failed");
 
-       return True;
+       return true;
 }
 
-static BOOL test_InitEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
-                       const char *msg, uint32_t timeout)
+static bool test_Init(struct torture_context *tctx, 
+                     struct dcerpc_pipe *p)
 {
-       struct initshutdown_InitEx r;
+       struct initshutdown_Init r;
        NTSTATUS status;
        uint16_t hostname = 0x0;
-       
+       struct dcerpc_binding_handle *b = p->binding_handle;
+
        r.in.hostname = &hostname;
-       r.in.message = talloc(mem_ctx, struct initshutdown_String);
-       init_initshutdown_String(mem_ctx, r.in.message, msg);
+       r.in.message = talloc(tctx, struct lsa_StringLarge);
+       init_lsa_StringLarge(r.in.message, "spottyfood");
        r.in.force_apps = 1;
-       r.in.timeout = timeout;
-       r.in.reboot = 1;
-       r.in.reason = 0;
+       r.in.timeout = 30;
+       r.in.do_reboot = 1;
 
-       status = dcerpc_initshutdown_InitEx(p, mem_ctx, &r);
+       status = dcerpc_initshutdown_Init_r(b, tctx, &r);
 
-       if (!NT_STATUS_IS_OK(status)) {
-               printf("initshutdown_InitEx failed - %s\n", nt_errstr(status));
-               return False;
-       }
+       torture_assert_ntstatus_ok(tctx, status, "initshutdown_Init failed");
+       torture_assert_werr_ok(tctx, r.out.result, "initshutdown_Init failed");
 
-       if (!W_ERROR_IS_OK(r.out.result)) {
-               printf("initshutdown_InitEx failed - %s\n", win_errstr(r.out.result));
-               return False;
-       }
-
-       return True;
+       return test_Abort(tctx, p);
 }
 
-static BOOL test_Abort(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_InitEx(struct torture_context *tctx, 
+                                               struct dcerpc_pipe *p)
 {
-       struct initshutdown_Abort r;
+       struct initshutdown_InitEx r;
        NTSTATUS status;
-       uint16_t server = 0x0;
-
-       r.in.server = &server;
-       
-       status = dcerpc_initshutdown_Abort(p, mem_ctx, &r);
+       uint16_t hostname = 0x0;
+       struct dcerpc_binding_handle *b = p->binding_handle;
 
-       if (!NT_STATUS_IS_OK(status)) {
-               printf("initshutdown_Abort failed - %s\n", nt_errstr(status));
-               return False;
-       }
+       r.in.hostname = &hostname;
+       r.in.message = talloc(tctx, struct lsa_StringLarge);
+       init_lsa_StringLarge(r.in.message, "spottyfood");
+       r.in.force_apps = 1;
+       r.in.timeout = 30;
+       r.in.do_reboot = 1;
+       r.in.reason = 0;
 
-       if (!W_ERROR_IS_OK(r.out.result)) {
-               printf("initshutdown_Abort failed - %s\n", win_errstr(r.out.result));
-               return False;
-       }
+       status = dcerpc_initshutdown_InitEx_r(b, tctx, &r);
 
-       return True;
-}
+       torture_assert_ntstatus_ok(tctx, status, "initshutdown_InitEx failed");
 
-BOOL torture_rpc_initshutdown(struct torture_context *torture)
-{
-    NTSTATUS status;
-    struct dcerpc_pipe *p;
-       TALLOC_CTX *mem_ctx;
-       BOOL ret = True;
+       torture_assert_werr_ok(tctx, r.out.result, "initshutdown_InitEx failed");
 
-       mem_ctx = talloc_init("torture_rpc_initshutdown");
+       return test_Abort(tctx, p);
+}
 
-       status = torture_rpc_connection(mem_ctx, &p, &dcerpc_table_initshutdown);
 
-       if (!NT_STATUS_IS_OK(status)) {
-               talloc_free(mem_ctx);
-               return False;
-       }
+struct torture_suite *torture_rpc_initshutdown(TALLOC_CTX *mem_ctx)
+{
+       struct torture_suite *suite = torture_suite_create(mem_ctx, "initshutdown");
+       struct torture_rpc_tcase *tcase;
+       struct torture_test *test;
 
-       if (!torture_setting_bool(torture, "dangerous", False)) {
-               printf("initshutdown tests disabled - enable dangerous tests to use\n");
-       } else {
-               ret &= test_Init(p, mem_ctx, "spottyfood", 30);
-               ret &= test_Abort(p, mem_ctx);
-               ret &= test_InitEx(p, mem_ctx, "spottyfood", 30);
-               ret &= test_Abort(p, mem_ctx);
-       }
+       tcase = torture_suite_add_rpc_iface_tcase(suite, "initshutdown", 
+                                                 &ndr_table_initshutdown);
 
-       talloc_free(mem_ctx);
+       test = torture_rpc_tcase_add_test(tcase, "Init", test_Init);
+       test->dangerous = true;
+       test = torture_rpc_tcase_add_test(tcase, "InitEx", test_InitEx);
+       test->dangerous = true;
 
-       return ret;
+       return suite;
 }