werror: replace WERR_INVALID_PARAM with WERR_INVALID_PARAMETER in source4/torture/

Guenther

Signed-off-by: Guenther Deschner <gd@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>

diff --git a/source4/torture/ldap/basic.c b/source4/torture/ldap/basic.c
index 8d964ac80efe2a9194a371f972f4534bcda525ef..5f758a950297bc75b63e588701406f120a076d1a 100644 (file)
--- a/source4/torture/ldap/basic.c
+++ b/source4/torture/ldap/basic.c
@@ -445,7 +445,7 @@ static bool test_error_codes(struct torture_context *tctx,
        err = ad_error(rep->r.ModifyResponse.errormessage, &endptr);
        err_code_str = win_errstr(err);
        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
-       if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM) &&
+       if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAMETER) &&
             !W_ERROR_EQUAL(err, WERR_DS_UNWILLING_TO_PERFORM))
                || (rep->r.ModifyResponse.resultcode != LDAP_UNWILLING_TO_PERFORM)) {
                return false;
@@ -480,7 +480,7 @@ static bool test_error_codes(struct torture_context *tctx,
        err = ad_error(rep->r.ModifyResponse.errormessage, &endptr);
        err_code_str = win_errstr(err);
        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
-       if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM) &&
+       if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAMETER) &&
             !W_ERROR_EQUAL(err, WERR_DS_UNWILLING_TO_PERFORM))
                || (rep->r.ModifyResponse.resultcode != LDAP_UNWILLING_TO_PERFORM)) {
                return false;
@@ -618,7 +618,7 @@ static bool test_error_codes(struct torture_context *tctx,
        err = ad_error(rep->r.ModifyDNResponse.errormessage, &endptr);
        err_code_str = win_errstr(err);
        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
-       if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM) &&
+       if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAMETER) &&
             !W_ERROR_EQUAL(err, WERR_DS_NAMING_VIOLATION))
                || (rep->r.ModifyDNResponse.resultcode != LDAP_NAMING_VIOLATION)) {
                return false;
@@ -654,7 +654,7 @@ static bool test_error_codes(struct torture_context *tctx,
        err = ad_error(rep->r.ModifyDNResponse.errormessage, &endptr);
        err_code_str = win_errstr(err);
        printf(" - Errorcode: %s; Reason: %s\n", err_code_str, endptr);
-       if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAM) &&
+       if ((!W_ERROR_EQUAL(err, WERR_INVALID_PARAMETER) &&
             !W_ERROR_EQUAL(err, WERR_DS_PROTOCOL_ERROR))
                || (rep->r.ModifyDNResponse.resultcode != LDAP_PROTOCOL_ERROR)) {
                return false;

diff --git a/source4/torture/ndr/winreg.c b/source4/torture/ndr/winreg.c
index 0eb1a2487ce65a748dc5625fef8c1f4ffc53c9c7..4eaff8d21cb7c92b6cc879d4318d1a38fcb45138 100644 (file)
--- a/source4/torture/ndr/winreg.c
+++ b/source4/torture/ndr/winreg.c
@@ -113,7 +113,7 @@ static bool createkey_out_check(struct torture_context *tctx,
 {
        torture_assert(tctx, GUID_all_zero(&r->out.new_handle->uuid), "new_handle");
        torture_assert(tctx, r->out.action_taken == NULL, "action_taken pointer");
-       torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, 
+       torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAMETER,
                                                          "return code");
 
        return true;
@@ -487,7 +487,7 @@ static const uint8_t notifychangekeyvalue_out_data[] = {
 
 static bool notifychangekeyvalue_out_check(struct torture_context *tctx, struct winreg_NotifyChangeKeyValue *r)
 {
-       torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, "notify change key value");
+       torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAMETER, "notify change key value");
        return true;
 }
 

diff --git a/source4/torture/rpc/backupkey.c b/source4/torture/rpc/backupkey.c
index 276fa7f58f342a2475815e075c5753bf766e11f5..8cd3c166d0e225138931553ccda67f95f62975a9 100644 (file)
--- a/source4/torture/rpc/backupkey.c
+++ b/source4/torture/rpc/backupkey.c
@@ -844,7 +844,7 @@ static bool test_RestoreGUID_ko(struct torture_context *tctx,
                out_blob.length = *r->out.data_out_len;
                ndr_err = ndr_pull_struct_blob(&out_blob, tctx, &resp, (ndr_pull_flags_fn_t)ndr_pull_bkrp_client_side_unwrapped);
                torture_assert_int_equal(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err), 0, "Unable to unmarshall bkrp_client_side_unwrapped");
-               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, "Wrong error code");
+               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAMETER, "Wrong error code");
        } else {
                struct bkrp_BackupKey *r = createRetrieveBackupKeyGUIDStruct(tctx, p, 2, &out_blob);
                torture_assert_ntstatus_equal(tctx, dcerpc_bkrp_BackupKey_r(b, tctx, r),
@@ -878,7 +878,7 @@ static bool test_RestoreGUID_wrongversion(struct torture_context *tctx,
                out_blob.length = *r->out.data_out_len;
                ndr_err = ndr_pull_struct_blob(&out_blob, tctx, &resp, (ndr_pull_flags_fn_t)ndr_pull_bkrp_client_side_unwrapped);
                torture_assert_int_equal(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err), 0, "Unable to unmarshall bkrp_client_side_unwrapped");
-               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, "Wrong error code on wrong version");
+               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAMETER, "Wrong error code on wrong version");
        } else {
                struct bkrp_BackupKey *r = createRetrieveBackupKeyGUIDStruct(tctx, p, 2, &out_blob);
                torture_assert_ntstatus_equal(tctx, dcerpc_bkrp_BackupKey_r(b, tctx, r),
@@ -1052,7 +1052,7 @@ static bool test_RestoreGUID_emptyrequest(struct torture_context *tctx,
                r->in.param = 0;
                torture_assert_ntstatus_ok(tctx, dcerpc_bkrp_BackupKey_r(b, tctx, r), "Restore GUID");
                out_blob.length = *r->out.data_out_len;
-               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, "Bad error code on wrong has in access check");
+               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAMETER, "Bad error code on wrong has in access check");
        } else {
                struct bkrp_BackupKey *r = createRetrieveBackupKeyGUIDStruct(tctx, p, 2, &out_blob);
                torture_assert_ntstatus_equal(tctx, dcerpc_bkrp_BackupKey_r(b, tctx, r),
@@ -1606,8 +1606,8 @@ static bool test_ServerWrap_decrypt_empty_request(struct torture_context *tctx,
        }
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1625,8 +1625,8 @@ static bool test_ServerWrap_decrypt_empty_request(struct torture_context *tctx,
                                   "decrypt");
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1703,7 +1703,7 @@ static bool test_ServerWrap_decrypt_short_request(struct torture_context *tctx,
        }
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
+                                 WERR_INVALID_PARAMETER,
                                  "decrypt should fail with WERR_INVALID_PARM");
 
        /* Decrypt */
@@ -1722,8 +1722,8 @@ static bool test_ServerWrap_decrypt_short_request(struct torture_context *tctx,
                                   "decrypt");
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1741,8 +1741,8 @@ static bool test_ServerWrap_decrypt_short_request(struct torture_context *tctx,
                                   "decrypt");
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1760,8 +1760,8 @@ static bool test_ServerWrap_decrypt_short_request(struct torture_context *tctx,
                                   "decrypt");
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        return true;
 }
