source4/torture/rap/printing.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for SMB printing operations
   4
   5    Copyright (C) Guenther Deschner 2010
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22 #include "libcli/raw/libcliraw.h"
  23 #include "libcli/libcli.h"
  24 #include "torture/torture.h"
  25 #include "torture/util.h"
  26 #include "system/filesys.h"
  27
  28 #include "torture/smbtorture.h"
  29 #include "torture/util.h"
  30 #include "libcli/rap/rap.h"
  31 #include "torture/rap/proto.h"
  32 #include "param/param.h"
  33
  34 /* TODO:
  35
  36  printing half the file,
  37  finding job
  38  delete job
  39  try writing 2nd half
  40
  41  SMBsplretq
  42
  43 */
  44
  45 #define TORTURE_PRINT_FILE "torture_print_file"
  46
  47 static bool print_printjob(struct torture_context *tctx,
  48                            struct smbcli_tree *tree)
  49 {
  50         int fnum;
  51         DATA_BLOB data;
  52         ssize_t size_written;
  53         const char *str;
  54
  55         torture_comment(tctx, "creating printjob %s\n", TORTURE_PRINT_FILE);
  56
  57         fnum = smbcli_open(tree, TORTURE_PRINT_FILE, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
  58         if (fnum == -1) {
  59                 torture_fail(tctx, "failed to open file");
  60         }
  61
  62         str = talloc_asprintf(tctx, "TortureTestPage: %d\nData\n",0);
  63
  64         data = data_blob_string_const(str);
  65
  66         size_written = smbcli_write(tree, fnum, 0, data.data, 0, data.length);
  67         if (size_written != data.length) {
  68                 torture_fail(tctx, "failed to write file");
  69         }
  70
  71         torture_assert_ntstatus_ok(tctx,
  72                 smbcli_close(tree, fnum),
  73                 "failed to close file");
  74
  75         return true;
  76 }
  77
  78 static bool test_raw_print(struct torture_context *tctx,
  79                            struct smbcli_state *cli)
  80 {
  81         return print_printjob(tctx, cli->tree);
  82 }
  83
  84 static bool test_netprintqenum(struct torture_context *tctx,
  85                                struct smbcli_state *cli)
  86 {
  87         struct rap_NetPrintQEnum r;
  88         int i, q;
  89         uint16_t levels[] = { 0, 1, 2, 3, 4, 5 };
  90
  91         for (i=0; i < ARRAY_SIZE(levels); i++) {
  92
  93                 r.in.level = levels[i];
  94                 r.in.bufsize = 8192;
  95
  96                 torture_comment(tctx,
  97                         "Testing rap_NetPrintQEnum level %d\n", r.in.level);
  98
  99                 torture_assert_ntstatus_ok(tctx,
 100                         smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 101                         "smbcli_rap_netprintqenum failed");
 102                 torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 103                         "failed to enum printq");
 104
 105                 for (q=0; q<r.out.count; q++) {
 106                         switch (r.in.level) {
 107                         case 0:
 108                                 printf("%s\n", r.out.info[q].info0.PrintQName);
 109                                 break;
 110                         }
 111                 }
 112         }
 113
 114         return true;
 115 }
 116
 117 static bool test_netprintqgetinfo(struct torture_context *tctx,
 118                                   struct smbcli_state *cli)
 119 {
 120         struct rap_NetPrintQGetInfo r;
 121         struct rap_NetPrintQEnum r_enum;
 122         int i, p;
 123         uint16_t levels[] = { 0, 1, 2, 3, 4, 5 };
 124
 125         r.in.level = 0;
 126         r.in.bufsize = 0;
 127         r.in.PrintQueueName = "";
 128
 129         torture_assert_ntstatus_ok(tctx,
 130                 smbcli_rap_netprintqgetinfo(cli->tree, tctx, &r),
 131                 "smbcli_rap_netprintqgetinfo failed");
 132         torture_assert_werr_equal(tctx,
 133                                   W_ERROR(r.out.status),
 134                                   WERR_INVALID_PARAMETER,
 135                                   "smbcli_rap_netprintqgetinfo failed");
 136
 137         r_enum.in.level = 5;
 138         r_enum.in.bufsize = 8192;
 139
 140         torture_assert_ntstatus_ok(tctx,
 141                 smbcli_rap_netprintqenum(cli->tree, tctx, &r_enum),
 142                 "failed to enum printq");
 143         torture_assert_werr_ok(tctx, W_ERROR(r_enum.out.status),
 144                 "failed to enum printq");
 145
 146         for (p=0; p < r_enum.out.count; p++) {
 147
 148                 for (i=0; i < ARRAY_SIZE(levels); i++) {
 149
 150                         r.in.level = levels[i];
 151                         r.in.bufsize = 8192;
 152                         r.in.PrintQueueName = r_enum.out.info[p].info5.PrintQueueName;
 153
 154                         torture_comment(tctx, "Testing rap_NetPrintQGetInfo(%s) level %d\n",
 155                                 r.in.PrintQueueName, r.in.level);
 156
 157                         torture_assert_ntstatus_ok(tctx,
 158                                 smbcli_rap_netprintqgetinfo(cli->tree, tctx, &r),
 159                                 "smbcli_rap_netprintqgetinfo failed");
 160                         torture_assert_werr_ok(tctx,
 161                                 W_ERROR(r.out.status),
 162                                 "smbcli_rap_netprintqgetinfo failed");
 163
 164                         switch (r.in.level) {
 165                         case 0:
 166                                 printf("%s\n", r.out.info.info0.PrintQName);
 167                                 break;
 168                         }
 169                 }
 170         }
 171
 172         return true;
 173 }
 174
 175 static bool test_netprintjob_pause(struct torture_context *tctx,
 176                                    struct smbcli_state *cli,
 177                                    uint16_t job_id)
 178 {
 179         struct rap_NetPrintJobPause r;
 180
 181         r.in.JobID = job_id;
 182
 183         torture_comment(tctx, "Testing rap_NetPrintJobPause(%d)\n", r.in.JobID);
 184
 185         torture_assert_ntstatus_ok(tctx,
 186                 smbcli_rap_netprintjobpause(cli->tree, tctx, &r),
 187                 "smbcli_rap_netprintjobpause failed");
 188
 189         return true;
 190 }
 191
 192 static bool test_netprintjob_continue(struct torture_context *tctx,
 193                                       struct smbcli_state *cli,
 194                                       uint16_t job_id)
 195 {
 196         struct rap_NetPrintJobContinue r;
 197
 198         r.in.JobID = job_id;
 199
 200         torture_comment(tctx, "Testing rap_NetPrintJobContinue(%d)\n", r.in.JobID);
 201
 202         torture_assert_ntstatus_ok(tctx,
 203                 smbcli_rap_netprintjobcontinue(cli->tree, tctx, &r),
 204                 "smbcli_rap_netprintjobcontinue failed");
 205
 206         return true;
 207 }
 208
 209 static bool test_netprintjob_delete(struct torture_context *tctx,
 210                                     struct smbcli_state *cli,
 211                                     uint16_t job_id)
 212 {
 213         struct rap_NetPrintJobDelete r;
 214
 215         r.in.JobID = job_id;
 216
 217         torture_comment(tctx, "Testing rap_NetPrintJobDelete(%d)\n", r.in.JobID);
 218
 219         torture_assert_ntstatus_ok(tctx,
 220                 smbcli_rap_netprintjobdelete(cli->tree, tctx, &r),
 221                 "smbcli_rap_netprintjobdelete failed");
 222
 223         return true;
 224 }
 225
 226 static bool test_netprintjob(struct torture_context *tctx,
 227                              struct smbcli_state *cli)
 228 {
 229         uint16_t job_id = 400;
 230
 231         torture_assert(tctx,
 232                 test_netprintjob_pause(tctx, cli, job_id),
 233                 "failed to pause job");
 234         torture_assert(tctx,
 235                 test_netprintjob_continue(tctx, cli, job_id),
 236                 "failed to continue job");
 237         torture_assert(tctx,
 238                 test_netprintjob_delete(tctx, cli, job_id),
 239                 "failed to delete job");
 240
 241         return true;
 242 }
 243
 244 static bool test_netprintq_pause(struct torture_context *tctx,
 245                                  struct smbcli_state *cli,
 246                                  const char *PrintQueueName)
 247 {
 248         struct rap_NetPrintQueuePause r;
 249
 250         r.in.PrintQueueName = PrintQueueName;
 251
 252         torture_comment(tctx, "Testing rap_NetPrintQueuePause(%s)\n", r.in.PrintQueueName);
 253
 254         torture_assert_ntstatus_ok(tctx,
 255                 smbcli_rap_netprintqueuepause(cli->tree, tctx, &r),
 256                 "smbcli_rap_netprintqueuepause failed");
 257         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 258                 "smbcli_rap_netprintqueuepause failed");
 259
 260         return true;
 261 }
 262
 263 static bool test_netprintq_resume(struct torture_context *tctx,
 264                                   struct smbcli_state *cli,
 265                                   const char *PrintQueueName)
 266 {
 267         struct rap_NetPrintQueueResume r;
 268
 269         r.in.PrintQueueName = PrintQueueName;
 270
 271         torture_comment(tctx, "Testing rap_NetPrintQueueResume(%s)\n", r.in.PrintQueueName);
 272
 273         torture_assert_ntstatus_ok(tctx,
 274                 smbcli_rap_netprintqueueresume(cli->tree, tctx, &r),
 275                 "smbcli_rap_netprintqueueresume failed");
 276         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 277                 "smbcli_rap_netprintqueueresume failed");
 278
 279         return true;
 280 }
 281
 282 static bool test_netprintq(struct torture_context *tctx,
 283                            struct smbcli_state *cli)
 284 {
 285         struct rap_NetPrintQEnum r;
 286         int i;
 287
 288         r.in.level = 5;
 289         r.in.bufsize = 8192;
 290
 291         torture_assert_ntstatus_ok(tctx,
 292                 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 293                 "failed to enum printq");
 294         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 295                 "failed to enum printq");
 296
 297         for (i=0; i < r.out.count; i++) {
 298
 299                 const char *printqname = r.out.info[i].info5.PrintQueueName;
 300
 301                 torture_assert(tctx,
 302                         test_netprintq_pause(tctx, cli, printqname),
 303                         "failed to pause print queue");
 304
 305                 torture_assert(tctx,
 306                         test_netprintq_resume(tctx, cli, printqname),
 307                         "failed to resume print queue");
 308         }
 309
 310         return true;
 311 }
 312
 313 static bool test_netprintjobenum_args(struct torture_context *tctx,
 314                                       struct smbcli_state *cli,
 315                                       const char *PrintQueueName,
 316                                       uint16_t level,
 317                                       uint16_t *count_p,
 318                                       union rap_printj_info **info_p)
 319 {
 320         struct rap_NetPrintJobEnum r;
 321
 322         r.in.PrintQueueName = PrintQueueName;
 323         r.in.bufsize = 8192;
 324         r.in.level = level;
 325
 326         torture_comment(tctx,
 327                 "Testing rap_NetPrintJobEnum(%s) level %d\n", r.in.PrintQueueName, r.in.level);
 328
 329         torture_assert_ntstatus_ok(tctx,
 330                 smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
 331                 "smbcli_rap_netprintjobenum failed");
 332
 333         if (count_p) {
 334                 *count_p = r.out.count;
 335         }
 336         if (info_p) {
 337                 *info_p = r.out.info;
 338         }
 339
 340         return true;
 341 }
 342
 343 static bool test_netprintjobenum_one(struct torture_context *tctx,
 344                                      struct smbcli_state *cli,
 345                                      const char *PrintQueueName)
 346 {
 347         struct rap_NetPrintJobEnum r;
 348         int i;
 349         uint16_t levels[] = { 0, 1, 2 };
 350
 351         r.in.PrintQueueName = PrintQueueName;
 352         r.in.bufsize = 8192;
 353
 354         for (i=0; i < ARRAY_SIZE(levels); i++) {
 355
 356                 r.in.level = levels[i];
 357
 358                 torture_comment(tctx,
 359                         "Testing rap_NetPrintJobEnum(%s) level %d\n", r.in.PrintQueueName, r.in.level);
 360
 361                 torture_assert_ntstatus_ok(tctx,
 362                         smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
 363                         "smbcli_rap_netprintjobenum failed");
 364         }
 365
 366         return true;
 367 }
 368
 369 static bool test_netprintjobgetinfo_byid(struct torture_context *tctx,
 370                                          struct smbcli_state *cli,
 371                                          uint16_t JobID)
 372 {
 373         struct rap_NetPrintJobGetInfo r;
 374         uint16_t levels[] = { 0, 1, 2 };
 375         int i;
 376
 377         r.in.JobID = JobID;
 378         r.in.bufsize = 8192;
 379
 380         for (i=0; i < ARRAY_SIZE(levels); i++) {
 381
 382                 r.in.level = levels[i];
 383
 384                 torture_comment(tctx, "Testing rap_NetPrintJobGetInfo(%d) level %d\n", r.in.JobID, r.in.level);
 385
 386                 torture_assert_ntstatus_ok(tctx,
 387                         smbcli_rap_netprintjobgetinfo(cli->tree, tctx, &r),
 388                         "smbcli_rap_netprintjobgetinfo failed");
 389         }
 390
 391         return true;
 392 }
 393
 394 static bool test_netprintjobsetinfo_byid(struct torture_context *tctx,
 395                                          struct smbcli_state *cli,
 396                                          uint16_t JobID)
 397 {
 398         struct rap_NetPrintJobSetInfo r;
 399         uint16_t levels[] = { 0, 1, 2 };
 400         int i;
 401         const char *comment = "tortured by samba";
 402
 403         r.in.JobID = JobID;
 404         r.in.bufsize = strlen(comment);
 405         r.in.ParamNum = RAP_PARAM_JOBCOMMENT;
 406         r.in.Param.string = comment;
 407
 408         for (i=0; i < ARRAY_SIZE(levels); i++) {
 409
 410                 r.in.level = levels[i];
 411
 412                 torture_comment(tctx, "Testing rap_NetPrintJobSetInfo(%d) level %d\n", r.in.JobID, r.in.level);
 413
 414                 torture_assert_ntstatus_ok(tctx,
 415                         smbcli_rap_netprintjobsetinfo(cli->tree, tctx, &r),
 416                         "smbcli_rap_netprintjobsetinfo failed");
 417         }
 418
 419         return true;
 420 }
 421
 422
 423 static bool test_netprintjobgetinfo_byqueue(struct torture_context *tctx,
 424                                             struct smbcli_state *cli,
 425                                             const char *PrintQueueName)
 426 {
 427         struct rap_NetPrintJobEnum r;
 428         int i;
 429
 430         r.in.PrintQueueName = PrintQueueName;
 431         r.in.bufsize = 8192;
 432         r.in.level = 0;
 433
 434         torture_assert_ntstatus_ok(tctx,
 435                 smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
 436                 "failed to enumerate jobs");
 437
 438         for (i=0; i < r.out.count; i++) {
 439
 440                 torture_assert(tctx,
 441                         test_netprintjobgetinfo_byid(tctx, cli, r.out.info[i].info0.JobID),
 442                         "failed to get job info");
 443         }
 444
 445         return true;
 446 }
 447
 448 static bool test_netprintjobsetinfo_byqueue(struct torture_context *tctx,
 449                                             struct smbcli_state *cli,
 450                                             const char *PrintQueueName)
 451 {
 452         struct rap_NetPrintJobEnum r;
 453         int i;
 454
 455         r.in.PrintQueueName = PrintQueueName;
 456         r.in.bufsize = 8192;
 457         r.in.level = 0;
 458
 459         torture_assert_ntstatus_ok(tctx,
 460                 smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
 461                 "failed to enumerate jobs");
 462
 463         for (i=0; i < r.out.count; i++) {
 464
 465                 torture_assert(tctx,
 466                         test_netprintjobsetinfo_byid(tctx, cli, r.out.info[i].info0.JobID),
 467                         "failed to set job info");
 468         }
 469
 470         return true;
 471 }
 472
 473 static bool test_netprintjobenum(struct torture_context *tctx,
 474                                  struct smbcli_state *cli)
 475 {
 476         struct rap_NetPrintQEnum r;
 477         int i;
 478
 479         r.in.level = 5;
 480         r.in.bufsize = 8192;
 481
 482         torture_assert_ntstatus_ok(tctx,
 483                 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 484                 "failed to enum printq");
 485         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 486                 "failed to enum printq");
 487
 488         for (i=0; i < r.out.count; i++) {
 489
 490                 const char *printqname = r.out.info[i].info5.PrintQueueName;
 491
 492                 torture_assert(tctx,
 493                         test_netprintjobenum_one(tctx, cli, printqname),
 494                         "failed to enumerate printjobs on print queue");
 495         }
 496
 497         return true;
 498 }
 499
 500 static bool test_netprintjobgetinfo(struct torture_context *tctx,
 501                                     struct smbcli_state *cli)
 502 {
 503         struct rap_NetPrintQEnum r;
 504         int i;
 505
 506         r.in.level = 5;
 507         r.in.bufsize = 8192;
 508
 509         torture_assert_ntstatus_ok(tctx,
 510                 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 511                 "failed to enum printq");
 512         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 513                 "failed to enum printq");
 514
 515         for (i=0; i < r.out.count; i++) {
 516
 517                 const char *printqname = r.out.info[i].info5.PrintQueueName;
 518
 519                 torture_assert(tctx,
 520                         test_netprintjobgetinfo_byqueue(tctx, cli, printqname),
 521                         "failed to enumerate printjobs on print queue");
 522         }
 523
 524         return true;
 525 }
 526
 527 static bool test_netprintjobsetinfo(struct torture_context *tctx,
 528                                     struct smbcli_state *cli)
 529 {
 530         struct rap_NetPrintQEnum r;
 531         int i;
 532
 533         r.in.level = 5;
 534         r.in.bufsize = 8192;
 535
 536         torture_assert_ntstatus_ok(tctx,
 537                 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 538                 "failed to enum printq");
 539         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 540                 "failed to enum printq");
 541
 542         for (i=0; i < r.out.count; i++) {
 543
 544                 const char *printqname = r.out.info[i].info5.PrintQueueName;
 545
 546                 torture_assert(tctx,
 547                         test_netprintjobsetinfo_byqueue(tctx, cli, printqname),
 548                         "failed to set printjobs on print queue");
 549         }
 550
 551         return true;
 552 }
 553
 554 static bool test_netprintdestenum(struct torture_context *tctx,
 555                                   struct smbcli_state *cli)
 556 {
 557         struct rap_NetPrintDestEnum r;
 558         int i;
 559         uint16_t levels[] = { 0, 1, 2, 3 };
 560
 561         for (i=0; i < ARRAY_SIZE(levels); i++) {
 562
 563                 r.in.level = levels[i];
 564                 r.in.bufsize = 8192;
 565
 566                 torture_comment(tctx,
 567                         "Testing rap_NetPrintDestEnum level %d\n", r.in.level);
 568
 569                 torture_assert_ntstatus_ok(tctx,
 570                         smbcli_rap_netprintdestenum(cli->tree, tctx, &r),
 571                         "smbcli_rap_netprintdestenum failed");
 572         }
 573
 574         return true;
 575 }
 576
 577 static bool test_netprintdestgetinfo_bydest(struct torture_context *tctx,
 578                                             struct smbcli_state *cli,
 579                                             const char *PrintDestName)
 580 {
 581         struct rap_NetPrintDestGetInfo r;
 582         int i;
 583         uint16_t levels[] = { 0, 1, 2, 3 };
 584
 585         for (i=0; i < ARRAY_SIZE(levels); i++) {
 586
 587                 r.in.PrintDestName = PrintDestName;
 588                 r.in.level = levels[i];
 589                 r.in.bufsize = 8192;
 590
 591                 torture_comment(tctx,
 592                         "Testing rap_NetPrintDestGetInfo(%s) level %d\n", r.in.PrintDestName, r.in.level);
 593
 594                 torture_assert_ntstatus_ok(tctx,
 595                         smbcli_rap_netprintdestgetinfo(cli->tree, tctx, &r),
 596                         "smbcli_rap_netprintdestgetinfo failed");
 597         }
 598
 599         return true;
 600 }
 601
 602
 603 static bool test_netprintdestgetinfo(struct torture_context *tctx,
 604                                      struct smbcli_state *cli)
 605 {
 606         struct rap_NetPrintDestEnum r;
 607         int i;
 608
 609         r.in.level = 2;
 610         r.in.bufsize = 8192;
 611
 612         torture_comment(tctx,
 613                 "Testing rap_NetPrintDestEnum level %d\n", r.in.level);
 614
 615         torture_assert_ntstatus_ok(tctx,
 616                 smbcli_rap_netprintdestenum(cli->tree, tctx, &r),
 617                 "smbcli_rap_netprintdestenum failed");
 618
 619         for (i=0; i < r.out.count; i++) {
 620
 621                 torture_assert(tctx,
 622                         test_netprintdestgetinfo_bydest(tctx, cli, r.out.info[i].info2.PrinterName),
 623                         "failed to get printdest info");
 624
 625         }
 626
 627         return true;
 628 }
 629
 630 static bool test_rap_print(struct torture_context *tctx,
 631                            struct smbcli_state *cli)
 632 {
 633         struct rap_NetPrintQEnum r;
 634         int i;
 635
 636         r.in.level = 5;
 637         r.in.bufsize = 8192;
 638
 639         torture_assert_ntstatus_ok(tctx,
 640                 smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 641                 "failed to enum printq");
 642         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 643                 "failed to enum printq");
 644
 645         for (i=0; i < r.out.count; i++) {
 646
 647                 const char *printqname = r.out.info[i].info5.PrintQueueName;
 648                 struct smbcli_tree *res_queue = NULL;
 649                 uint16_t num_jobs;
 650                 union rap_printj_info *job_info;
 651                 int j;
 652
 653                 torture_assert(tctx,
 654                         test_netprintq_pause(tctx, cli, printqname),
 655                         "failed to set printjobs on print queue");
 656
 657                 torture_assert_ntstatus_ok(tctx,
 658                         torture_second_tcon(tctx, cli->session, printqname, &res_queue),
 659                         "failed to open 2nd connection");
 660
 661                 torture_assert(tctx,
 662                         print_printjob(tctx, res_queue),
 663                         "failed to print job on 2nd connection");
 664
 665                 talloc_free(res_queue);
 666
 667                 torture_assert(tctx,
 668                         test_netprintjobenum_args(tctx, cli, printqname, 1,
 669                         &num_jobs, &job_info),
 670                         "failed to enum printjobs on print queue");
 671
 672                 for (j=0; j < num_jobs; j++) {
 673
 674                         uint16_t job_id = job_info[j].info1.JobID;
 675
 676                         torture_assert(tctx,
 677                                 test_netprintjobgetinfo_byid(tctx, cli, job_id),
 678                                 "failed to getinfo on new printjob");
 679
 680                         torture_assert(tctx,
 681                                 test_netprintjob_delete(tctx, cli, job_id),
 682                                 "failed to delete job");
 683                 }
 684
 685                 torture_assert(tctx,
 686                         test_netprintq_resume(tctx, cli, printqname),
 687                         "failed to resume print queue");
 688
 689         }
 690
 691         return true;
 692 }
 693
 694 struct torture_suite *torture_rap_printing(TALLOC_CTX *mem_ctx)
 695 {
 696         struct torture_suite *suite = torture_suite_create(mem_ctx, "printing");
 697
 698         torture_suite_add_1smb_test(suite, "raw_print", test_raw_print);
 699         torture_suite_add_1smb_test(suite, "rap_print", test_rap_print);
 700         torture_suite_add_1smb_test(suite, "rap_printq_enum", test_netprintqenum);
 701         torture_suite_add_1smb_test(suite, "rap_printq_getinfo", test_netprintqgetinfo);
 702         torture_suite_add_1smb_test(suite, "rap_printq", test_netprintq);
 703         torture_suite_add_1smb_test(suite, "rap_printjob_enum", test_netprintjobenum);
 704         torture_suite_add_1smb_test(suite, "rap_printjob_getinfo", test_netprintjobgetinfo);
 705         torture_suite_add_1smb_test(suite, "rap_printjob_setinfo", test_netprintjobsetinfo);
 706         torture_suite_add_1smb_test(suite, "rap_printjob", test_netprintjob);
 707         torture_suite_add_1smb_test(suite, "rap_printdest_enum", test_netprintdestenum);
 708         torture_suite_add_1smb_test(suite, "rap_printdest_getinfo", test_netprintdestgetinfo);
 709
 710         return suite;
 711 }