@@ -2205,7 +2205,7 @@ static bool test_ServerWrap_decrypt_wrong_stuff(struct torture_context *tctx,
                torture_assert_werr_equal(tctx,
                                          r.out.result,
                                          WERR_INVALID_SID,
-                                         "decrypt should fail with WERR_INVALID_SID or WERR_INVALID_PARAM");
+                                         "decrypt should fail with WERR_INVALID_SID or WERR_INVALID_PARAMETER");
        } else if (wrong == RIGHT_KEY) {
                torture_assert_werr_equal(tctx,
                                          r.out.result,
@@ -2218,10 +2218,10 @@ static bool test_ServerWrap_decrypt_wrong_stuff(struct torture_context *tctx,
                                          "decrypt should fail with WERR_INVALID_ACCESS");
        } else {
                if (!W_ERROR_EQUAL(r.out.result, WERR_INVALID_ACCESS)
-                   && !W_ERROR_EQUAL(r.out.result, WERR_INVALID_PARAM)) {
+                   && !W_ERROR_EQUAL(r.out.result, WERR_INVALID_PARAMETER)) {
                        torture_assert_werr_equal(tctx, r.out.result,
                                                  WERR_INVALID_DATA,
-                                                 "decrypt should fail with WERR_INVALID_ACCESS, WERR_INVALID_PARAM or WERR_INVALID_DATA");
+                                                 "decrypt should fail with WERR_INVALID_ACCESS, WERR_INVALID_PARAMETER or WERR_INVALID_DATA");
                }
        }
 
@@ -2245,7 +2245,7 @@ static bool test_ServerWrap_decrypt_wrong_stuff(struct torture_context *tctx,
                torture_assert_werr_equal(tctx,
                                          r.out.result,
                                          WERR_INVALID_SID,
-                                         "decrypt should fail with WERR_INVALID_SID or WERR_INVALID_PARAM");
+                                         "decrypt should fail with WERR_INVALID_SID or WERR_INVALID_PARAMETER");
        } else if (wrong == RIGHT_KEY) {
                torture_assert_werr_equal(tctx,
                                          r.out.result,
@@ -2259,8 +2259,8 @@ static bool test_ServerWrap_decrypt_wrong_stuff(struct torture_context *tctx,
        } else {
                torture_assert_werr_equal(tctx,
                                          r.out.result,
-                                         WERR_INVALID_PARAM,
-                                         "decrypt should fail with WERR_INVALID_PARAM");
+                                         WERR_INVALID_PARAMETER,
+                                         "decrypt should fail with WERR_INVALID_PARAMETER");
        }
 
        gnutls_global_deinit();

diff --git a/source4/torture/rpc/backupkey_heimdal.c b/source4/torture/rpc/backupkey_heimdal.c
index 370700a6a8fe196e14ef8c639aac3a021e3ff12a..c516a025c32431976f4e1979430038a86450450d 100644 (file)
--- a/source4/torture/rpc/backupkey_heimdal.c
+++ b/source4/torture/rpc/backupkey_heimdal.c
@@ -796,7 +796,7 @@ static bool test_RestoreGUID_ko(struct torture_context *tctx,
                out_blob.length = *r->out.data_out_len;
                ndr_err = ndr_pull_struct_blob(&out_blob, tctx, &resp, (ndr_pull_flags_fn_t)ndr_pull_bkrp_client_side_unwrapped);
                torture_assert_int_equal(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err), 0, "Unable to unmarshall bkrp_client_side_unwrapped");
-               if (!W_ERROR_EQUAL(r->out.result, WERR_INVALID_PARAM)) {
+               if (!W_ERROR_EQUAL(r->out.result, WERR_INVALID_PARAMETER)) {
                        torture_assert_werr_equal(tctx, r->out.result,
                                                  WERR_INVALID_DATA,
                                                  "Wrong error code");
@@ -829,7 +829,7 @@ static bool test_RestoreGUID_wrongversion(struct torture_context *tctx,
                out_blob.length = *r->out.data_out_len;
                ndr_err = ndr_pull_struct_blob(&out_blob, tctx, &resp, (ndr_pull_flags_fn_t)ndr_pull_bkrp_client_side_unwrapped);
                torture_assert_int_equal(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err), 0, "Unable to unmarshall bkrp_client_side_unwrapped");
-               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, "Wrong error code on wrong version");
+               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAMETER, "Wrong error code on wrong version");
        } else {
                struct bkrp_BackupKey *r = createRetrieveBackupKeyGUIDStruct(tctx, p, 2, &out_blob);
                torture_assert_ntstatus_equal(tctx, dcerpc_bkrp_BackupKey_r(b, tctx, r),
@@ -978,7 +978,7 @@ static bool test_RestoreGUID_emptyrequest(struct torture_context *tctx,
                r->in.param = 0;
                torture_assert_ntstatus_ok(tctx, dcerpc_bkrp_BackupKey_r(b, tctx, r), "Restore GUID");
                out_blob.length = *r->out.data_out_len;
-               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, "Bad error code on wrong has in access check");
+               torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAMETER, "Bad error code on wrong has in access check");
        } else {
                struct bkrp_BackupKey *r = createRetrieveBackupKeyGUIDStruct(tctx, p, 2, &out_blob);
                torture_assert_ntstatus_equal(tctx, dcerpc_bkrp_BackupKey_r(b, tctx, r),
@@ -1384,8 +1384,8 @@ static bool test_ServerWrap_decrypt_empty_request(struct torture_context *tctx,
        }
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1403,8 +1403,8 @@ static bool test_ServerWrap_decrypt_empty_request(struct torture_context *tctx,
                                   "decrypt");
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1481,8 +1481,8 @@ static bool test_ServerWrap_decrypt_short_request(struct torture_context *tctx,
        }
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1500,8 +1500,8 @@ static bool test_ServerWrap_decrypt_short_request(struct torture_context *tctx,
                                   "decrypt");
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1519,8 +1519,8 @@ static bool test_ServerWrap_decrypt_short_request(struct torture_context *tctx,
                                   "decrypt");
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        /* Decrypt */
        torture_assert_ntstatus_ok(tctx,
@@ -1538,8 +1538,8 @@ static bool test_ServerWrap_decrypt_short_request(struct torture_context *tctx,
                                   "decrypt");
        torture_assert_werr_equal(tctx,
                                  r.out.result,
-                                 WERR_INVALID_PARAM,
-                                 "decrypt should fail with WERR_INVALID_PARAM");
+                                 WERR_INVALID_PARAMETER,
+                                 "decrypt should fail with WERR_INVALID_PARAMETER");
 
        return true;
 }
@@ -1927,7 +1927,7 @@ static bool test_ServerWrap_decrypt_wrong_stuff(struct torture_context *tctx,
                torture_assert_werr_equal(tctx,
                                          r.out.result,
                                          WERR_INVALID_SID,
-                                         "decrypt should fail with WERR_INVALID_SID or WERR_INVALID_PARAM");
+                                         "decrypt should fail with WERR_INVALID_SID or WERR_INVALID_PARAMETER");
        } else if (wrong == RIGHT_KEY) {
                torture_assert_werr_equal(tctx,
                                          r.out.result,
@@ -1939,11 +1939,11 @@ static bool test_ServerWrap_decrypt_wrong_stuff(struct torture_context *tctx,
                                          WERR_INVALID_ACCESS,
                                          "decrypt should fail with WERR_INVALID_ACCESS");
        } else {
-               if (!W_ERROR_EQUAL(r.out.result, WERR_INVALID_PARAM)) {
+               if (!W_ERROR_EQUAL(r.out.result, WERR_INVALID_PARAMETER)) {
                        torture_assert_werr_equal(tctx,
                                                  r.out.result,
                                                  WERR_INVALID_ACCESS,
-                                                 "decrypt should fail with WERR_INVALID_ACCESS or WERR_INVALID_PARAM");
+                                                 "decrypt should fail with WERR_INVALID_ACCESS or WERR_INVALID_PARAMETER");
                }
        }
 
@@ -1967,7 +1967,7 @@ static bool test_ServerWrap_decrypt_wrong_stuff(struct torture_context *tctx,
                torture_assert_werr_equal(tctx,
                                          r.out.result,
                                          WERR_INVALID_SID,
-                                         "decrypt should fail with WERR_INVALID_SID or WERR_INVALID_PARAM");
+                                         "decrypt should fail with WERR_INVALID_SID or WERR_INVALID_PARAMETER");
        } else if (wrong == RIGHT_KEY) {
                torture_assert_werr_equal(tctx,
                                          r.out.result,
@@ -1980,10 +1980,10 @@ static bool test_ServerWrap_decrypt_wrong_stuff(struct torture_context *tctx,
                                          "decrypt should fail with WERR_INVALID_ACCESS");
        } else {
                if (!W_ERROR_EQUAL(r.out.result, WERR_INVALID_ACCESS)
-                   && !W_ERROR_EQUAL(r.out.result, WERR_INVALID_PARAM)) {
+                   && !W_ERROR_EQUAL(r.out.result, WERR_INVALID_PARAMETER)) {
                        torture_assert_werr_equal(tctx, r.out.result,
                                                  WERR_INVALID_DATA,
-                                                 "decrypt should fail with WERR_INVALID_ACCESS, WERR_INVALID_PARAM or WERR_INVALID_DATA");
+                                                 "decrypt should fail with WERR_INVALID_ACCESS, WERR_INVALID_PARAMETER or WERR_INVALID_DATA");
                }
        }
 

diff --git a/source4/torture/rpc/browser.c b/source4/torture/rpc/browser.c
index d3c312cb48026f7ea291af5bb825828ed1fb8602..db324b1a465e54f399a1228ee8e64ddec508e950 100644 (file)
--- a/source4/torture/rpc/browser.c
+++ b/source4/torture/rpc/browser.c
@@ -71,7 +71,7 @@ bool test_BrowserrQueryOtherDomains(struct torture_context *tctx,
        info.info.info100 = NULL;
        status = dcerpc_BrowserrQueryOtherDomains_r(b, tctx, &r);
        torture_assert_ntstatus_ok(tctx, status, "BrowserrQueryOtherDomains failed");
-       torture_assert_werr_equal(tctx, WERR_INVALID_PARAM, r.out.result,
+       torture_assert_werr_equal(tctx, WERR_INVALID_PARAMETER, r.out.result,
                                  "BrowserrQueryOtherDomains failed");
 
        info.level = 101;

diff --git a/source4/torture/rpc/spoolss.c b/source4/torture/rpc/spoolss.c
index 6e6c323c7caeecadfb39c76f84bc57e7491bbf81..b6842810c8e1ddc35f3725180a27809cfdf6707b 100644 (file)
--- a/source4/torture/rpc/spoolss.c
+++ b/source4/torture/rpc/spoolss.c
@@ -1323,7 +1323,7 @@ static bool test_SetPrinter_errors(struct torture_context *tctx,
 
        torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),
                "failed to call SetPrinter");
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
                "failed to call SetPrinter");
 
  again:
@@ -1434,7 +1434,7 @@ static bool test_SetPrinter_errors(struct torture_context *tctx,
                case 4:
                case 5:
                case 7:
-                       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
+                       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
                                "unexpected error code returned");
                        break;
                case 9:
@@ -2241,10 +2241,10 @@ static bool test_devicemode_full(struct torture_context *tctx,
        uint16_t __driverextra_length;/* [value(r->driverextra_data.length)] */
        uint32_t fields;
 #endif
-       TEST_DEVMODE_INT_EXP(8, size,           8, size, __LINE__, WERR_INVALID_PARAM);
-       TEST_DEVMODE_INT_EXP(8, size,           8, size, 0, WERR_INVALID_PARAM);
-       TEST_DEVMODE_INT_EXP(8, size,           8, size, 0xffff, WERR_INVALID_PARAM);
-       TEST_DEVMODE_INT_EXP(8, size,           8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0), (devmode_ctr.devmode->__driverextra_length > 0 ) ? WERR_INVALID_PARAM : WERR_OK);
+       TEST_DEVMODE_INT_EXP(8, size,           8, size, __LINE__, WERR_INVALID_PARAMETER);
+       TEST_DEVMODE_INT_EXP(8, size,           8, size, 0, WERR_INVALID_PARAMETER);
+       TEST_DEVMODE_INT_EXP(8, size,           8, size, 0xffff, WERR_INVALID_PARAMETER);
+       TEST_DEVMODE_INT_EXP(8, size,           8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0), (devmode_ctr.devmode->__driverextra_length > 0 ) ? WERR_INVALID_PARAMETER : WERR_OK);
        TEST_DEVMODE_INT(8, size,               8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0) - devmode_ctr.devmode->__driverextra_length);
 
        devmode_ctr.devmode->driverextra_data = data_blob_string_const("foobar");
@@ -2252,7 +2252,7 @@ static bool test_devicemode_full(struct torture_context *tctx,
                test_devmode_set_level(tctx, b, handle, 8, devmode_ctr.devmode),
                "failed to set devmode");
 
-       TEST_DEVMODE_INT_EXP(8, size,           8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0), (devmode_ctr.devmode->__driverextra_length > 0 ) ? WERR_INVALID_PARAM : WERR_OK);
+       TEST_DEVMODE_INT_EXP(8, size,           8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0), (devmode_ctr.devmode->__driverextra_length > 0 ) ? WERR_INVALID_PARAMETER : WERR_OK);
        TEST_DEVMODE_INT(8, size,               8, size, ndr_size_spoolss_DeviceMode(devmode_ctr.devmode, 0) - devmode_ctr.devmode->__driverextra_length);
 
        TEST_DEVMODE_INT(8, orientation,        8, orientation, __LINE__);
@@ -2743,8 +2743,8 @@ static bool test_AddForm(struct torture_context *tctx,
 
        torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_AddForm_r(b, tctx, &r),
                "2nd AddForm failed");
-       if (W_ERROR_EQUAL(expected_result, WERR_INVALID_PARAM)) {
-               torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
+       if (W_ERROR_EQUAL(expected_result, WERR_INVALID_PARAMETER)) {
+               torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
                        "2nd AddForm gave unexpected result");
        } else {
                torture_assert_werr_equal(tctx, r.out.result, WERR_FILE_EXISTS,
@@ -2895,7 +2895,7 @@ static bool test_Forms_args(struct torture_context *tctx,
                torture_assert_int_equal(tctx, info.info1.size.width, add_info.info1->size.width, "width mismatch");
        }
 
-       if (!W_ERROR_EQUAL(expected_add_result, WERR_INVALID_PARAM)) {
+       if (!W_ERROR_EQUAL(expected_add_result, WERR_INVALID_PARAMETER)) {
                torture_assert(tctx,
                        test_EnumForms_find_one(tctx, b, handle, print_server, form_name),
                        "Newly added form not found in enum call");
@@ -2955,7 +2955,7 @@ static bool test_Forms(struct torture_context *tctx,
                                .area           = area,
                        },
                        .expected_add_result    = WERR_OK,
-                       .expected_delete_result = WERR_INVALID_PARAM,
+                       .expected_delete_result = WERR_INVALID_PARAMETER,
                },
 */
                {
@@ -2976,7 +2976,7 @@ static bool test_Forms(struct torture_context *tctx,
                                .area           = area,
                        },
                        .expected_add_result    = WERR_FILE_EXISTS,
-                       .expected_delete_result = WERR_INVALID_PARAM
+                       .expected_delete_result = WERR_INVALID_PARAMETER
                },
                {
                        .info1 = {
@@ -2986,7 +2986,7 @@ static bool test_Forms(struct torture_context *tctx,
                                .area           = area,
                        },
                        .expected_add_result    = WERR_FILE_EXISTS,
-                       .expected_delete_result = WERR_INVALID_PARAM
+                       .expected_delete_result = WERR_INVALID_PARAMETER
                },
                {
                        .info1 = {
@@ -2996,7 +2996,7 @@ static bool test_Forms(struct torture_context *tctx,
                                .area           = area,
                        },
                        .expected_add_result    = WERR_FILE_EXISTS,
-                       .expected_delete_result = WERR_INVALID_PARAM
+                       .expected_delete_result = WERR_INVALID_PARAMETER
                },
                {
                        .info1 = {
@@ -3005,7 +3005,7 @@ static bool test_Forms(struct torture_context *tctx,
                                .size           = size,
                                .area           = area,
                        },
-                       .expected_add_result    = WERR_INVALID_PARAM,
+                       .expected_add_result    = WERR_INVALID_PARAMETER,
                        .expected_delete_result = WERR_INVALID_FORM_NAME
                }
 
@@ -3256,7 +3256,7 @@ static bool test_AddJob(struct torture_context *tctx,
 
        status = dcerpc_spoolss_AddJob_r(b, tctx, &r);
        torture_assert_ntstatus_ok(tctx, status, "AddJob failed");
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER, "AddJob failed");
 
        return true;
 }
@@ -6360,7 +6360,7 @@ static bool test_OpenPrinter_badname(struct torture_context *tctx,
 
        status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &opEx);
        torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
-       torture_assert_werr_equal(tctx, opEx.out.result, WERR_INVALID_PARAM,
+       torture_assert_werr_equal(tctx, opEx.out.result, WERR_INVALID_PARAMETER,
                "unexpected result");
 
        if (W_ERROR_IS_OK(opEx.out.result)) {
@@ -9750,11 +9750,11 @@ static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
 
        if (ex) {
                torture_assert(tctx,
-                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
+                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriverEx level 2");
        } else {
                torture_assert(tctx,
-                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
+                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriver level 2");
        }
 
@@ -9762,11 +9762,11 @@ static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
 
        if (ex) {
                torture_assert(tctx,
-                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
+                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriverEx level 2");
        } else {
                torture_assert(tctx,
-                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
+                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriver level 2");
        }
 
@@ -9774,11 +9774,11 @@ static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
 
        if (ex) {
                torture_assert(tctx,
-                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
+                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriverEx level 2");
        } else {
                torture_assert(tctx,
-                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
+                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriver level 2");
        }
 
@@ -9786,11 +9786,11 @@ static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
 
        if (ex) {
                torture_assert(tctx,
-                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
+                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriverEx level 2");
        } else {
                torture_assert(tctx,
-                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
+                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriver level 2");
        }
 
@@ -9798,11 +9798,11 @@ static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
 
        if (ex) {
                torture_assert(tctx,
-                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
+                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriverEx level 2");
        } else {
                torture_assert(tctx,
-                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
+                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriver level 2");
        }
 
@@ -9810,11 +9810,11 @@ static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
 
        if (ex) {
                torture_assert(tctx,
-                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAM),
+                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, flags, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriverEx level 2");
        } else {
                torture_assert(tctx,
-                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAM),
+                       test_AddPrinterDriver_exp(tctx, b, server_name, &info_ctr, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriver level 2");
        }
 
@@ -9822,7 +9822,7 @@ static bool test_AddPrinterDriver_args_level_2(struct torture_context *tctx,
 
        if (ex) {
                torture_assert(tctx,
-                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, 0, WERR_INVALID_PARAM),
+                       test_AddPrinterDriverEx_exp(tctx, b, server_name, &info_ctr, 0, WERR_INVALID_PARAMETER),
                        "failed to test AddPrinterDriverEx");
        }
 

diff --git a/source4/torture/rpc/spoolss_win.c b/source4/torture/rpc/spoolss_win.c
index 3a73b9a4d8957f613ea689009889fc3330793041..9162acd56d5d3c3e00785a64737cfe29faeb3ee7 100644 (file)
--- a/source4/torture/rpc/spoolss_win.c
+++ b/source4/torture/rpc/spoolss_win.c
@@ -469,7 +469,7 @@ static bool test_WinXP(struct torture_context *tctx, struct dcerpc_pipe *p)
 
        ret &= test_OpenPrinterSequence(tctx, p, &handle01);
        ret &= test_GetPrinterData(tctx, b, &handle01,"UISingleJobStatusString",
-                       WERR_INVALID_PARAM, 0);
+                       WERR_INVALID_PARAMETER, 0);
        torture_comment(tctx, "Skip RemoteFindNextPrinterChangeNotifyEx test\n");
 
        server_name = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p));
@@ -547,7 +547,7 @@ static bool test_WinXP(struct torture_context *tctx, struct dcerpc_pipe *p)
        }
 
        ret &= test_EnumPrinterDataEx(tctx, b, &handle03, "", 0,
-                       WERR_INVALID_PARAM);
+                       WERR_INVALID_PARAMETER);
 
        ret &= test_GetPrinter(tctx, b, &handle03, tmp_ctx, 2, 0);
 

diff --git a/source4/torture/rpc/svcctl.c b/source4/torture/rpc/svcctl.c
index 3e6b66dcc5170c2a59394fe1f17422cbde17f3a5..ebb2bc6ad0e49305f0c1b6daea505bed5547e097 100644 (file)
--- a/source4/torture/rpc/svcctl.c
+++ b/source4/torture/rpc/svcctl.c
@@ -300,7 +300,7 @@ static bool test_QueryServiceObjectSecurity(struct torture_context *tctx,
        torture_assert_ntstatus_ok(tctx,
                dcerpc_svcctl_QueryServiceObjectSecurity_r(b, tctx, &r),
                "QueryServiceObjectSecurity failed!");
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
                "QueryServiceObjectSecurity failed!");
 
        r.in.security_flags = SECINFO_DACL;
@@ -454,7 +454,7 @@ static bool test_ControlService(struct torture_context *tctx,
        torture_assert_ntstatus_ok(tctx,
                dcerpc_svcctl_ControlService_r(b, tctx, &r),
                "ControlService failed!");
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
                "ControlService failed!");
 
        if (!test_CloseServiceHandle(b, tctx, &s))
@@ -574,7 +574,7 @@ static bool test_EnumDependentServicesW(struct torture_context *tctx,
                dcerpc_svcctl_EnumDependentServicesW_r(b, tctx, &r),
                "EnumDependentServicesW failed!");
 
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
                "EnumDependentServicesW failed!");
 
        for (i=0; i<ARRAY_SIZE(states); i++) {

diff --git a/source4/torture/rpc/winreg.c b/source4/torture/rpc/winreg.c
index 1a45c469cf5d83bb149288feab1ba79eee787869..1a7b60f6493386e83e2ef37debfd9ac746a78588 100644 (file)
--- a/source4/torture/rpc/winreg.c
+++ b/source4/torture/rpc/winreg.c
@@ -1228,7 +1228,7 @@ static bool test_SecurityDescriptorsSecInfo(struct dcerpc_pipe *p,
                        false, (secinfo_verify_fn)_test_owner_present },
                { sd_owner, SECINFO_OWNER, WERR_OK,
                        true, (secinfo_verify_fn)_test_owner_present },
-               { sd_owner, SECINFO_GROUP, WERR_INVALID_PARAM },
+               { sd_owner, SECINFO_GROUP, WERR_INVALID_PARAMETER },
                { sd_owner, SECINFO_DACL, WERR_OK,
                        true, (secinfo_verify_fn)_test_owner_present },
                { sd_owner, SECINFO_SACL, WERR_ACCESS_DENIED },
@@ -1242,7 +1242,7 @@ static bool test_SecurityDescriptorsSecInfo(struct dcerpc_pipe *p,
        struct winreg_secinfo_table sec_info_group_tests[] = {
                { sd_group, 0, WERR_OK,
                        false, (secinfo_verify_fn)_test_group_present },
-               { sd_group, SECINFO_OWNER, WERR_INVALID_PARAM },
+               { sd_group, SECINFO_OWNER, WERR_INVALID_PARAMETER },
                { sd_group, SECINFO_GROUP, WERR_OK,
                        true, (secinfo_verify_fn)_test_group_present },
                { sd_group, SECINFO_DACL, WERR_OK,
@@ -1257,8 +1257,8 @@ static bool test_SecurityDescriptorsSecInfo(struct dcerpc_pipe *p,
        struct winreg_secinfo_table sec_info_dacl_tests[] = {
                { sd_dacl, 0, WERR_OK,
                        false, (secinfo_verify_fn)_test_dacl_trustee_present },
-               { sd_dacl, SECINFO_OWNER, WERR_INVALID_PARAM },
-               { sd_dacl, SECINFO_GROUP, WERR_INVALID_PARAM },
+               { sd_dacl, SECINFO_OWNER, WERR_INVALID_PARAMETER },
+               { sd_dacl, SECINFO_GROUP, WERR_INVALID_PARAMETER },
                { sd_dacl, SECINFO_DACL, WERR_OK,
                        true, (secinfo_verify_fn)_test_dacl_trustee_present },
                { sd_dacl, SECINFO_SACL, WERR_ACCESS_DENIED },
@@ -1272,8 +1272,8 @@ static bool test_SecurityDescriptorsSecInfo(struct dcerpc_pipe *p,
        struct winreg_secinfo_table sec_info_sacl_tests[] = {
                { sd_sacl, 0, WERR_OK,
                        false, (secinfo_verify_fn)_test_sacl_trustee_present },
-               { sd_sacl, SECINFO_OWNER, WERR_INVALID_PARAM },
-               { sd_sacl, SECINFO_GROUP, WERR_INVALID_PARAM },
+               { sd_sacl, SECINFO_OWNER, WERR_INVALID_PARAMETER },
+               { sd_sacl, SECINFO_GROUP, WERR_INVALID_PARAMETER },
                { sd_sacl, SECINFO_DACL, WERR_OK,
                        false, (secinfo_verify_fn)_test_sacl_trustee_present },
                { sd_sacl, SECINFO_SACL, WERR_OK,
@@ -1882,8 +1882,8 @@ static bool test_QueryValue_full(struct dcerpc_binding_handle *b,
        const char *errmsg_nonexisting = "expected WERR_FILE_NOT_FOUND for nonexisting value";
 
        if (valuename == NULL) {
-               expected_error = WERR_INVALID_PARAM;
-               errmsg_nonexisting = "expected WERR_INVALID_PARAM for NULL valuename";
+               expected_error = WERR_INVALID_PARAMETER;
+               errmsg_nonexisting = "expected WERR_INVALID_PARAMETER for NULL valuename";
        }
 
        ZERO_STRUCT(r);
@@ -1896,30 +1896,30 @@ static bool test_QueryValue_full(struct dcerpc_binding_handle *b,
        r.in.value_name = &value_name;
 
        torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
-               "expected WERR_INVALID_PARAM for NULL winreg_String.name");
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
+               "expected WERR_INVALID_PARAMETER for NULL winreg_String.name");
 
        init_winreg_String(&value_name, valuename);
        r.in.value_name = &value_name;
 
        torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r),
                "QueryValue failed");
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
-               "expected WERR_INVALID_PARAM for missing type length and size");
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
+               "expected WERR_INVALID_PARAMETER for missing type length and size");
 
        r.in.type = &type;
        r.out.type = &type;
        torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r),
                "QueryValue failed");
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
-               "expected WERR_INVALID_PARAM for missing length and size");
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
+               "expected WERR_INVALID_PARAMETER for missing length and size");
 
        r.in.data_length = &data_length;
        r.out.data_length = &data_length;
        torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r),
                "QueryValue failed");
-       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
-               "expected WERR_INVALID_PARAM for missing size");
+       torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAMETER,
+               "expected WERR_INVALID_PARAMETER for missing size");
 
        r.in.data_size = &data_size;
        r.out.data_size = &data_size;

diff --git a/source4/torture/rpc/witness.c b/source4/torture/rpc/witness.c
index 6f50a637543efd6cbc41d673620a7e7634e0e755..1d4ae8636a0565764ec51344d858e67906322e72 100644 (file)
--- a/source4/torture/rpc/witness.c
+++ b/source4/torture/rpc/witness.c
@@ -175,7 +175,7 @@ static bool test_witness_UnRegister_with_handle(struct torture_context *tctx,
 
        torture_assert_werr_equal(tctx,
                r.out.result,
-               WERR_INVALID_PARAM,
+               WERR_INVALID_PARAMETER,
                "UnRegister failed");
 
        return true;
@@ -270,14 +270,14 @@ static bool test_witness_Register(struct torture_context *tctx,
                        .ip_address             = "",
                        .client_computer_name   = "",
                        .expected_status        = NT_STATUS_OK,
-                       .expected_result        = WERR_INVALID_PARAM
+                       .expected_result        = WERR_INVALID_PARAMETER
                },{
                        .version                = WITNESS_V1,
                        .net_name               = NULL,
                        .ip_address             = NULL,
                        .client_computer_name   = lpcfg_netbios_name(tctx->lp_ctx),
                        .expected_status        = NT_STATUS_OK,
-                       .expected_result        = WERR_INVALID_PARAM
+                       .expected_result        = WERR_INVALID_PARAMETER
                },{
                        .version                = WITNESS_V2,
                        .net_name               = NULL,
@@ -291,7 +291,7 @@ static bool test_witness_Register(struct torture_context *tctx,
                        .ip_address             = NULL,
                        .client_computer_name   = lpcfg_netbios_name(tctx->lp_ctx),
                        .expected_status        = NT_STATUS_OK,
-                       .expected_result        = WERR_INVALID_PARAM
+                       .expected_result        = WERR_INVALID_PARAMETER
                }
 
        };
@@ -406,14 +406,14 @@ static bool test_witness_RegisterEx(struct torture_context *tctx,
                        .ip_address             = "",
                        .client_computer_name   = "",
                        .expected_status        = NT_STATUS_OK,
-                       .expected_result        = WERR_INVALID_PARAM
+                       .expected_result        = WERR_INVALID_PARAMETER
                },{
                        .version                = WITNESS_V2,
                        .net_name               = NULL,
                        .ip_address             = NULL,
                        .client_computer_name   = lpcfg_netbios_name(tctx->lp_ctx),
                        .expected_status        = NT_STATUS_OK,
-                       .expected_result        = WERR_INVALID_PARAM
+                       .expected_result        = WERR_INVALID_PARAMETER
                },{
                        .version                = WITNESS_V1,
                        .net_name               = NULL,
@@ -427,7 +427,7 @@ static bool test_witness_RegisterEx(struct torture_context *tctx,
                        .ip_address             = NULL,
                        .client_computer_name   = lpcfg_netbios_name(tctx->lp_ctx),
                        .expected_status        = NT_STATUS_OK,
-                       .expected_result        = WERR_INVALID_PARAM
+                       .expected_result        = WERR_INVALID_PARAMETER
                }
 
        };

diff --git a/source4/torture/rpc/wkssvc.c b/source4/torture/rpc/wkssvc.c
index 09272004ef3dfe81af4fff4023a4ee53b9f718ac..e2c32f49260ef544fe4b4f9346dd25249a7f7be8 100644 (file)
--- a/source4/torture/rpc/wkssvc.c
+++ b/source4/torture/rpc/wkssvc.c
@@ -129,7 +129,7 @@ static bool test_NetrWkstaTransportAdd(struct torture_context *tctx,
        torture_assert_ntstatus_ok(tctx, status,
                                   "NetrWkstaTransportAdd failed");
        torture_assert_werr_equal(tctx, r.out.result,
-                                 WERR_INVALID_PARAM,
+                                 WERR_INVALID_PARAMETER,
                                  "NetrWkstaTransportAdd level 0 failed");
 
        return true;
@@ -231,12 +231,12 @@ static bool test_NetrWkstaUserGetInfo(struct torture_context *tctx,
                { NULL, 0, WERR_NO_SUCH_LOGON_SESSION },
                { NULL, 1, WERR_NO_SUCH_LOGON_SESSION },
                { NULL, 1101, WERR_OK },
-               { dom, 0, WERR_INVALID_PARAM },
-               { dom, 1, WERR_INVALID_PARAM },
-               { dom, 1101, WERR_INVALID_PARAM },
-               { user, 0, WERR_INVALID_PARAM },
-               { user, 1, WERR_INVALID_PARAM },
-               { user, 1101, WERR_INVALID_PARAM },
+               { dom, 0, WERR_INVALID_PARAMETER },
+               { dom, 1, WERR_INVALID_PARAMETER },
+               { dom, 1101, WERR_INVALID_PARAMETER },
+               { user, 0, WERR_INVALID_PARAMETER },
+               { user, 1, WERR_INVALID_PARAMETER },
+               { user, 1101, WERR_INVALID_PARAMETER },
        };
 
        for (i=0; i<ARRAY_SIZE(tests); i++) {