← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gridengine/utopic

« back to all changes in this revision

Viewing changes to source/libs/spool/flatfile/test_flatfile_spool.c

  • Committer: Bazaar Package Importer
  • Author(s): Mark Hymers
  • Date: 2008-06-25 22:36:13 UTC
  • Revision ID: james.westby@ubuntu.com-20080625223613-tvd9xlhuoct9kyhm
Tags: upstream-6.2~beta2
Import upstream version 6.2~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/libs/spool/flatfile/test_flatfile_spool.c
 
1
/*___INFO__MARK_BEGIN__*/
 
2
/*************************************************************************
 
3
 * 
 
4
 *  The Contents of this file are made available subject to the terms of
 
5
 *  the Sun Industry Standards Source License Version 1.2
 
6
 * 
 
7
 *  Sun Microsystems Inc., March, 2001
 
8
 * 
 
9
 * 
 
10
 *  Sun Industry Standards Source License Version 1.2
 
11
 *  =================================================
 
12
 *  The contents of this file are subject to the Sun Industry Standards
 
13
 *  Source License Version 1.2 (the "License"); You may not use this file
 
14
 *  except in compliance with the License. You may obtain a copy of the
 
15
 *  License at http://gridengine.sunsource.net/Gridengine_SISSL_license.html
 
16
 * 
 
17
 *  Software provided under this License is provided on an "AS IS" basis,
 
18
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 
19
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 
20
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 
21
 *  See the License for the specific provisions governing your rights and
 
22
 *  obligations concerning the Software.
 
23
 * 
 
24
 *   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 
25
 * 
 
26
 *   Copyright: 2001 by Sun Microsystems, Inc.
 
27
 * 
 
28
 *   All Rights Reserved.
 
29
 * 
 
30
 ************************************************************************/
 
31
/*___INFO__MARK_END__*/
 
32
 
 
33
#include <stdio.h>
 
34
#include <stdlib.h>
 
35
#include <string.h>
 
36
#include <strings.h>
 
37
#include <unistd.h>
 
38
#include <ctype.h>
 
39
 
 
40
#include <sys/types.h>
 
41
#include <sys/wait.h>
 
42
 
 
43
#include "sge_unistd.h"
 
44
#include "sge_gdi.h"
 
45
#include "sig_handlers.h"
 
46
#include "commlib.h"
 
47
#include "sge_prog.h"
 
48
#include "msg_clients_common.h"
 
49
#include "msg_common.h"
 
50
#include "sge_answer.h"
 
51
#include "sge_mt_init.h"
 
52
#include "sge_log.h"
 
53
#include "cull/cull_multitype.h"
 
54
#include "cull/cull_list.h"
 
55
#include "rmon/sgermon.h"
 
56
#include "sgeobj/config.h"
 
57
#include "sgeobj/sge_all_listsL.h"
 
58
#include "sgeobj/sge_answer.h"
 
59
#include "sgeobj/sge_attrL.h"
 
60
#include "sgeobj/sge_calendarL.h"
 
61
#include "sgeobj/sge_centryL.h"
 
62
#include "sgeobj/sge_ckptL.h"
 
63
#include "sgeobj/sge_cqueueL.h"
 
64
#include "sgeobj/sge_hostL.h"
 
65
#include "sgeobj/sge_hrefL.h"
 
66
#include "sgeobj/sge_feature.h"
 
67
#include "sgeobj/sge_peL.h"
 
68
#include "sgeobj/sge_range.h"
 
69
#include "sgeobj/sge_strL.h"
 
70
#include "sgeobj/sge_sharetreeL.h"
 
71
#include "sgeobj/sge_subordinateL.h"
 
72
#include "sgeobj/sge_usageL.h"
 
73
#include "sgeobj/sge_userprj.h"
 
74
#include "sgeobj/sge_usersetL.h"
 
75
#include "sgeobj/sge_resource_quotaL.h"
 
76
#include "spool/sge_spooling_utilities.h"
 
77
#include "spool/flatfile/sge_flatfile.h"
 
78
#include "spool/flatfile/sge_flatfile_obj.h"
 
79
#include "spool/flatfile/sge_spooling_flatfile_scanner.h"
 
80
#include "uti/sge_prog.h"
 
81
#include "uti/sge_tmpnam.h"
 
82
 
 
83
#define allow_delete_time_modification
 
84
 
 
85
static int diff(const char *file1, const char *file2);
 
86
static int PE_test(void);
 
87
static int CAL_test(void);
 
88
static int CK_test(void);
 
89
static int STN_test(void);
 
90
static int CE_test(void);
 
91
static int CEL_test(void); 
 
92
static int UU_test(void);
 
93
static int PR_test(void);
 
94
static int US_test(void);
 
95
static int EH_test(void);
 
96
static int CQ_test(void);
 
97
static int SC_test(void);
 
98
static int QU_test(void);
 
99
static int HGRP_test(void);
 
100
#ifndef __SGE_NO_USERMAPPING__
 
101
static int CU_test(void);
 
102
#endif
 
103
static int CONF_test(void);
 
104
static int RQS_test(void);
 
105
static int AR_test(void);
 
106
 
 
107
#ifndef __SGE_NO_USERMAPPING__
 
108
const spool_flatfile_instr qconf_comma_braced_sfi = 
 
109
{
 
110
   NULL,
 
111
   true,
 
112
   false,
 
113
   false,
 
114
   true,
 
115
   false,
 
116
   false,
 
117
   true,
 
118
   ' ',
 
119
   '\n',
 
120
   '\0',
 
121
   '\0',
 
122
   '\0',
 
123
   &qconf_sub_name_value_comma_braced_sfi,
 
124
   { NoName, NoName, NoName }
 
125
};
 
126
#endif
 
127
 
 
128
typedef int (*func)(void);
 
129
 
 
130
/*
 
131
 * 
 
132
 */
 
133
int main(int argc, char** argv)
 
134
{
 
135
   const func test_array[] = {
 
136
                               PE_test,
 
137
                               CAL_test,
 
138
                               CK_test,
 
139
                               STN_test,
 
140
                               CE_test,
 
141
                               CEL_test,
 
142
                               UU_test,
 
143
                               PR_test,
 
144
                               EH_test,
 
145
                               US_test,
 
146
                               CQ_test,
 
147
                               SC_test,
 
148
                               QU_test,
 
149
                               HGRP_test,
 
150
                               CONF_test,
 
151
                               RQS_test,
 
152
                               AR_test,
 
153
#ifndef __SGE_NO_USERMAPPING__
 
154
                               CU_test,
 
155
#endif
 
156
                               NULL };
 
157
 
 
158
   DENTER_MAIN(TOP_LAYER, "test_ff_cl");   
 
159
 
 
160
   if (argc > 1) {
 
161
      int ret;
 
162
 
 
163
      while((ret = spool_lex())) {
 
164
         printf("line %3d: token %3d: %s\n", spool_line, ret, spool_text);
 
165
      }
 
166
   }
 
167
   else {
 
168
      int i = 0;
 
169
      sge_mt_init();
 
170
      lInit(nmv);
 
171
 
 
172
      while (test_array[i] != NULL) {
 
173
         if (test_array[i]() != 0) {
 
174
            SGE_EXIT(NULL, 1);
 
175
         }
 
176
         i++;
 
177
      }
 
178
   }
 
179
 
 
180
   DEXIT;
 
181
   return(EXIT_SUCCESS);
 
182
}
 
183
 
 
184
static int PE_test(void)
 
185
{
 
186
   int ret = 0;
 
187
   lList *lp = NULL;
 
188
   lList *lp2 = NULL;
 
189
   lList *alp = NULL;
 
190
   lListElem *ep = lCreateElem(PE_Type);
 
191
   lListElem *ep2 = NULL;
 
192
   lListElem *ep3 = NULL;
 
193
   const char *file1 = NULL;
 
194
   const char *file2 = NULL;
 
195
   
 
196
   /* Build a PE structure */
 
197
   
 
198
   lSetString(ep, PE_name, "Test_Name");
 
199
   lSetUlong(ep, PE_slots, 7);
 
200
   lSetString(ep, PE_start_proc_args, "start_args");
 
201
   lSetString(ep, PE_stop_proc_args, "stop_args");
 
202
   lSetString(ep, PE_allocation_rule, "allocation_rule");
 
203
   lSetBool(ep, PE_control_slaves, true);
 
204
   lSetBool(ep, PE_job_is_first_task, true);
 
205
   lSetString(ep, PE_urgency_slots, "urgency_slots");
 
206
#ifdef SGE_PQS_API
 
207
   lSetString(ep, PE_qsort_args, "qsort_args");
 
208
#endif
 
209
   
 
210
   lp = lCreateList("Resource Utilization List", RUE_Type);
 
211
   
 
212
   ep2 = lCreateElem(RUE_Type);
 
213
   lSetString(ep2, RUE_name, "Test_Name2");
 
214
   lSetDouble(ep2, RUE_utilized_now, 12.345);
 
215
   lAppendElem(lp, ep2);
 
216
   
 
217
   ep2 = lCreateElem(RUE_Type);
 
218
   lSetString(ep2, RUE_name, "Test_Name3");
 
219
   lSetDouble(ep2, RUE_utilized_now, 678.9);
 
220
   lAppendElem(lp, ep2);
 
221
   
 
222
   lSetList(ep, PE_resource_utilization, lp);
 
223
   
 
224
   lp = lCreateList("User_List", US_Type);
 
225
 
 
226
   ep2 = lCreateElem(US_Type);   
 
227
   lSetString(ep2, US_name, "First_User_List");
 
228
   lSetUlong(ep2, US_type, 101);
 
229
   lSetUlong(ep2, US_fshare, 303);
 
230
   lSetUlong(ep2, US_oticket, 505);
 
231
   lSetUlong(ep2, US_job_cnt, 707);
 
232
   lSetUlong(ep2, US_pending_job_cnt, 909);
 
233
   
 
234
   lp2 = lCreateList("User_Entry_List", UE_Type);
 
235
   
 
236
   ep3 = lCreateElem(UE_Type);
 
237
   lSetString(ep3, UE_name, "First_User");
 
238
   lAppendElem(lp2, ep3);
 
239
   
 
240
   ep3 = lCreateElem(UE_Type);
 
241
   lSetString(ep3, UE_name, "Second_User");
 
242
   lAppendElem(lp2, ep3);
 
243
 
 
244
   lSetList(ep2, US_entries, lp2);
 
245
   
 
246
   lAppendElem(lp, ep2);
 
247
   
 
248
   ep2 = lCreateElem(US_Type);   
 
249
   lSetString(ep2, US_name, "Second_User_List");
 
250
   lSetUlong(ep2, US_type, 202);
 
251
   lSetUlong(ep2, US_fshare, 404);
 
252
   lSetUlong(ep2, US_oticket, 606);
 
253
   lSetUlong(ep2, US_job_cnt, 808);
 
254
   lSetUlong(ep2, US_pending_job_cnt, 0);
 
255
   
 
256
   lp2 = lCreateList("User_Entry_List", UE_Type);
 
257
   
 
258
   ep3 = lCreateElem(UE_Type);
 
259
   lSetString(ep3, UE_name, "Third_User");
 
260
   lAppendElem(lp2, ep3);
 
261
   
 
262
   ep3 = lCreateElem(UE_Type);
 
263
   lSetString(ep3, UE_name, "Fourth_User");
 
264
   lAppendElem(lp2, ep3);
 
265
 
 
266
   lSetList(ep2, US_entries, lp2);
 
267
   
 
268
   lAppendElem(lp, ep2);
 
269
   
 
270
   lSetList(ep, PE_user_list, lp);
 
271
   
 
272
   lp = lCreateList("XUser_List", US_Type);
 
273
   
 
274
   ep2 = lCreateElem(US_Type);   
 
275
   lSetString(ep2, US_name, "First_XUser_List");
 
276
   lSetUlong(ep2, US_type, 101);
 
277
   lSetUlong(ep2, US_fshare, 303);
 
278
   lSetUlong(ep2, US_oticket, 505);
 
279
   lSetUlong(ep2, US_job_cnt, 707);
 
280
   lSetUlong(ep2, US_pending_job_cnt, 909);
 
281
   
 
282
   lp2 = lCreateList("XUser_Entry_List", UE_Type);
 
283
   
 
284
   ep3 = lCreateElem(UE_Type);
 
285
   lSetString(ep3, UE_name, "First_XUser");
 
286
   lAppendElem(lp2, ep3);
 
287
   
 
288
   ep3 = lCreateElem(UE_Type);
 
289
   lSetString(ep3, UE_name, "Second_XUser");
 
290
   lAppendElem(lp2, ep3);
 
291
 
 
292
   lSetList(ep2, US_entries, lp2);
 
293
   
 
294
   lAppendElem(lp, ep2);
 
295
   
 
296
   ep2 = lCreateElem(US_Type);   
 
297
   lSetString(ep2, US_name, "Second_XUser_List");
 
298
   lSetUlong(ep2, US_type, 202);
 
299
   lSetUlong(ep2, US_fshare, 404);
 
300
   lSetUlong(ep2, US_oticket, 606);
 
301
   lSetUlong(ep2, US_job_cnt, 808);
 
302
   lSetUlong(ep2, US_pending_job_cnt, 0);
 
303
   
 
304
   lp2 = lCreateList("XUser_Entry_List", UE_Type);
 
305
   
 
306
   ep3 = lCreateElem(UE_Type);
 
307
   lSetString(ep3, UE_name, "Third_XUser");
 
308
   lAppendElem(lp2, ep3);
 
309
   
 
310
   ep3 = lCreateElem(UE_Type);
 
311
   lSetString(ep3, UE_name, "Fourth_XUser");
 
312
   lAppendElem(lp2, ep3);
 
313
 
 
314
   lSetList(ep2, US_entries, lp2);
 
315
   
 
316
   lAppendElem(lp, ep2);
 
317
   
 
318
   lSetList(ep, PE_xuser_list, lp);
 
319
 
 
320
   printf("PE: spool\n");
 
321
   /* Write a PE file using classic spooling */
 
322
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
323
                                       PE_fields,
 
324
                                       &qconf_sfi,
 
325
                                       SP_DEST_TMP,
 
326
                                       SP_FORM_ASCII, 
 
327
                                       file1, false);
 
328
 
 
329
   /* Read a PE file using flatfile spooling */
 
330
   lFreeElem(&ep);
 
331
   ep = spool_flatfile_read_object(&alp, PE_Type, NULL,
 
332
                                   PE_fields, NULL, true, &qconf_sfi,
 
333
                                   SP_FORM_ASCII, NULL, file1);
 
334
 
 
335
   /* Write a PE file using flatfile spooling */
 
336
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
337
                                       PE_fields,
 
338
                                       &qconf_sfi,
 
339
                                       SP_DEST_TMP,
 
340
                                       SP_FORM_ASCII, 
 
341
                                       file2, false);
 
342
 
 
343
   lFreeElem(&ep);
 
344
   ret = diff(file1, file2);
 
345
   
 
346
   unlink(file1);
 
347
   unlink(file2);
 
348
   FREE(file1);
 
349
   FREE(file2);
 
350
 
 
351
   answer_list_output(&alp);   
 
352
 
 
353
   return ret;
 
354
}
 
355
 
 
356
static int CAL_test(void)
 
357
{
 
358
   int ret = 0;
 
359
   lListElem *ep = NULL;
 
360
   lList *alp = NULL;
 
361
   const char *file1 = NULL, *file2 = NULL;
 
362
   
 
363
   ep = lCreateElem(CAL_Type);   
 
364
   lSetString(ep, CAL_name, "Test_Name");
 
365
   lSetString(ep, CAL_year_calendar, "2004");
 
366
   lSetString(ep, CAL_week_calendar, "KW 05");
 
367
 
 
368
   printf("CAL: spool\n");
 
369
   /* Write a CAL file using classic spooling */
 
370
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
371
                                       CAL_fields,
 
372
                                       &qconf_sfi,
 
373
                                       SP_DEST_TMP,
 
374
                                       SP_FORM_ASCII, 
 
375
                                       file1, false);
 
376
   
 
377
   /* Read a CAL file using flatfile spooling */
 
378
   lFreeElem(&ep);
 
379
   ep = spool_flatfile_read_object(&alp, CAL_Type, NULL,
 
380
                                   CAL_fields, NULL, true, &qconf_sfi,
 
381
                                   SP_FORM_ASCII, NULL, file1);
 
382
   
 
383
   /* Write a CAL file using flatfile spooling */
 
384
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
385
                                       CAL_fields,
 
386
                                       &qconf_sfi,
 
387
                                       SP_DEST_TMP,
 
388
                                       SP_FORM_ASCII, 
 
389
                                       file2, false);
 
390
   
 
391
   lFreeElem(&ep);
 
392
   
 
393
   ret = diff(file1, file2);
 
394
   
 
395
   unlink(file1);
 
396
   unlink(file2);
 
397
   FREE(file1);
 
398
   FREE(file2);
 
399
   
 
400
   answer_list_output(&alp);   
 
401
   lFreeList(&alp);
 
402
   
 
403
   return ret;
 
404
}
 
405
 
 
406
static int CK_test(void)
 
407
{
 
408
   int ret = 0;
 
409
   lListElem *ep = NULL;
 
410
   lList *alp = NULL;
 
411
   const char *file1 = NULL, *file2 = NULL;
 
412
   
 
413
   ep = lCreateElem(CK_Type);
 
414
   lSetString(ep, CK_name, "Test_Name");
 
415
   lSetString(ep, CK_interface, "interface");
 
416
   lSetString(ep, CK_ckpt_command, "ckpt_command");
 
417
   lSetString(ep, CK_migr_command, "migr_command");
 
418
   lSetString(ep, CK_rest_command, "rest_command");
 
419
   lSetString(ep, CK_ckpt_dir, "ckpt_dir");
 
420
   lSetString(ep, CK_when, "when");
 
421
   lSetString(ep, CK_signal, "signal");
 
422
   lSetUlong(ep, CK_job_pid, 1313);
 
423
   lSetString(ep, CK_clean_command, "clean_command");
 
424
   
 
425
   printf("CK: spool\n");
 
426
   /* Write a CK file using classic spooling */
 
427
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
428
                                       CK_fields,
 
429
                                       &qconf_sfi,
 
430
                                       SP_DEST_TMP,
 
431
                                       SP_FORM_ASCII, 
 
432
                                       file1, false);
 
433
   
 
434
   /* Read a CK file using flatfile spooling */
 
435
   lFreeElem(&ep);
 
436
   ep = spool_flatfile_read_object(&alp, CK_Type, NULL,
 
437
                                   CK_fields, NULL, true, &qconf_sfi,
 
438
                                   SP_FORM_ASCII, NULL, file1);
 
439
      
 
440
   /* Write a CK file using flatfile spooling */
 
441
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
442
                                       CK_fields,
 
443
                                       &qconf_sfi,
 
444
                                       SP_DEST_TMP,
 
445
                                       SP_FORM_ASCII, 
 
446
                                       file2, false);
 
447
   
 
448
   lFreeElem(&ep);
 
449
   
 
450
   ret = diff(file1, file2);
 
451
   
 
452
   unlink(file1);
 
453
   unlink(file2);
 
454
   FREE(file1);
 
455
   FREE(file2);
 
456
   
 
457
   answer_list_output(&alp);   
 
458
 
 
459
   return ret;
 
460
}
 
461
 
 
462
static int STN_test() {
 
463
   int ret = 0;
 
464
   lListElem *ep = NULL;
 
465
   lListElem *ep2 = NULL;
 
466
   lListElem *ep3 = NULL;
 
467
   lList *lp = NULL;
 
468
   lList *lp2 = NULL;
 
469
   lList *alp = NULL;
 
470
   spooling_field *fields = NULL;
 
471
   const char *file1 = NULL;
 
472
   const char *file2 = NULL;
 
473
   
 
474
   ep = lCreateElem(STN_Type);
 
475
   lSetString(ep, STN_name, "Test_Name");
 
476
   lSetUlong(ep, STN_type, 1);
 
477
   lSetUlong(ep, STN_id, 0);
 
478
   lSetUlong(ep, STN_shares, 99);
 
479
   lSetUlong(ep, STN_version, 1);
 
480
   
 
481
   lp = lCreateList("Sharetree List", STN_Type);
 
482
   
 
483
   ep2 = lCreateElem(STN_Type);
 
484
   lSetString(ep2, STN_name, "Test_Name2");
 
485
   lSetUlong(ep2, STN_type, 1);
 
486
   lSetUlong(ep2, STN_id, 1);
 
487
   lSetUlong(ep2, STN_shares, 99);
 
488
   
 
489
   lp2 = lCreateList("Sharetree List", STN_Type);
 
490
   
 
491
   ep3 = lCreateElem(STN_Type);
 
492
   lSetString(ep3, STN_name, "Test_Name3");
 
493
   lSetUlong(ep3, STN_type, 1);
 
494
   lSetUlong(ep3, STN_id, 2);
 
495
   lSetUlong(ep3, STN_shares, 99);
 
496
   lSetList(ep3, STN_children, NULL);
 
497
   lAppendElem(lp2, ep3);
 
498
   
 
499
   ep3 = lCreateElem(STN_Type);
 
500
   lSetString(ep3, STN_name, "Test_Name4");
 
501
   lSetUlong(ep3, STN_type, 1);
 
502
   lSetUlong(ep3, STN_id, 4);
 
503
   lSetUlong(ep3, STN_shares, 99);
 
504
   lSetList(ep3, STN_children, NULL);
 
505
   lAppendElem(lp2, ep3);
 
506
   
 
507
   lSetList(ep2, STN_children, lp2);
 
508
   lAppendElem(lp, ep2);
 
509
   
 
510
   ep2 = lCreateElem(STN_Type);
 
511
   lSetString(ep2, STN_name, "Test_Name5");
 
512
   lSetUlong(ep2, STN_type, 1);
 
513
   lSetUlong(ep2, STN_id, 5);
 
514
   lSetUlong(ep2, STN_shares, 99);
 
515
   
 
516
   lp2 = lCreateList("Sharetree List", STN_Type);
 
517
   
 
518
   ep3 = lCreateElem(STN_Type);
 
519
   lSetString(ep3, STN_name, "Test_Name6");
 
520
   lSetUlong(ep3, STN_type, 1);
 
521
   lSetUlong(ep3, STN_id, 7);
 
522
   lSetUlong(ep3, STN_shares, 99);
 
523
   lSetList(ep3, STN_children, NULL);
 
524
   lAppendElem(lp2, ep3);
 
525
   
 
526
   lSetList(ep2, STN_children, lp2);
 
527
   lAppendElem(lp, ep2);
 
528
   
 
529
   lSetList(ep, STN_children, lp);
 
530
 
 
531
   fields = sge_build_STN_field_list(true, true);
 
532
   
 
533
   printf("STN: spool\n");
 
534
   /* Write a STN file using classic spooling */
 
535
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
536
                                       fields,
 
537
                                       &qconf_name_value_list_sfi,
 
538
                                       SP_DEST_TMP,
 
539
                                       SP_FORM_ASCII, 
 
540
                                       file1, false);
 
541
 
 
542
   /* Read a STN file using flatfile spooling */
 
543
   lFreeElem(&ep);
 
544
   ep = spool_flatfile_read_object(&alp, STN_Type, NULL,
 
545
                                   fields, NULL, true, &qconf_name_value_list_sfi,
 
546
                                   SP_FORM_ASCII, NULL, file1);
 
547
   
 
548
   /* Write a STN file using flatfile spooling */
 
549
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
550
                                       fields,
 
551
                                       &qconf_name_value_list_sfi,
 
552
                                       SP_DEST_TMP,
 
553
                                       SP_FORM_ASCII, 
 
554
                                       file2, false);
 
555
   lFreeElem(&ep);
 
556
 
 
557
   
 
558
   ret = diff(file1, file2);
 
559
   
 
560
   unlink(file1);
 
561
   unlink(file2);
 
562
   FREE(file1);
 
563
   FREE(file2);
 
564
 
 
565
   FREE(fields);
 
566
 
 
567
   answer_list_output(&alp);   
 
568
   
 
569
   return ret;
 
570
}
 
571
 
 
572
static int CE_test(void)
 
573
{
 
574
   int ret = 0;
 
575
   lListElem *ep = NULL;
 
576
   lList *alp = NULL;
 
577
   const char *file1 = NULL, *file2 = NULL;
 
578
   
 
579
   ep = lCreateElem(CE_Type);
 
580
   lSetString(ep, CE_name, "Test_Name");
 
581
   lSetString(ep, CE_shortcut, "shortcut");
 
582
   lSetUlong(ep, CE_valtype, 1);
 
583
   lSetUlong(ep, CE_relop, 5);
 
584
   lSetBool(ep, CE_consumable, true);
 
585
   lSetString(ep, CE_default, "10");
 
586
   lSetUlong(ep, CE_requestable, REQU_NO);
 
587
   lSetString(ep, CE_urgency_weight, "20");
 
588
   
 
589
   printf("CE: spool\n");
 
590
   /* Write a CE file using classic spooling */
 
591
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
592
                                       CE_fields,
 
593
                                       &qconf_sfi,
 
594
                                       SP_DEST_TMP,
 
595
                                       SP_FORM_ASCII, 
 
596
                                       file1, false);
 
597
   
 
598
   /* Read a CE file using flatfile spooling */
 
599
   lFreeElem(&ep);
 
600
   ep = spool_flatfile_read_object(&alp, CE_Type, NULL,
 
601
                                   CE_fields, NULL, true, &qconf_sfi,
 
602
                                   SP_FORM_ASCII, NULL, file1);
 
603
         
 
604
   /* Write a CE file using flatfile spooling */
 
605
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
606
                                       CE_fields,
 
607
                                       &qconf_sfi,
 
608
                                       SP_DEST_TMP,
 
609
                                       SP_FORM_ASCII, 
 
610
                                       file2, false);
 
611
 
 
612
   lFreeElem(&ep);
 
613
   
 
614
   ret = diff(file1, file2);
 
615
   
 
616
   unlink(file1);
 
617
   unlink(file2);
 
618
   FREE(file1);
 
619
   FREE(file2);
 
620
   
 
621
   answer_list_output(&alp);   
 
622
   
 
623
   return ret;
 
624
}
 
625
 
 
626
static int CEL_test(void)
 
627
{
 
628
   int ret = 0;
 
629
   lListElem *ep = NULL;
 
630
   lList *lp = NULL;
 
631
   lList *alp = NULL;
 
632
   const char *file1 = NULL;
 
633
   const char *file2 = NULL;
 
634
   
 
635
   lp = lCreateList("Complex List", CE_Type);
 
636
   
 
637
   ep = lCreateElem(CE_Type);
 
638
   lSetString(ep, CE_name, "Test_Name1");
 
639
   lSetString(ep, CE_shortcut, "tn1");
 
640
   lSetUlong(ep, CE_valtype, 1);
 
641
   lSetUlong(ep, CE_relop, 5);
 
642
   lSetBool(ep, CE_consumable, true);
 
643
   lSetString(ep, CE_default, "15");
 
644
   lSetUlong(ep, CE_requestable, REQU_NO);
 
645
   lSetString(ep, CE_urgency_weight, "25");
 
646
   lAppendElem(lp, ep);
 
647
   
 
648
   ep = lCreateElem(CE_Type);
 
649
   lSetString(ep, CE_name, "Test_Name2");
 
650
   lSetString(ep, CE_shortcut, "tn2");
 
651
   lSetUlong(ep, CE_valtype, 1);
 
652
   lSetUlong(ep, CE_relop, 5);
 
653
   lSetBool(ep, CE_consumable, false);
 
654
   lSetString(ep, CE_default, "15");
 
655
   lSetUlong(ep, CE_requestable, REQU_YES);
 
656
   lSetString(ep, CE_urgency_weight, "25");
 
657
   lAppendElem(lp, ep);
 
658
   
 
659
   spool_flatfile_align_list(&alp,(const lList *)lp, CE_fields, 0);
 
660
   
 
661
   printf("CEL: spool\n");
 
662
   /* Write a CEL file using classic spooling */
 
663
   file1 = spool_flatfile_write_list(&alp, lp,
 
664
                                     CE_fields,
 
665
                                     &qconf_ce_list_sfi,
 
666
                                     SP_DEST_TMP, 
 
667
                                     SP_FORM_ASCII, 
 
668
                                     file1, false);
 
669
   
 
670
   /* Read a CE file using flatfile spooling */
 
671
   lFreeList(&lp);
 
672
   lp = spool_flatfile_read_list(&alp, CE_Type,
 
673
                                   CE_fields, NULL, true, &qconf_ce_list_sfi,
 
674
                                   SP_FORM_ASCII, NULL, file1);
 
675
   
 
676
   /* Write a CEL file using flatfile spooling */
 
677
   file2 = spool_flatfile_write_list(&alp, lp,
 
678
                                     CE_fields,
 
679
                                     &qconf_ce_list_sfi,
 
680
                                     SP_DEST_TMP, 
 
681
                                     SP_FORM_ASCII, 
 
682
                                     NULL, false);
 
683
   lFreeList(&lp);
 
684
 
 
685
   
 
686
   ret = diff(file1, file2);
 
687
   
 
688
   unlink(file1);
 
689
   unlink(file2);
 
690
   FREE(file1);
 
691
   FREE(file2);
 
692
   
 
693
   answer_list_output(&alp);   
 
694
   
 
695
   return ret;
 
696
}
 
697
 
 
698
static int diff(const char *file1, const char *file2)
 
699
{
 
700
   int ret = 1;
 
701
   char **argv =(char **)malloc(sizeof(char *) * 4);
 
702
   char *path = "/usr/bin/diff";
 
703
 
 
704
   if(file1 == NULL || file2 == NULL) {
 
705
      printf("file pointer is <NULL>\n");
 
706
      SGE_EXIT(NULL, 1);
 
707
   }
 
708
   
 
709
   if(!fork()) {
 
710
      argv[0] = path;
 
711
      argv[1] = (char *)file1;
 
712
      argv[2] = (char *)file2;
 
713
      argv[3] = NULL;
 
714
      
 
715
      execv(path, argv);
 
716
      /* if execv return an error occured */
 
717
   }
 
718
   else {
 
719
      int stat_loc = 0;
 
720
      
 
721
      wait(&stat_loc);
 
722
      if (WIFEXITED(stat_loc)) {
 
723
         ret = WEXITSTATUS(stat_loc);
 
724
      }
 
725
   }
 
726
   
 
727
   FREE(argv);
 
728
   return ret;
 
729
}
 
730
 
 
731
static lList *buildUsageList(void) {   
 
732
   lList *lp = NULL;
 
733
   lListElem *ep2 = NULL;
 
734
 
 
735
   lp = lCreateList("Usage List", UA_Type);
 
736
   
 
737
   ep2 = lCreateElem(UA_Type);
 
738
   lSetString(ep2, UA_name, "Test_Name2");
 
739
   lSetDouble(ep2, UA_value, 11.22);
 
740
   lAppendElem(lp, ep2);
 
741
   
 
742
   ep2 = lCreateElem(UA_Type);
 
743
   lSetString(ep2, UA_name, "Test_Name3");
 
744
   lSetDouble(ep2, UA_value, 33.44);
 
745
   lAppendElem(lp, ep2);
 
746
   
 
747
   ep2 = lCreateElem(UA_Type);
 
748
   lSetString(ep2, UA_name, "Test_Name4");
 
749
   lSetDouble(ep2, UA_value, 55.66);
 
750
   lAppendElem(lp, ep2);
 
751
 
 
752
   return lp;
 
753
}
 
754
 
 
755
static lList *buildLTUsageList(void) {
 
756
   lList *lp = NULL;
 
757
   lListElem *ep2 = NULL;
 
758
 
 
759
   lp = lCreateList("LT Usage List", UA_Type);
 
760
   
 
761
   ep2 = lCreateElem(UA_Type);
 
762
   lSetString(ep2, UA_name, "Test_Name5");
 
763
   lSetDouble(ep2, UA_value, 11.22);
 
764
   lAppendElem(lp, ep2);
 
765
   
 
766
   ep2 = lCreateElem(UA_Type);
 
767
   lSetString(ep2, UA_name, "Test_Name6");
 
768
   lSetDouble(ep2, UA_value, 33.44);
 
769
   lAppendElem(lp, ep2);
 
770
   
 
771
   ep2 = lCreateElem(UA_Type);
 
772
   lSetString(ep2, UA_name, "Test_Name7");
 
773
   lSetDouble(ep2, UA_value, 55.66);
 
774
   lAppendElem(lp, ep2);
 
775
 
 
776
   return lp;
 
777
}      
 
778
 
 
779
static lList *buildProjectList(void) {
 
780
   lList *lp = NULL;
 
781
   lList *lp2 = NULL;
 
782
   lListElem *ep2 = NULL;
 
783
   lListElem *ep3 = NULL;
 
784
 
 
785
   lp = lCreateList("Project List", UPP_Type);
 
786
   
 
787
   ep2 = lCreateElem(UPP_Type);
 
788
   lSetString(ep2, UPP_name, "Test_Name8");
 
789
   
 
790
   lp2 = lCreateList("Usage List", UA_Type);
 
791
   
 
792
   ep3 = lCreateElem(UA_Type);
 
793
   lSetString(ep3, UA_name, "Test_Name9");
 
794
   lSetDouble(ep3, UA_value, 11.22);
 
795
   lAppendElem(lp2, ep3);
 
796
   
 
797
   ep3 = lCreateElem(UA_Type);
 
798
   lSetString(ep3, UA_name, "Test_Name10");
 
799
   lSetDouble(ep3, UA_value, 33.44);
 
800
   lAppendElem(lp2, ep3);
 
801
   
 
802
   ep3 = lCreateElem(UA_Type);
 
803
   lSetString(ep3, UA_name, "Test_Name11");
 
804
   lSetDouble(ep3, UA_value, 55.66);
 
805
   lAppendElem(lp2, ep3);
 
806
      
 
807
   lSetList(ep2, UPP_usage, lp2);
 
808
   
 
809
   lp2 = lCreateList("LT Usage List", UA_Type);
 
810
   
 
811
   ep3 = lCreateElem(UA_Type);
 
812
   lSetString(ep3, UA_name, "Test_Name12");
 
813
   lSetDouble(ep3, UA_value, 11.22);
 
814
   lAppendElem(lp2, ep3);
 
815
   
 
816
   ep3 = lCreateElem(UA_Type);
 
817
   lSetString(ep3, UA_name, "Test_Name13");
 
818
   lSetDouble(ep3, UA_value, 33.44);
 
819
   lAppendElem(lp2, ep3);
 
820
   
 
821
   ep3 = lCreateElem(UA_Type);
 
822
   lSetString(ep3, UA_name, "Test_Name14");
 
823
   lSetDouble(ep3, UA_value, 55.66);
 
824
   lAppendElem(lp2, ep3);
 
825
      
 
826
   lSetList(ep2, UPP_long_term_usage, lp2);
 
827
   lAppendElem(lp, ep2);
 
828
   
 
829
   ep2 = lCreateElem(UPP_Type);
 
830
   lSetString(ep2, UPP_name, "Test_Name15");
 
831
   
 
832
   lp2 = lCreateList("Usage List", UA_Type);
 
833
   
 
834
   ep3 = lCreateElem(UA_Type);
 
835
   lSetString(ep3, UA_name, "Test_Name16");
 
836
   lSetDouble(ep3, UA_value, 11.22);
 
837
   lAppendElem(lp2, ep3);
 
838
   
 
839
   ep3 = lCreateElem(UA_Type);
 
840
   lSetString(ep3, UA_name, "Test_Name17");
 
841
   lSetDouble(ep3, UA_value, 33.44);
 
842
   lAppendElem(lp2, ep3);
 
843
   
 
844
   ep3 = lCreateElem(UA_Type);
 
845
   lSetString(ep3, UA_name, "Test_Name18");
 
846
   lSetDouble(ep3, UA_value, 55.66);
 
847
   lAppendElem(lp2, ep3);
 
848
      
 
849
   lSetList(ep2, UPP_usage, lp2);
 
850
   
 
851
   lp2 = lCreateList("LT Usage List", UA_Type);
 
852
   
 
853
   ep3 = lCreateElem(UA_Type);
 
854
   lSetString(ep3, UA_name, "Test_Name19");
 
855
   lSetDouble(ep3, UA_value, 11.22);
 
856
   lAppendElem(lp2, ep3);
 
857
   
 
858
   ep3 = lCreateElem(UA_Type);
 
859
   lSetString(ep3, UA_name, "Test_Name20");
 
860
   lSetDouble(ep3, UA_value, 33.44);
 
861
   lAppendElem(lp2, ep3);
 
862
   
 
863
   ep3 = lCreateElem(UA_Type);
 
864
   lSetString(ep3, UA_name, "Test_Name21");
 
865
   lSetDouble(ep3, UA_value, 55.66);
 
866
   lAppendElem(lp2, ep3);
 
867
      
 
868
   lSetList(ep2, UPP_long_term_usage, lp2);
 
869
   lAppendElem(lp, ep2);
 
870
 
 
871
   return lp;
 
872
}
 
873
 
 
874
static lList *buildDebitedUsageList(void) {
 
875
   lList *lp = NULL;
 
876
   lList *lp2 = NULL;
 
877
   lListElem *ep = NULL;
 
878
   lListElem *ep1 = NULL;
 
879
 
 
880
   lp = lCreateList("Debited Usage List", UPU_Type);
 
881
   
 
882
   ep = lCreateElem(UPU_Type);
 
883
   lSetUlong(ep, UPU_job_number, 13579);
 
884
   
 
885
   lp2 = lCreateList("Old Usage List", UA_Type);
 
886
   
 
887
   ep1 = lCreateElem(UA_Type);
 
888
   lSetString(ep1, UA_name, "Test_Name26");
 
889
   lSetDouble(ep1, UA_value, 11.22);
 
890
   lAppendElem(lp2, ep1);
 
891
   
 
892
   ep1 = lCreateElem(UA_Type);
 
893
   lSetString(ep1, UA_name, "Test_Name27");
 
894
   lSetDouble(ep1, UA_value, 33.44);
 
895
   lAppendElem(lp2, ep1);
 
896
   
 
897
   ep1 = lCreateElem(UA_Type);
 
898
   lSetString(ep1, UA_name, "Test_Name28");
 
899
   lSetDouble(ep1, UA_value, 55.66);
 
900
   lAppendElem(lp2, ep1);
 
901
      
 
902
   lSetList(ep, UPU_old_usage_list, lp2);
 
903
   lAppendElem(lp, ep);
 
904
   
 
905
   ep = lCreateElem(UPU_Type);
 
906
   lSetUlong(ep, UPU_job_number, 97531);
 
907
   
 
908
   lp2 = lCreateList("Old Usage List", UA_Type);
 
909
   
 
910
   ep1 = lCreateElem(UA_Type);
 
911
   lSetString(ep1, UA_name, "Test_Name29");
 
912
   lSetDouble(ep1, UA_value, 11.22);
 
913
   lAppendElem(lp2, ep1);
 
914
   
 
915
   ep1 = lCreateElem(UA_Type);
 
916
   lSetString(ep1, UA_name, "Test_Name30");
 
917
   lSetDouble(ep1, UA_value, 33.44);
 
918
   lAppendElem(lp2, ep1);
 
919
   
 
920
   ep1 = lCreateElem(UA_Type);
 
921
   lSetString(ep1, UA_name, "Test_Name31");
 
922
   lSetDouble(ep1, UA_value, 55.66);
 
923
   lAppendElem(lp2, ep1);
 
924
      
 
925
   lSetList(ep, UPU_old_usage_list, lp2);
 
926
   lAppendElem(lp, ep);
 
927
 
 
928
   return lp;
 
929
}   
 
930
 
 
931
static lList *buildACLList(void) {
 
932
   lList *lp = NULL;
 
933
   lListElem *ep2 = NULL;
 
934
 
 
935
   lp = lCreateList("ACL List", US_Type);
 
936
   
 
937
   ep2 = lCreateElem(US_Type);
 
938
   lSetString(ep2, US_name, "Test_Name22");
 
939
   lAppendElem(lp, ep2);
 
940
   
 
941
   ep2 = lCreateElem(US_Type);
 
942
   lSetString(ep2, US_name, "Test_Name23");
 
943
   lAppendElem(lp, ep2);
 
944
 
 
945
   return lp;
 
946
}   
 
947
   
 
948
static lList *buildXACLList(void) {
 
949
   lList *lp = NULL;
 
950
   lListElem *ep2 = NULL;
 
951
 
 
952
   lp = lCreateList("XACL List", US_Type);
 
953
   
 
954
   ep2 = lCreateElem(US_Type);
 
955
   lSetString(ep2, US_name, "Test_Name24");
 
956
   lAppendElem(lp, ep2);
 
957
   
 
958
   ep2 = lCreateElem(US_Type);
 
959
   lSetString(ep2, US_name, "Test_Name25");
 
960
   lAppendElem(lp, ep2);
 
961
 
 
962
   return lp;
 
963
}   
 
964
 
 
965
static int UU_test(void) {
 
966
   int ret = 0;
 
967
   lListElem *user = NULL;
 
968
   lList *lp = NULL;
 
969
   lList *alp = NULL;
 
970
   spooling_field *fields = NULL;
 
971
   const char *file1 = NULL;
 
972
   const char *file2 = NULL;
 
973
   
 
974
   user = lCreateElem(UU_Type);
 
975
   lSetString(user, UU_name, "Test_Name");
 
976
   lSetUlong(user, UU_oticket, 100);
 
977
   lSetUlong(user, UU_fshare, 50);
 
978
   lSetUlong(user, UU_delete_time, 123456789);
 
979
   lSetString(user, UU_default_project, "default_project");
 
980
 
 
981
   lSetUlong(user, UU_usage_time_stamp, 987654321);
 
982
 
 
983
   lp = buildUsageList();
 
984
   lSetList(user, UU_usage, lp);
 
985
   
 
986
   lp = buildLTUsageList();
 
987
   lSetList(user, UU_long_term_usage, lp);
 
988
   
 
989
   lp = buildProjectList();
 
990
   lSetList(user, UU_project, lp);
 
991
   
 
992
   lp = buildDebitedUsageList();
 
993
   lSetList(user, UU_debited_job_usage, lp);
 
994
 
 
995
   printf("UU: spool\n");
 
996
 
 
997
   fields = sge_build_UU_field_list(true);
 
998
 
 
999
   /* Write a UU file using flatfile spooling */
 
1000
   file1 = spool_flatfile_write_object(&alp, user, false,
 
1001
                                     fields,
 
1002
                                     &qconf_sfi,
 
1003
                                     SP_DEST_TMP,
 
1004
                                     SP_FORM_ASCII, 
 
1005
                                     file1, false);
 
1006
   lFreeElem(&user);
 
1007
   user = spool_flatfile_read_object(&alp, UU_Type, NULL,
 
1008
                                   fields, NULL, true, &qconf_sfi,
 
1009
                                   SP_FORM_ASCII, NULL, file1);
 
1010
   file2 = spool_flatfile_write_object(&alp, user, false,
 
1011
                                     fields,
 
1012
                                     &qconf_sfi,
 
1013
                                     SP_DEST_TMP,
 
1014
                                     SP_FORM_ASCII, 
 
1015
                                     file2, false);
 
1016
   lFreeElem(&user);
 
1017
   ret = diff(file1, file2);
 
1018
   
 
1019
   unlink(file1);
 
1020
   unlink(file2);
 
1021
   FREE(file1);
 
1022
   FREE(file2);
 
1023
 
 
1024
   FREE(fields);
 
1025
   
 
1026
   answer_list_output(&alp);   
 
1027
   
 
1028
   return ret;
 
1029
}
 
1030
 
 
1031
static int PR_test(void) {
 
1032
   int ret = 0;
 
1033
   lListElem *prj = NULL;
 
1034
   lList *lp = NULL;
 
1035
   lList *alp = NULL;
 
1036
   spooling_field *fields = NULL;
 
1037
   const char *file1 = NULL;
 
1038
   const char *file2 = NULL;
 
1039
   
 
1040
   prj = lCreateElem(PR_Type);
 
1041
   lSetString(prj, PR_name, "Test_Name");
 
1042
   lSetUlong(prj, PR_oticket, 100);
 
1043
   lSetUlong(prj, PR_fshare, 50);
 
1044
   lSetUlong(prj, PR_usage_time_stamp, 987654321);
 
1045
 
 
1046
   lp = buildUsageList();
 
1047
   lSetList(prj, PR_usage, lp);
 
1048
   
 
1049
   lp = buildLTUsageList();
 
1050
   lSetList(prj, PR_long_term_usage, lp);
 
1051
   
 
1052
   lp = buildProjectList();
 
1053
   lSetList(prj, PR_project, lp);
 
1054
   
 
1055
   lp = buildACLList();
 
1056
   lSetList(prj, PR_acl, lp);
 
1057
   
 
1058
   lp = buildXACLList();
 
1059
   lSetList(prj, PR_xacl, lp);
 
1060
   
 
1061
   lp = buildDebitedUsageList();
 
1062
   lSetList(prj, PR_debited_job_usage, lp);
 
1063
 
 
1064
   fields = sge_build_PR_field_list(true);
 
1065
 
 
1066
   printf("PR: spool\n");
 
1067
   /* Write a PR file using classic spooling */
 
1068
   file1 = spool_flatfile_write_object(&alp, prj, false,
 
1069
                                     fields,
 
1070
                                     &qconf_sfi,
 
1071
                                     SP_DEST_TMP,
 
1072
                                     SP_FORM_ASCII, 
 
1073
                                     file1, false);
 
1074
   
 
1075
   /* Read a PR file using flatfile spooling */
 
1076
   lFreeElem(&prj);
 
1077
   prj = spool_flatfile_read_object(&alp, PR_Type, NULL,
 
1078
                                   fields, NULL, true, &qconf_sfi,
 
1079
                                   SP_FORM_ASCII, NULL, file1);
 
1080
         
 
1081
   /* Write a PR file using flatfile spooling */
 
1082
   file2 = spool_flatfile_write_object(&alp, prj, false,
 
1083
                                     fields,
 
1084
                                     &qconf_sfi,
 
1085
                                     SP_DEST_TMP,
 
1086
                                     SP_FORM_ASCII, 
 
1087
                                     file2, false);
 
1088
 
 
1089
   lFreeElem(&prj);
 
1090
   answer_list_output(&alp);   
 
1091
   
 
1092
   ret = diff(file1, file2);
 
1093
   
 
1094
   unlink(file1);
 
1095
   unlink(file2);
 
1096
   FREE(file1);
 
1097
   FREE(file2);
 
1098
   FREE(fields);
 
1099
   
 
1100
   answer_list_output(&alp);   
 
1101
   
 
1102
   return ret;
 
1103
}
 
1104
 
 
1105
static int US_test(void)
 
1106
{
 
1107
   int ret = 0;
 
1108
   lListElem *ep = NULL;
 
1109
   lListElem *ep2 = NULL;
 
1110
   lList *lp = NULL;
 
1111
   lList *alp = NULL;
 
1112
   const char *file1 = NULL;
 
1113
   const char *file2 = NULL;
 
1114
   
 
1115
   ep = lCreateElem(US_Type);
 
1116
   lSetString(ep, US_name, "Test_Name");
 
1117
   lSetUlong(ep, US_type, 1);
 
1118
   lSetUlong(ep, US_fshare, 10);
 
1119
   lSetUlong(ep, US_oticket, 100);
 
1120
   
 
1121
   lp = lCreateList("Entry List", UE_Type);
 
1122
   
 
1123
   ep2 = lCreateElem(UE_Type);
 
1124
   lSetString(ep2, UE_name, "Test_Name2");
 
1125
   lAppendElem(lp, ep2);
 
1126
   
 
1127
   ep2 = lCreateElem(UE_Type);
 
1128
   lSetString(ep2, UE_name, "Test_Name3");
 
1129
   lAppendElem(lp, ep2);
 
1130
   
 
1131
   ep2 = lCreateElem(UE_Type);
 
1132
   lSetString(ep2, UE_name, "Test_Name4");
 
1133
   lAppendElem(lp, ep2);
 
1134
   
 
1135
   lSetList(ep, US_entries, lp);
 
1136
   
 
1137
   printf("US: NO ARGS\n");
 
1138
   /* Write a US file using classic spooling */
 
1139
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
1140
                                       US_fields,
 
1141
                                       &qconf_param_sfi,
 
1142
                                       SP_DEST_TMP,
 
1143
                                       SP_FORM_ASCII, 
 
1144
                                       file1, false);
 
1145
 
 
1146
   /* Read a US file using flatfile spooling */
 
1147
   lFreeElem(&ep);
 
1148
   ep = spool_flatfile_read_object(&alp, US_Type, NULL,
 
1149
                                   US_fields, NULL, true, &qconf_param_sfi,
 
1150
                                   SP_FORM_ASCII, NULL, file1);
 
1151
      
 
1152
   /* Write a US file using flatfile spooling */
 
1153
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
1154
                                       US_fields,
 
1155
                                       &qconf_param_sfi,
 
1156
                                       SP_DEST_TMP,
 
1157
                                       SP_FORM_ASCII, 
 
1158
                                       file2, false);
 
1159
   
 
1160
   
 
1161
   ret = diff(file1, file2);
 
1162
   
 
1163
   unlink(file1);
 
1164
   unlink(file2);
 
1165
   FREE(file1);
 
1166
   FREE(file2);
 
1167
   
 
1168
   lFreeElem(&ep);
 
1169
   
 
1170
   answer_list_output(&alp);   
 
1171
   
 
1172
   return ret;
 
1173
}
 
1174
 
 
1175
static int EH_test(void)
 
1176
{
 
1177
   int ret = 0;
 
1178
   lListElem *ep = NULL;
 
1179
   lListElem *ep2 = NULL;
 
1180
   lList *lp = NULL;
 
1181
   lList *alp = NULL;
 
1182
   spooling_field *fields = NULL;
 
1183
   const char *file1 = NULL;
 
1184
   const char *file2 = NULL;
 
1185
   
 
1186
   ep = lCreateElem(EH_Type);
 
1187
   lSetHost(ep, EH_name, "Test_Name");
 
1188
   
 
1189
   lp = lCreateList("Load Scaling List", HS_Type);
 
1190
   
 
1191
   ep2 = lCreateElem(HS_Type);
 
1192
   lSetString(ep2, HS_name, "Test_Name2");
 
1193
   lSetDouble(ep2, HS_value, 1234.567);
 
1194
   lAppendElem(lp, ep2);
 
1195
   
 
1196
   ep2 = lCreateElem(HS_Type);
 
1197
   lSetString(ep2, HS_name, "Test_Name3");
 
1198
   lSetDouble(ep2, HS_value, 6.7);
 
1199
   lAppendElem(lp, ep2);
 
1200
   
 
1201
   lSetList(ep, EH_scaling_list, lp);
 
1202
   
 
1203
   lp = lCreateList("Consumable Config List", CE_Type);
 
1204
   
 
1205
   ep2 = lCreateElem(CE_Type);
 
1206
   lSetString(ep2, CE_name, "Test_Name4");
 
1207
   lSetString(ep2, CE_shortcut, "shortcut");
 
1208
   lSetUlong(ep2, CE_valtype, 1);
 
1209
   lSetUlong(ep2, CE_relop, 5);
 
1210
   lSetBool(ep2, CE_consumable, true);
 
1211
   lSetString(ep2, CE_default, "15");
 
1212
   lSetUlong(ep2, CE_requestable, REQU_NO);
 
1213
   lSetString(ep2, CE_urgency_weight, "25");
 
1214
   lSetString(ep2, CE_stringval, "stringval");
 
1215
   lAppendElem(lp, ep2);
 
1216
   
 
1217
   ep2 = lCreateElem(CE_Type);
 
1218
   lSetString(ep2, CE_name, "Test_Name5");
 
1219
   lSetString(ep2, CE_shortcut, "shortcut");
 
1220
   lSetUlong(ep2, CE_valtype, 1);
 
1221
   lSetUlong(ep2, CE_relop, 5);
 
1222
   lSetBool(ep2, CE_consumable, false);
 
1223
   lSetString(ep2, CE_default, "15");
 
1224
   lSetUlong(ep2, CE_requestable, REQU_YES);
 
1225
   lSetString(ep2, CE_urgency_weight, "25");
 
1226
   lSetDouble(ep2, CE_doubleval, 6969.9696);
 
1227
   lAppendElem(lp, ep2);
 
1228
   
 
1229
   lSetList(ep, EH_consumable_config_list, lp);
 
1230
   
 
1231
   lp = lCreateList("Actual Complex Values List", CE_Type);
 
1232
 
 
1233
   ep2 = lCreateElem(CE_Type);
 
1234
   lSetString(ep2, CE_name, "Test_Name6");
 
1235
   lSetString(ep2, CE_shortcut, "shortcut");
 
1236
   lSetUlong(ep2, CE_valtype, 1);
 
1237
   lSetUlong(ep2, CE_relop, 5);
 
1238
   lSetBool(ep2, CE_consumable, true);
 
1239
   lSetString(ep2, CE_default, "15");
 
1240
   lSetUlong(ep2, CE_requestable, REQU_NO);
 
1241
   lSetString(ep2, CE_urgency_weight, "25");
 
1242
   lSetString(ep2, CE_stringval, "stringval");
 
1243
   lAppendElem(lp, ep2);
 
1244
   
 
1245
   ep2 = lCreateElem(CE_Type);
 
1246
   lSetString(ep2, CE_name, "Test_Name7");
 
1247
   lSetString(ep2, CE_shortcut, "shortcut");
 
1248
   lSetUlong(ep2, CE_valtype, 1);
 
1249
   lSetUlong(ep2, CE_relop, 5);
 
1250
   lSetBool(ep2, CE_consumable, false);
 
1251
   lSetString(ep2, CE_default, "15");
 
1252
   lSetUlong(ep2, CE_requestable, REQU_YES);
 
1253
   lSetString(ep2, CE_urgency_weight, "25");
 
1254
   lSetDouble(ep2, CE_doubleval, 6969.9696);
 
1255
   lAppendElem(lp, ep2);
 
1256
 
 
1257
   lSetList(ep, EH_resource_utilization, lp);
 
1258
   
 
1259
   lp = lCreateList("Load Values List", HL_Type);
 
1260
   
 
1261
   ep2 = lCreateElem(HL_Type);
 
1262
   lSetString(ep2, HL_name, "Test_Name8");
 
1263
   lSetString(ep2, HL_value, "1234.567");
 
1264
   lAppendElem(lp, ep2);
 
1265
   
 
1266
   ep2 = lCreateElem(HL_Type);
 
1267
   lSetString(ep2, HL_name, "Test_Name9");
 
1268
   lSetString(ep2, HL_value, "6.7");
 
1269
   lAppendElem(lp, ep2);
 
1270
   
 
1271
   lSetList(ep, EH_load_list, lp);
 
1272
 
 
1273
   lSetUlong(ep, EH_processors, 64);
 
1274
   
 
1275
   lp = lCreateList("Resched Unknown List", RU_Type);
 
1276
   
 
1277
   ep2 = lCreateElem(RU_Type);
 
1278
   lSetUlong(ep2, RU_job_number, 1);
 
1279
   lSetUlong(ep2, RU_task_number, 1);
 
1280
   lSetUlong(ep2, RU_state, 0);
 
1281
   lAppendElem(lp, ep2);
 
1282
   
 
1283
   ep2 = lCreateElem(RU_Type);
 
1284
   lSetUlong(ep2, RU_job_number, 1);
 
1285
   lSetUlong(ep2, RU_task_number, 2);
 
1286
   lSetUlong(ep2, RU_state, 1);
 
1287
   lAppendElem(lp, ep2);
 
1288
   
 
1289
   ep2 = lCreateElem(RU_Type);
 
1290
   lSetUlong(ep2, RU_job_number, 2);
 
1291
   lSetUlong(ep2, RU_task_number, 1);
 
1292
   lSetUlong(ep2, RU_state, 2);
 
1293
   lAppendElem(lp, ep2);
 
1294
 
 
1295
   lSetList(ep, EH_reschedule_unknown_list, lp);
 
1296
   
 
1297
   lp = lCreateList("User List", US_Type);
 
1298
   
 
1299
   ep2 = lCreateElem(US_Type);
 
1300
   lSetString(ep2, US_name, "Test_Name9");
 
1301
   lAppendElem(lp, ep2);
 
1302
   
 
1303
   ep2 = lCreateElem(US_Type);
 
1304
   lSetString(ep2, US_name, "Test_Name10");
 
1305
   lAppendElem(lp, ep2);
 
1306
   
 
1307
   lSetList(ep, EH_acl, lp);
 
1308
   
 
1309
   lp = lCreateList("XUser List", US_Type);
 
1310
   
 
1311
   ep2 = lCreateElem(US_Type);
 
1312
   lSetString(ep2, US_name, "Test_Name11");
 
1313
   lAppendElem(lp, ep2);
 
1314
   
 
1315
   ep2 = lCreateElem(US_Type);
 
1316
   lSetString(ep2, US_name, "Test_Name12");
 
1317
   lAppendElem(lp, ep2);
 
1318
   
 
1319
   lSetList(ep, EH_xacl, lp);
 
1320
   
 
1321
   lp = lCreateList("Projects List", PR_Type);
 
1322
   
 
1323
   ep2 = lCreateElem(PR_Type);
 
1324
   lSetString(ep2, PR_name, "Test_Name13");
 
1325
   lAppendElem(lp, ep2);
 
1326
   
 
1327
   ep2 = lCreateElem(PR_Type);
 
1328
   lSetString(ep2, PR_name, "Test_Name14");
 
1329
   lAppendElem(lp, ep2);
 
1330
   
 
1331
   lSetList(ep, EH_prj, lp);
 
1332
   
 
1333
   lp = lCreateList("XProjects List", PR_Type);
 
1334
   
 
1335
   ep2 = lCreateElem(PR_Type);
 
1336
   lSetString(ep2, PR_name, "Test_Name15");
 
1337
   lAppendElem(lp, ep2);
 
1338
   
 
1339
   ep2 = lCreateElem(PR_Type);
 
1340
   lSetString(ep2, PR_name, "Test_Name16");
 
1341
   lAppendElem(lp, ep2);
 
1342
   
 
1343
   lSetList(ep, EH_xprj, lp);
 
1344
   
 
1345
   lp = lCreateList("Usage Scaling List", HS_Type);
 
1346
   
 
1347
   ep2 = lCreateElem(HS_Type);
 
1348
   lSetString(ep2, HS_name, "Test_Name17");
 
1349
   lSetDouble(ep2, HS_value, 1234.567);
 
1350
   lAppendElem(lp, ep2);
 
1351
   
 
1352
   ep2 = lCreateElem(HS_Type);
 
1353
   lSetString(ep2, HS_name, "Test_Name18");
 
1354
   lSetDouble(ep2, HS_value, 6.7);
 
1355
   lAppendElem(lp, ep2);
 
1356
   
 
1357
   lSetList(ep, EH_usage_scaling_list, lp);
 
1358
   
 
1359
   lp = lCreateList("Report Vars List", STU_Type);
 
1360
   
 
1361
   ep2 = lCreateElem(STU_Type);
 
1362
   lSetString(ep2, STU_name, "Test_Name19");
 
1363
   lAppendElem(lp, ep2);
 
1364
   
 
1365
   ep2 = lCreateElem(STU_Type);
 
1366
   lSetString(ep2, STU_name, "Test_Name20");
 
1367
   lAppendElem(lp, ep2);
 
1368
   
 
1369
   lSetList(ep, EH_report_variables, lp);
 
1370
 
 
1371
   fields = sge_build_EH_field_list(true, false, false);
 
1372
 
 
1373
   printf("EH: spool\n");
 
1374
   /* Write a EH file using classic spooling */
 
1375
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
1376
                                       fields,
 
1377
                                       &qconf_sfi,
 
1378
                                       SP_DEST_TMP,
 
1379
                                       SP_FORM_ASCII, 
 
1380
                                       file1, false);
 
1381
   
 
1382
   /* Read a EH file using flatfile spooling */
 
1383
   lFreeElem(&ep);
 
1384
   ep = spool_flatfile_read_object(&alp, EH_Type, NULL,
 
1385
                                   fields, NULL, true, &qconf_sfi,
 
1386
                                   SP_FORM_ASCII, NULL, file1);
 
1387
      
 
1388
   /* Write a EH file using flatfile spooling */
 
1389
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
1390
                                       fields,
 
1391
                                       &qconf_sfi,
 
1392
                                       SP_DEST_TMP,
 
1393
                                       SP_FORM_ASCII, 
 
1394
                                       file2, false);
 
1395
   
 
1396
   ret = diff(file1, file2);
 
1397
   
 
1398
   unlink(file1);
 
1399
   unlink(file2);   
 
1400
   FREE(file1);
 
1401
   FREE(file2);
 
1402
   FREE(fields);
 
1403
 
 
1404
   lFreeElem(&ep);
 
1405
 
 
1406
   if (ret != 0) {
 
1407
      return ret;
 
1408
   }
 
1409
   
 
1410
   answer_list_output(&alp);   
 
1411
   
 
1412
   return ret;
 
1413
}
 
1414
 
 
1415
static int CQ_test(void) {
 
1416
   int ret = 0;
 
1417
   lListElem *ep = NULL;
 
1418
   lListElem *ep2 = NULL;
 
1419
   lListElem *ep3 = NULL;
 
1420
   lList *lp = NULL;
 
1421
   lList *lp2 = NULL;
 
1422
   lList *alp = NULL;
 
1423
   const char *file1 = NULL, *file2 = NULL;
 
1424
   
 
1425
   ep = lCreateElem(CQ_Type);
 
1426
   
 
1427
   lSetString(ep, CQ_name, "Test_Name");
 
1428
   
 
1429
   lAddSubHost(ep, HR_name, "Test_Name2", CQ_hostlist, HR_Type);
 
1430
   lAddSubHost(ep, HR_name, "Test_Name3", CQ_hostlist, HR_Type);
 
1431
 
 
1432
   lp = lCreateList("Seq No. List", AULNG_Type);
 
1433
   
 
1434
   ep2 = lCreateElem(AULNG_Type);
 
1435
   lSetHost(ep2, AULNG_href, "Test_Name4");
 
1436
   lSetUlong(ep2, AULNG_value, 12);
 
1437
   lAppendElem(lp, ep2);
 
1438
   
 
1439
   ep2 = lCreateElem(AULNG_Type);
 
1440
   lSetHost(ep2, AULNG_href, "Test_Name5");
 
1441
   lSetUlong(ep2, AULNG_value, 16);
 
1442
   lAppendElem(lp, ep2);
 
1443
 
 
1444
   lSetList(ep, CQ_seq_no, lp);
 
1445
 
 
1446
   lp = lCreateList("Load Thresholds", ACELIST_Type);
 
1447
   
 
1448
   ep2 = lCreateElem(ACELIST_Type);
 
1449
   lSetHost(ep2, ACELIST_href, "Test_Name6");
 
1450
 
 
1451
   lp2 = lCreateList("Complex List", CE_Type);
 
1452
   
 
1453
   ep3 = lCreateElem(CE_Type);
 
1454
   lSetString(ep3, CE_name, "Test_Name7");
 
1455
   lSetString(ep3, CE_stringval, "stringval");
 
1456
   lAppendElem(lp2, ep3);
 
1457
   
 
1458
   lSetList(ep2, ACELIST_value, lp2);
 
1459
   
 
1460
   lAppendElem(lp, ep2);
 
1461
 
 
1462
   lSetList(ep, CQ_load_thresholds, lp);
 
1463
   
 
1464
   lp = lCreateList("Suspend Thresholds", ACELIST_Type);
 
1465
 
 
1466
   ep2 = lCreateElem(ACELIST_Type);
 
1467
   lSetHost(ep2, ACELIST_href, "Test_Name15");
 
1468
 
 
1469
   lp2 = lCreateList("Complex_List2", CE_Type);
 
1470
   
 
1471
   ep3 = lCreateElem(CE_Type);
 
1472
   lSetString(ep3, CE_name, "Test_Name16");
 
1473
   lSetString(ep3, CE_stringval, "stringval");
 
1474
   lAppendElem(lp2, ep3);
 
1475
 
 
1476
   lSetList(ep2, ACELIST_value, lp2);
 
1477
   
 
1478
   lAppendElem(lp, ep2);
 
1479
 
 
1480
   lSetList(ep, CQ_suspend_thresholds, lp);
 
1481
   
 
1482
   lp = lCreateList("NSuspend List", AULNG_Type);
 
1483
   
 
1484
   ep2 = lCreateElem(AULNG_Type);
 
1485
   lSetHost(ep2, AULNG_href, "Test_Name18");
 
1486
   lSetUlong(ep2, AULNG_value, 12);
 
1487
   lAppendElem(lp, ep2);
 
1488
   
 
1489
   ep2 = lCreateElem(AULNG_Type);
 
1490
   lSetHost(ep2, AULNG_href, "Test_Name19");
 
1491
   lSetUlong(ep2, AULNG_value, 16);
 
1492
   lAppendElem(lp, ep2);
 
1493
 
 
1494
   lSetList(ep, CQ_nsuspend, lp);
 
1495
 
 
1496
   lp = lCreateList("Suspend Intervals", AINTER_Type);
 
1497
   
 
1498
   ep2 = lCreateElem(AINTER_Type);
 
1499
   lSetHost(ep2, AINTER_href, "Test_Name20");
 
1500
   lSetString(ep2, AINTER_value, "1");
 
1501
   lAppendElem(lp, ep2);
 
1502
   
 
1503
   ep2 = lCreateElem(AINTER_Type);
 
1504
   lSetHost(ep2, AINTER_href, "Test_Name21");
 
1505
   lSetString(ep2, AINTER_value, "2");
 
1506
   lAppendElem(lp, ep2);
 
1507
 
 
1508
   lSetList(ep, CQ_suspend_interval, lp);
 
1509
 
 
1510
   lp = lCreateList("Priority List", ASTR_Type);
 
1511
   
 
1512
   ep2 = lCreateElem(ASTR_Type);
 
1513
   lSetHost(ep2, ASTR_href, "Test_Name22");
 
1514
   lSetString(ep2, ASTR_value, "3");
 
1515
   lAppendElem(lp, ep2);
 
1516
   
 
1517
   ep2 = lCreateElem(ASTR_Type);
 
1518
   lSetHost(ep2, ASTR_href, "Test_Name23");
 
1519
   lSetString(ep2, ASTR_value, "4");
 
1520
   lAppendElem(lp, ep2);
 
1521
 
 
1522
   lSetList(ep, CQ_priority, lp);
 
1523
 
 
1524
   lp = lCreateList("Min CPU Intervals", AINTER_Type);
 
1525
   
 
1526
   ep2 = lCreateElem(AINTER_Type);
 
1527
   lSetHost(ep2, AINTER_href, "Test_Name24");
 
1528
   lSetString(ep2, AINTER_value, "5");
 
1529
   lAppendElem(lp, ep2);
 
1530
   
 
1531
   ep2 = lCreateElem(AINTER_Type);
 
1532
   lSetHost(ep2, AINTER_href, "Test_Name25");
 
1533
   lSetString(ep2, AINTER_value, "6");
 
1534
   lAppendElem(lp, ep2);
 
1535
 
 
1536
   lSetList(ep, CQ_min_cpu_interval, lp);
 
1537
 
 
1538
   lp = lCreateList("Processor List", ASTR_Type);
 
1539
   
 
1540
   ep2 = lCreateElem(ASTR_Type);
 
1541
   lSetHost(ep2, ASTR_href, "Test_Name26");
 
1542
   lSetString(ep2, ASTR_value, "7");
 
1543
   lAppendElem(lp, ep2);
 
1544
   
 
1545
   ep2 = lCreateElem(ASTR_Type);
 
1546
   lSetHost(ep2, ASTR_href, "Test_Name27");
 
1547
   lSetString(ep2, ASTR_value, "8");
 
1548
   lAppendElem(lp, ep2);
 
1549
 
 
1550
   lSetList(ep, CQ_processors, lp);
 
1551
 
 
1552
   lp = lCreateList("Q-Type List", AQTLIST_Type);
 
1553
   
 
1554
   ep2 = lCreateElem(AQTLIST_Type);
 
1555
   lSetHost(ep2, AQTLIST_href, "Test_Name28");
 
1556
   lSetUlong(ep2, AQTLIST_value, 12);
 
1557
   lAppendElem(lp, ep2);
 
1558
   
 
1559
   ep2 = lCreateElem(AQTLIST_Type);
 
1560
   lSetHost(ep2, AQTLIST_href, "Test_Name29");
 
1561
   lSetUlong(ep2, AQTLIST_value, 16);
 
1562
   lAppendElem(lp, ep2);
 
1563
 
 
1564
   lSetList(ep, CQ_qtype, lp);
 
1565
 
 
1566
   lp = lCreateList("Checkpoint List", ASTRLIST_Type);
 
1567
   
 
1568
   ep2 = lCreateElem(ASTRLIST_Type);
 
1569
   lSetHost(ep2, ASTRLIST_href, "Test_Name30");
 
1570
   
 
1571
   lp2 = lCreateList("String List", ST_Type);
 
1572
   
 
1573
   ep3 = lCreateElem(ST_Type);
 
1574
   lSetString(ep3, ST_name, "Test_Name31");
 
1575
   lAppendElem(lp2, ep3);
 
1576
   
 
1577
   ep3 = lCreateElem(ST_Type);
 
1578
   lSetString(ep3, ST_name, "Test_Name32");
 
1579
   lAppendElem(lp2, ep3);
 
1580
   
 
1581
   lSetList(ep2, ASTRLIST_value, lp2);
 
1582
   lAppendElem(lp, ep2);
 
1583
 
 
1584
   lSetList(ep, CQ_ckpt_list, lp);
 
1585
 
 
1586
   lp = lCreateList("PE List", ASTRLIST_Type);
 
1587
   
 
1588
   ep2 = lCreateElem(ASTRLIST_Type);
 
1589
   lSetHost(ep2, ASTRLIST_href, "Test_Name36");
 
1590
   
 
1591
   lp2 = lCreateList("String List", ST_Type);
 
1592
   
 
1593
   ep3 = lCreateElem(ST_Type);
 
1594
   lSetString(ep3, ST_name, "Test_Name37");
 
1595
   lAppendElem(lp2, ep3);
 
1596
 
 
1597
   ep3 = lCreateElem(ST_Type);
 
1598
   lSetString(ep3, ST_name, "Test_Name38");
 
1599
   lAppendElem(lp2, ep3);
 
1600
   
 
1601
   lSetList(ep2, ASTRLIST_value, lp2);
 
1602
   lAppendElem(lp, ep2);
 
1603
   
 
1604
   lSetList(ep, CQ_pe_list, lp);
 
1605
 
 
1606
   lp = lCreateList("Rerun List", ABOOL_Type);
 
1607
   
 
1608
   ep2 = lCreateElem(ABOOL_Type);
 
1609
   lSetHost(ep2, ABOOL_href, "Test_Name42");
 
1610
   lSetBool(ep2, ABOOL_value, true);
 
1611
   lAppendElem(lp, ep2);
 
1612
   
 
1613
   ep2 = lCreateElem(ABOOL_Type);
 
1614
   lSetHost(ep2, ABOOL_href, "Test_Name43");
 
1615
   lSetBool(ep2, ABOOL_value, false);
 
1616
   lAppendElem(lp, ep2);
 
1617
 
 
1618
   lSetList(ep, CQ_rerun, lp);
 
1619
 
 
1620
   lp = lCreateList("Job Slots", AULNG_Type);
 
1621
   
 
1622
   ep2 = lCreateElem(AULNG_Type);
 
1623
   lSetHost(ep2, AULNG_href, "Test_Name44");
 
1624
   lSetUlong(ep2, AULNG_value, 12);
 
1625
   lAppendElem(lp, ep2);
 
1626
   
 
1627
   ep2 = lCreateElem(AULNG_Type);
 
1628
   lSetHost(ep2, AULNG_href, "Test_Name45");
 
1629
   lSetUlong(ep2, AULNG_value, 16);
 
1630
   lAppendElem(lp, ep2);
 
1631
 
 
1632
   lSetList(ep, CQ_job_slots, lp);
 
1633
 
 
1634
   lp = lCreateList("Tmp Dir List", ASTR_Type);
 
1635
   
 
1636
   ep2 = lCreateElem(ASTR_Type);
 
1637
   lSetHost(ep2, ASTR_href, "Test_Name46");
 
1638
   lSetString(ep2, ASTR_value, "value");
 
1639
   lAppendElem(lp, ep2);
 
1640
   
 
1641
   ep2 = lCreateElem(ASTR_Type);
 
1642
   lSetHost(ep2, ASTR_href, "Test_Name47");
 
1643
   lSetString(ep2, ASTR_value, "value");
 
1644
   lAppendElem(lp, ep2);
 
1645
 
 
1646
   lSetList(ep, CQ_tmpdir, lp);
 
1647
 
 
1648
   lp = lCreateList("Shell List", ASTR_Type);
 
1649
   
 
1650
   ep2 = lCreateElem(ASTR_Type);
 
1651
   lSetHost(ep2, ASTR_href, "Test_Name48");
 
1652
   lSetString(ep2, ASTR_value, "value");
 
1653
   lAppendElem(lp, ep2);
 
1654
   
 
1655
   ep2 = lCreateElem(ASTR_Type);
 
1656
   lSetHost(ep2, ASTR_href, "Test_Name49");
 
1657
   lSetString(ep2, ASTR_value, "value");
 
1658
   lAppendElem(lp, ep2);
 
1659
 
 
1660
   lSetList(ep, CQ_shell, lp);
 
1661
 
 
1662
   lp = lCreateList("Prolog List", ASTR_Type);
 
1663
   
 
1664
   ep2 = lCreateElem(ASTR_Type);
 
1665
   lSetHost(ep2, ASTR_href, "Test_Name50");
 
1666
   lSetString(ep2, ASTR_value, "value");
 
1667
   lAppendElem(lp, ep2);
 
1668
   
 
1669
   ep2 = lCreateElem(ASTR_Type);
 
1670
   lSetHost(ep2, ASTR_href, "Test_Name51");
 
1671
   lSetString(ep2, ASTR_value, "value");
 
1672
   lAppendElem(lp, ep2);
 
1673
 
 
1674
   lSetList(ep, CQ_prolog, lp);
 
1675
 
 
1676
   lp = lCreateList("Epilog List", ASTR_Type);
 
1677
   
 
1678
   ep2 = lCreateElem(ASTR_Type);
 
1679
   lSetHost(ep2, ASTR_href, "Test_Name52");
 
1680
   lSetString(ep2, ASTR_value, "value");
 
1681
   lAppendElem(lp, ep2);
 
1682
   
 
1683
   ep2 = lCreateElem(ASTR_Type);
 
1684
   lSetHost(ep2, ASTR_href, "Test_Name53");
 
1685
   lSetString(ep2, ASTR_value, "value");
 
1686
   lAppendElem(lp, ep2);
 
1687
 
 
1688
   lSetList(ep, CQ_epilog, lp);
 
1689
 
 
1690
   lp = lCreateList("Shell Start Modes", ASTR_Type);
 
1691
   
 
1692
   ep2 = lCreateElem(ASTR_Type);
 
1693
   lSetHost(ep2, ASTR_href, "Test_Name54");
 
1694
   lSetString(ep2, ASTR_value, "value");
 
1695
   lAppendElem(lp, ep2);
 
1696
   
 
1697
   ep2 = lCreateElem(ASTR_Type);
 
1698
   lSetHost(ep2, ASTR_href, "Test_Name55");
 
1699
   lSetString(ep2, ASTR_value, "value");
 
1700
   lAppendElem(lp, ep2);
 
1701
 
 
1702
   lSetList(ep, CQ_shell_start_mode, lp);
 
1703
 
 
1704
   lp = lCreateList("Shell Start Methods", ASTR_Type);
 
1705
   
 
1706
   ep2 = lCreateElem(ASTR_Type);
 
1707
   lSetHost(ep2, ASTR_href, "Test_Name56");
 
1708
   lSetString(ep2, ASTR_value, "value");
 
1709
   lAppendElem(lp, ep2);
 
1710
   
 
1711
   ep2 = lCreateElem(ASTR_Type);
 
1712
   lSetHost(ep2, ASTR_href, "Test_Name57");
 
1713
   lSetString(ep2, ASTR_value, "value");
 
1714
   lAppendElem(lp, ep2);
 
1715
 
 
1716
   lSetList(ep, CQ_starter_method, lp);
 
1717
 
 
1718
   lp = lCreateList("Shell Suspend Methods", ASTR_Type);
 
1719
   
 
1720
   ep2 = lCreateElem(ASTR_Type);
 
1721
   lSetHost(ep2, ASTR_href, "Test_Name58");
 
1722
   lSetString(ep2, ASTR_value, "value");
 
1723
   lAppendElem(lp, ep2);
 
1724
   
 
1725
   ep2 = lCreateElem(ASTR_Type);
 
1726
   lSetHost(ep2, ASTR_href, "Test_Name59");
 
1727
   lSetString(ep2, ASTR_value, "value");
 
1728
   lAppendElem(lp, ep2);
 
1729
 
 
1730
   lSetList(ep, CQ_suspend_method, lp);
 
1731
 
 
1732
   lp = lCreateList("Shell Resume Methods", ASTR_Type);
 
1733
   
 
1734
   ep2 = lCreateElem(ASTR_Type);
 
1735
   lSetHost(ep2, ASTR_href, "Test_Name60");
 
1736
   lSetString(ep2, ASTR_value, "value");
 
1737
   lAppendElem(lp, ep2);
 
1738
   
 
1739
   ep2 = lCreateElem(ASTR_Type);
 
1740
   lSetHost(ep2, ASTR_href, "Test_Name61");
 
1741
   lSetString(ep2, ASTR_value, "value");
 
1742
   lAppendElem(lp, ep2);
 
1743
 
 
1744
   lSetList(ep, CQ_resume_method, lp);
 
1745
 
 
1746
   lp = lCreateList("Shell Terminate Methods", ASTR_Type);
 
1747
   
 
1748
   ep2 = lCreateElem(ASTR_Type);
 
1749
   lSetHost(ep2, ASTR_href, "Test_Name62");
 
1750
   lSetString(ep2, ASTR_value, "value");
 
1751
   lAppendElem(lp, ep2);
 
1752
   
 
1753
   ep2 = lCreateElem(ASTR_Type);
 
1754
   lSetHost(ep2, ASTR_href, "Test_Name63");
 
1755
   lSetString(ep2, ASTR_value, "value");
 
1756
   lAppendElem(lp, ep2);
 
1757
 
 
1758
   lSetList(ep, CQ_terminate_method, lp);
 
1759
 
 
1760
   lp = lCreateList("Notify List", AINTER_Type);
 
1761
   
 
1762
   ep2 = lCreateElem(AINTER_Type);
 
1763
   lSetHost(ep2, AINTER_href, "Test_Name64");
 
1764
   lSetString(ep2, AINTER_value, "46");
 
1765
   lAppendElem(lp, ep2);
 
1766
   
 
1767
   ep2 = lCreateElem(AINTER_Type);
 
1768
   lSetHost(ep2, AINTER_href, "Test_Name65");
 
1769
   lSetString(ep2, AINTER_value, "77");
 
1770
   lAppendElem(lp, ep2);
 
1771
 
 
1772
   lSetList(ep, CQ_notify, lp);
 
1773
 
 
1774
   lp = lCreateList("Owner List", AUSRLIST_Type);
 
1775
   
 
1776
   ep2 = lCreateElem(AUSRLIST_Type);
 
1777
   lSetHost(ep2, AUSRLIST_href, "Test_Name66");
 
1778
   
 
1779
   lp2 = lCreateList("Userset List", US_Type);
 
1780
   
 
1781
   ep3 = lCreateElem(US_Type);
 
1782
   lSetString(ep3, US_name, "Test_Name67");
 
1783
   lAppendElem(lp2, ep3);
 
1784
   
 
1785
   ep3 = lCreateElem(US_Type);
 
1786
   lSetString(ep3, US_name, "Test_Name68");
 
1787
   lAppendElem(lp2, ep3);
 
1788
   
 
1789
   lSetList(ep2, AUSRLIST_value, lp2);
 
1790
   lAppendElem(lp, ep2);
 
1791
 
 
1792
   lSetList(ep, CQ_owner_list, lp);
 
1793
 
 
1794
   lp = lCreateList("ACL List", AUSRLIST_Type);
 
1795
   
 
1796
   ep2 = lCreateElem(AUSRLIST_Type);
 
1797
   lSetHost(ep2, AUSRLIST_href, "Test_Name72");
 
1798
   
 
1799
   lp2 = lCreateList("Userset List", US_Type);
 
1800
   
 
1801
   ep3 = lCreateElem(US_Type);
 
1802
   lSetString(ep3, US_name, "Test_Name73");
 
1803
   lAppendElem(lp2, ep3);
 
1804
   
 
1805
   ep3 = lCreateElem(US_Type);
 
1806
   lSetString(ep3, US_name, "Test_Name74");
 
1807
   lAppendElem(lp2, ep3);
 
1808
   
 
1809
   lSetList(ep2, AUSRLIST_value, lp2);
 
1810
   lAppendElem(lp, ep2);
 
1811
 
 
1812
   lSetList(ep, CQ_acl, lp);
 
1813
 
 
1814
   lp = lCreateList("XUser List", AUSRLIST_Type);
 
1815
   
 
1816
   ep2 = lCreateElem(AUSRLIST_Type);
 
1817
   lSetHost(ep2, AUSRLIST_href, "Test_Name78");
 
1818
   
 
1819
   lp2 = lCreateList("Userset List", US_Type);
 
1820
   
 
1821
   ep3 = lCreateElem(US_Type);
 
1822
   lSetString(ep3, US_name, "Test_Name79");
 
1823
   lAppendElem(lp2, ep3);
 
1824
   
 
1825
   ep3 = lCreateElem(US_Type);
 
1826
   lSetString(ep3, US_name, "Test_Name80");
 
1827
   lAppendElem(lp2, ep3);
 
1828
   
 
1829
   lSetList(ep2, AUSRLIST_value, lp2);
 
1830
   lAppendElem(lp, ep2);
 
1831
 
 
1832
   lSetList(ep, CQ_xacl, lp);
 
1833
 
 
1834
   lp = lCreateList("Subordinate List", ASOLIST_Type);
 
1835
   
 
1836
   ep2 = lCreateElem(ASOLIST_Type);
 
1837
   lSetHost(ep2, ASOLIST_href, "Test_Name84");
 
1838
 
 
1839
   lp2 = lCreateList("Subordinate List", SO_Type);
 
1840
   
 
1841
   ep3 = lCreateElem(SO_Type);
 
1842
   lSetString(ep3, SO_name, "Test_Name85");
 
1843
   lSetUlong(ep3, SO_threshold, 13);
 
1844
   lAppendElem(lp2, ep3);
 
1845
   
 
1846
   ep3 = lCreateElem(SO_Type);
 
1847
   lSetString(ep3, SO_name, "Test_Name86");
 
1848
   lSetUlong(ep3, SO_threshold, 16);
 
1849
   lAppendElem(lp2, ep3);
 
1850
 
 
1851
   lSetList(ep2, ASOLIST_value, lp2);
 
1852
   
 
1853
   lAppendElem(lp, ep2);
 
1854
   
 
1855
   lSetList(ep, CQ_subordinate_list, lp);
 
1856
  
 
1857
   lp = lCreateList("Consumable Configs List", ACELIST_Type);
 
1858
   
 
1859
   ep2 = lCreateElem(ACELIST_Type);
 
1860
   lSetHost(ep2, ACELIST_href, "Test_Name93");
 
1861
 
 
1862
   lp2 = lCreateList("Complex List", CE_Type);
 
1863
   
 
1864
   ep3 = lCreateElem(CE_Type);
 
1865
   lSetString(ep3, CE_name, "Test_Name94");
 
1866
   lSetString(ep3, CE_stringval, "stringval");
 
1867
   lAppendElem(lp2, ep3);
 
1868
 
 
1869
   lSetList(ep2, ACELIST_value, lp2);
 
1870
   
 
1871
   lAppendElem(lp, ep2);
 
1872
 
 
1873
   lSetList(ep, CQ_consumable_config_list, lp);
 
1874
   
 
1875
   lp = lCreateList("Projects List", APRJLIST_Type);
 
1876
   
 
1877
   ep2 = lCreateElem(APRJLIST_Type);
 
1878
   lSetHost(ep2, APRJLIST_href, "Test_Name96");
 
1879
   
 
1880
   lp2 = lCreateList("Project List", PR_Type);
 
1881
   
 
1882
   ep3 = lCreateElem(PR_Type);
 
1883
   lSetString(ep3, PR_name, "Test_Name97");
 
1884
   lAppendElem(lp2, ep3);
 
1885
   
 
1886
   ep3 = lCreateElem(PR_Type);
 
1887
   lSetString(ep3, PR_name, "Test_Name98");
 
1888
   lAppendElem(lp2, ep3);
 
1889
   
 
1890
   lSetList(ep2, APRJLIST_value, lp2);
 
1891
   lAppendElem(lp, ep2);
 
1892
 
 
1893
   lSetList(ep, CQ_projects, lp);
 
1894
 
 
1895
   lp = lCreateList("XProjects List", APRJLIST_Type);
 
1896
   
 
1897
   ep2 = lCreateElem(APRJLIST_Type);
 
1898
   lSetHost(ep2, APRJLIST_href, "Test_Name102");
 
1899
   
 
1900
   lp2 = lCreateList("Project List", PR_Type);
 
1901
   
 
1902
   ep3 = lCreateElem(PR_Type);
 
1903
   lSetString(ep3, PR_name, "Test_Name103");
 
1904
   lAppendElem(lp2, ep3);
 
1905
   
 
1906
   ep3 = lCreateElem(PR_Type);
 
1907
   lSetString(ep3, PR_name, "Test_Name104");
 
1908
   lAppendElem(lp2, ep3);
 
1909
   
 
1910
   lSetList(ep2, APRJLIST_value, lp2);
 
1911
   lAppendElem(lp, ep2);
 
1912
 
 
1913
   lSetList(ep, CQ_xprojects, lp);
 
1914
 
 
1915
   lp = lCreateList("Calendar List", ASTR_Type);
 
1916
   
 
1917
   ep2 = lCreateElem(ASTR_Type);
 
1918
   lSetHost(ep2, ASTR_href, "Test_Name108");
 
1919
   lSetString(ep2, ASTR_value, "value");
 
1920
   lAppendElem(lp, ep2);
 
1921
   
 
1922
   ep2 = lCreateElem(ASTR_Type);
 
1923
   lSetHost(ep2, ASTR_href, "Test_Name109");
 
1924
   lSetString(ep2, ASTR_value, "value");
 
1925
   lAppendElem(lp, ep2);
 
1926
 
 
1927
   lSetList(ep, CQ_calendar, lp);
 
1928
 
 
1929
   lp = lCreateList("Initial State List", ASTR_Type);
 
1930
   
 
1931
   ep2 = lCreateElem(ASTR_Type);
 
1932
   lSetHost(ep2, ASTR_href, "Test_Name110");
 
1933
   lSetString(ep2, ASTR_value, "value");
 
1934
   lAppendElem(lp, ep2);
 
1935
   
 
1936
   ep2 = lCreateElem(ASTR_Type);
 
1937
   lSetHost(ep2, ASTR_href, "Test_Name111");
 
1938
   lSetString(ep2, ASTR_value, "value");
 
1939
   lAppendElem(lp, ep2);
 
1940
 
 
1941
   lSetList(ep, CQ_initial_state, lp);
 
1942
 
 
1943
   lp = lCreateList("s_rt List", ATIME_Type);
 
1944
   
 
1945
   ep2 = lCreateElem(ATIME_Type);
 
1946
   lSetHost(ep2, ATIME_href, "Test_Name112");
 
1947
   lSetString(ep2, ATIME_value, "00:00:00");
 
1948
   lAppendElem(lp, ep2);
 
1949
   
 
1950
   ep2 = lCreateElem(ATIME_Type);
 
1951
   lSetHost(ep2, ATIME_href, "Test_Name113");
 
1952
   lSetString(ep2, ATIME_value, "23:59:59");
 
1953
   lAppendElem(lp, ep2);
 
1954
 
 
1955
   lSetList(ep, CQ_s_rt, lp);
 
1956
 
 
1957
   lp = lCreateList("h_rt List", ATIME_Type);
 
1958
   
 
1959
   ep2 = lCreateElem(ATIME_Type);
 
1960
   lSetHost(ep2, ATIME_href, "Test_Name114");
 
1961
   lSetString(ep2, ATIME_value, "00:00:00");
 
1962
   lAppendElem(lp, ep2);
 
1963
   
 
1964
   ep2 = lCreateElem(ATIME_Type);
 
1965
   lSetHost(ep2, ATIME_href, "Test_Name115");
 
1966
   lSetString(ep2, ATIME_value, "23:59:59");
 
1967
   lAppendElem(lp, ep2);
 
1968
 
 
1969
   lSetList(ep, CQ_h_rt, lp);
 
1970
 
 
1971
   lp = lCreateList("s_cpu List", ATIME_Type);
 
1972
   
 
1973
   ep2 = lCreateElem(ATIME_Type);
 
1974
   lSetHost(ep2, ATIME_href, "Test_Name116");
 
1975
   lSetString(ep2, ATIME_value, "00:00:00");
 
1976
   lAppendElem(lp, ep2);
 
1977
   
 
1978
   ep2 = lCreateElem(ATIME_Type);
 
1979
   lSetHost(ep2, ATIME_href, "Test_Name117");
 
1980
   lSetString(ep2, ATIME_value, "23:59:59");
 
1981
   lAppendElem(lp, ep2);
 
1982
 
 
1983
   lSetList(ep, CQ_s_cpu, lp);
 
1984
 
 
1985
   lp = lCreateList("h_cpu List", ATIME_Type);
 
1986
   
 
1987
   ep2 = lCreateElem(ATIME_Type);
 
1988
   lSetHost(ep2, ATIME_href, "Test_Name118");
 
1989
   lSetString(ep2, ATIME_value, "00:00:00");
 
1990
   lAppendElem(lp, ep2);
 
1991
   
 
1992
   ep2 = lCreateElem(ATIME_Type);
 
1993
   lSetHost(ep2, ATIME_href, "Test_Name119");
 
1994
   lSetString(ep2, ATIME_value, "23:59:59");
 
1995
   lAppendElem(lp, ep2);
 
1996
 
 
1997
   lSetList(ep, CQ_h_cpu, lp);
 
1998
 
 
1999
   lp = lCreateList("s_fsize List", AMEM_Type);
 
2000
   
 
2001
   ep2 = lCreateElem(AMEM_Type);
 
2002
   lSetHost(ep2, AMEM_href, "Test_Name120");
 
2003
   lSetString(ep2, AMEM_value, "1048576");
 
2004
   lAppendElem(lp, ep2);
 
2005
   
 
2006
   ep2 = lCreateElem(AMEM_Type);
 
2007
   lSetHost(ep2, AMEM_href, "Test_Name121");
 
2008
   lSetString(ep2, AMEM_value, "1024");
 
2009
   lAppendElem(lp, ep2);
 
2010
 
 
2011
   lSetList(ep, CQ_s_fsize, lp);
 
2012
 
 
2013
   lp = lCreateList("h_fsize List", AMEM_Type);
 
2014
   
 
2015
   ep2 = lCreateElem(AMEM_Type);
 
2016
   lSetHost(ep2, AMEM_href, "Test_Name122");
 
2017
   lSetString(ep2, AMEM_value, "1048576");
 
2018
   lAppendElem(lp, ep2);
 
2019
   
 
2020
   ep2 = lCreateElem(AMEM_Type);
 
2021
   lSetHost(ep2, AMEM_href, "Test_Name123");
 
2022
   lSetString(ep2, AMEM_value, "1024");
 
2023
   lAppendElem(lp, ep2);
 
2024
 
 
2025
   lSetList(ep, CQ_h_fsize, lp);
 
2026
 
 
2027
   lp = lCreateList("s_data List", AMEM_Type);
 
2028
   
 
2029
   ep2 = lCreateElem(AMEM_Type);
 
2030
   lSetHost(ep2, AMEM_href, "Test_Name124");
 
2031
   lSetString(ep2, AMEM_value, "1048576");
 
2032
   lAppendElem(lp, ep2);
 
2033
   
 
2034
   ep2 = lCreateElem(AMEM_Type);
 
2035
   lSetHost(ep2, AMEM_href, "Test_Name125");
 
2036
   lSetString(ep2, AMEM_value, "1024");
 
2037
   lAppendElem(lp, ep2);
 
2038
 
 
2039
   lSetList(ep, CQ_s_data, lp);
 
2040
 
 
2041
   lp = lCreateList("h_data List", AMEM_Type);
 
2042
   
 
2043
   ep2 = lCreateElem(AMEM_Type);
 
2044
   lSetHost(ep2, AMEM_href, "Test_Name126");
 
2045
   lSetString(ep2, AMEM_value, "1048576");
 
2046
   lAppendElem(lp, ep2);
 
2047
   
 
2048
   ep2 = lCreateElem(AMEM_Type);
 
2049
   lSetHost(ep2, AMEM_href, "Test_Name127");
 
2050
   lSetString(ep2, AMEM_value, "1024");
 
2051
   lAppendElem(lp, ep2);
 
2052
 
 
2053
   lSetList(ep, CQ_h_data, lp);
 
2054
 
 
2055
   lp = lCreateList("s_stack List", AMEM_Type);
 
2056
   
 
2057
   ep2 = lCreateElem(AMEM_Type);
 
2058
   lSetHost(ep2, AMEM_href, "Test_Name128");
 
2059
   lSetString(ep2, AMEM_value, "1048576");
 
2060
   lAppendElem(lp, ep2);
 
2061
   
 
2062
   ep2 = lCreateElem(AMEM_Type);
 
2063
   lSetHost(ep2, AMEM_href, "Test_Name129");
 
2064
   lSetString(ep2, AMEM_value, "1024");
 
2065
   lAppendElem(lp, ep2);
 
2066
 
 
2067
   lSetList(ep, CQ_s_stack, lp);
 
2068
 
 
2069
   lp = lCreateList("h_stack List", AMEM_Type);
 
2070
   
 
2071
   ep2 = lCreateElem(AMEM_Type);
 
2072
   lSetHost(ep2, AMEM_href, "Test_Name130");
 
2073
   lSetString(ep2, AMEM_value, "1048576");
 
2074
   lAppendElem(lp, ep2);
 
2075
   
 
2076
   ep2 = lCreateElem(AMEM_Type);
 
2077
   lSetHost(ep2, AMEM_href, "Test_Name131");
 
2078
   lSetString(ep2, AMEM_value, "1024");
 
2079
   lAppendElem(lp, ep2);
 
2080
 
 
2081
   lSetList(ep, CQ_h_stack, lp);
 
2082
 
 
2083
   lp = lCreateList("s_core List", AMEM_Type);
 
2084
   
 
2085
   ep2 = lCreateElem(AMEM_Type);
 
2086
   lSetHost(ep2, AMEM_href, "Test_Name132");
 
2087
   lSetString(ep2, AMEM_value, "1048576");
 
2088
   lAppendElem(lp, ep2);
 
2089
   
 
2090
   ep2 = lCreateElem(AMEM_Type);
 
2091
   lSetHost(ep2, AMEM_href, "Test_Name133");
 
2092
   lSetString(ep2, AMEM_value, "1024");
 
2093
   lAppendElem(lp, ep2);
 
2094
 
 
2095
   lSetList(ep, CQ_s_core, lp);
 
2096
 
 
2097
   lp = lCreateList("h_core List", AMEM_Type);
 
2098
   
 
2099
   ep2 = lCreateElem(AMEM_Type);
 
2100
   lSetHost(ep2, AMEM_href, "Test_Name134");
 
2101
   lSetString(ep2, AMEM_value, "1048576");
 
2102
   lAppendElem(lp, ep2);
 
2103
   
 
2104
   ep2 = lCreateElem(AMEM_Type);
 
2105
   lSetHost(ep2, AMEM_href, "Test_Name135");
 
2106
   lSetString(ep2, AMEM_value, "1024");
 
2107
   lAppendElem(lp, ep2);
 
2108
 
 
2109
   lSetList(ep, CQ_h_core, lp);
 
2110
 
 
2111
   lp = lCreateList("s_rss List", AMEM_Type);
 
2112
   
 
2113
   ep2 = lCreateElem(AMEM_Type);
 
2114
   lSetHost(ep2, AMEM_href, "Test_Name136");
 
2115
   lSetString(ep2, AMEM_value, "1048576");
 
2116
   lAppendElem(lp, ep2);
 
2117
   
 
2118
   ep2 = lCreateElem(AMEM_Type);
 
2119
   lSetHost(ep2, AMEM_href, "Test_Name137");
 
2120
   lSetString(ep2, AMEM_value, "1024");
 
2121
   lAppendElem(lp, ep2);
 
2122
 
 
2123
   lSetList(ep, CQ_s_rss, lp);
 
2124
 
 
2125
   lp = lCreateList("h_rss List", AMEM_Type);
 
2126
   
 
2127
   ep2 = lCreateElem(AMEM_Type);
 
2128
   lSetHost(ep2, AMEM_href, "Test_Name138");
 
2129
   lSetString(ep2, AMEM_value, "1048576");
 
2130
   lAppendElem(lp, ep2);
 
2131
   
 
2132
   ep2 = lCreateElem(AMEM_Type);
 
2133
   lSetHost(ep2, AMEM_href, "Test_Name139");
 
2134
   lSetString(ep2, AMEM_value, "1024");
 
2135
   lAppendElem(lp, ep2);
 
2136
 
 
2137
   lSetList(ep, CQ_h_rss, lp);
 
2138
 
 
2139
   lp = lCreateList("s_vmem List", AMEM_Type);
 
2140
   
 
2141
   ep2 = lCreateElem(AMEM_Type);
 
2142
   lSetHost(ep2, AMEM_href, "Test_Name140");
 
2143
   lSetString(ep2, AMEM_value, "1048576");
 
2144
   lAppendElem(lp, ep2);
 
2145
   
 
2146
   ep2 = lCreateElem(AMEM_Type);
 
2147
   lSetHost(ep2, AMEM_href, "Test_Name141");
 
2148
   lSetString(ep2, AMEM_value, "1024");
 
2149
   lAppendElem(lp, ep2);
 
2150
 
 
2151
   lSetList(ep, CQ_s_vmem, lp);
 
2152
 
 
2153
   lp = lCreateList("h_vmem List", AMEM_Type);
 
2154
   
 
2155
   ep2 = lCreateElem(AMEM_Type);
 
2156
   lSetHost(ep2, AMEM_href, "Test_Name142");
 
2157
   lSetString(ep2, AMEM_value, "1048576");
 
2158
   lAppendElem(lp, ep2);
 
2159
   
 
2160
   ep2 = lCreateElem(AMEM_Type);
 
2161
   lSetHost(ep2, AMEM_href, "Test_Name143");
 
2162
   lSetString(ep2, AMEM_value, "1024");
 
2163
   lAppendElem(lp, ep2);
 
2164
 
 
2165
   lSetList(ep, CQ_h_vmem, lp);
 
2166
 
 
2167
   printf("CQ: No Args\n");   
 
2168
   /* Write a CQ file using classic spooling */
 
2169
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
2170
                                       CQ_fields,
 
2171
                                       &qconf_sfi,
 
2172
                                       SP_DEST_TMP,
 
2173
                                       SP_FORM_ASCII, 
 
2174
                                       file1, false);
 
2175
   
 
2176
   /* Read a CQ file using flatfile spooling */
 
2177
   lFreeElem(&ep);
 
2178
   ep = spool_flatfile_read_object(&alp, CQ_Type, NULL,
 
2179
                                   CQ_fields, NULL, true, &qconf_sfi,
 
2180
                                   SP_FORM_ASCII, NULL, file1);
 
2181
   
 
2182
   /* Write a CQ file using flatfile spooling */
 
2183
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
2184
                                       CQ_fields,
 
2185
                                       &qconf_sfi,
 
2186
                                       SP_DEST_TMP,
 
2187
                                       SP_FORM_ASCII, 
 
2188
                                       file2, false);
 
2189
   
 
2190
   lFreeElem(&ep);
 
2191
   
 
2192
   ret = diff(file1, file2);
 
2193
   
 
2194
   unlink(file1);
 
2195
   unlink(file2);
 
2196
   FREE(file1);
 
2197
   FREE(file2);
 
2198
   
 
2199
   answer_list_output(&alp);   
 
2200
   
 
2201
   return ret;
 
2202
}
 
2203
 
 
2204
static int SC_test(void)
 
2205
{
 
2206
   int ret = 0;
 
2207
   lListElem *ep = NULL;
 
2208
   lListElem *ep2 = NULL;
 
2209
   lList *lp = NULL;
 
2210
   lList *alp = NULL;
 
2211
   const char *file1 = NULL, *file2 = NULL;
 
2212
   
 
2213
   ep = lCreateElem(SC_Type);
 
2214
   lSetString(ep, SC_algorithm, "algorithm");
 
2215
   lSetString(ep, SC_schedule_interval, "30");
 
2216
   lSetUlong(ep, SC_maxujobs, 1024);
 
2217
   lSetUlong(ep, SC_queue_sort_method, 1);
 
2218
 
 
2219
   lp = lCreateList("Job Load Adjustments", CE_Type);
 
2220
 
 
2221
   ep2 = lCreateElem(CE_Type);
 
2222
   lSetString(ep2, CE_name, "Test_Name1");
 
2223
   lSetString(ep2, CE_shortcut, "shortcut");
 
2224
   lSetUlong(ep2, CE_valtype, 1);
 
2225
   lSetUlong(ep2, CE_relop, 5);
 
2226
   lSetBool(ep2, CE_consumable, true);
 
2227
   lSetString(ep2, CE_default, "15");
 
2228
   lSetUlong(ep2, CE_requestable, REQU_NO);
 
2229
   lSetString(ep2, CE_urgency_weight, "25");
 
2230
   lSetString(ep2, CE_stringval, "stringval");
 
2231
   lAppendElem(lp, ep2);
 
2232
   
 
2233
   ep2 = lCreateElem(CE_Type);
 
2234
   lSetString(ep2, CE_name, "Test_Name2");
 
2235
   lSetString(ep2, CE_shortcut, "shortcut");
 
2236
   lSetUlong(ep2, CE_valtype, 1);
 
2237
   lSetUlong(ep2, CE_relop, 5);
 
2238
   lSetBool(ep2, CE_consumable, false);
 
2239
   lSetString(ep2, CE_default, "15");
 
2240
   lSetUlong(ep2, CE_requestable, REQU_YES);
 
2241
   lSetString(ep2, CE_urgency_weight, "25");
 
2242
   lSetString(ep2, CE_stringval, "stringval");
 
2243
   lAppendElem(lp, ep2);
 
2244
 
 
2245
   lSetList(ep, SC_job_load_adjustments, lp);
 
2246
   lSetString(ep, SC_load_adjustment_decay_time, "45");
 
2247
   lSetString(ep, SC_load_formula, "load_formula");
 
2248
   lSetString(ep, SC_schedd_job_info, "schedd_job_info");
 
2249
   lSetUlong(ep, SC_flush_submit_sec, 128);
 
2250
   lSetUlong(ep, SC_flush_finish_sec, 512);
 
2251
   lSetString(ep, SC_params, "params");
 
2252
   lSetString(ep, SC_reprioritize_interval, "15");
 
2253
   lSetUlong(ep, SC_halftime, 32);
 
2254
   
 
2255
   lp = lCreateList("Usage Weight List", UA_Type);
 
2256
   
 
2257
   ep2 = lCreateElem(UA_Type);
 
2258
   lSetString(ep2, UA_name, "Test_Name3");
 
2259
   lSetDouble(ep2, UA_value, 11.22);
 
2260
   lAppendElem(lp, ep2);
 
2261
   
 
2262
   ep2 = lCreateElem(UA_Type);
 
2263
   lSetString(ep2, UA_name, "Test_Name4");
 
2264
   lSetDouble(ep2, UA_value, 33.44);
 
2265
   lAppendElem(lp, ep2);
 
2266
      
 
2267
   lSetList(ep, SC_usage_weight_list, lp);
 
2268
   
 
2269
   lSetDouble(ep, SC_compensation_factor, 11.22);
 
2270
   lSetDouble(ep, SC_weight_user, 11.22);
 
2271
   lSetDouble(ep, SC_weight_project, 33.44);
 
2272
   lSetDouble(ep, SC_weight_department, 66.77);
 
2273
   lSetDouble(ep, SC_weight_job, 88.99);
 
2274
   lSetUlong(ep, SC_weight_tickets_functional, 36);
 
2275
   lSetUlong(ep, SC_weight_tickets_share, 18);
 
2276
   lSetBool(ep, SC_share_override_tickets, true);
 
2277
   lSetBool(ep, SC_share_functional_shares, true);
 
2278
   lSetUlong(ep, SC_max_functional_jobs_to_schedule, 2048);
 
2279
   lSetBool(ep, SC_report_pjob_tickets, true);
 
2280
   lSetUlong(ep, SC_max_pending_tasks_per_job, 256);
 
2281
   lSetString(ep, SC_halflife_decay_list, "halflife_decay_list");
 
2282
   lSetString(ep, SC_policy_hierarchy, "policy_hierarchy");
 
2283
   lSetDouble(ep, SC_weight_ticket, 11.99);
 
2284
   lSetDouble(ep, SC_weight_waiting_time, 22.88);
 
2285
   lSetDouble(ep, SC_weight_deadline, 33.77);
 
2286
   lSetDouble(ep, SC_weight_urgency, 44.66);
 
2287
   lSetDouble(ep, SC_weight_priority, 55.99);
 
2288
   lSetUlong(ep, SC_max_reservation, 33.00);
 
2289
   lSetString(ep, SC_default_duration, "default_duration");
 
2290
 
 
2291
   printf("SC: No Args\n");   
 
2292
   /* Write a SC file using classic spooling */
 
2293
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
2294
                                       SC_fields,
 
2295
                                       &qconf_comma_sfi,
 
2296
                                       SP_DEST_TMP,
 
2297
                                       SP_FORM_ASCII, 
 
2298
                                       file1, false);
 
2299
   
 
2300
   /* Read a SC file using flatfile spooling */
 
2301
   lFreeElem(&ep);
 
2302
   ep = spool_flatfile_read_object(&alp, SC_Type, NULL,
 
2303
                                   SC_fields, NULL, true, &qconf_comma_sfi,
 
2304
                                   SP_FORM_ASCII, NULL, file1);
 
2305
   
 
2306
   /* Write a SC file using flatfile spooling */
 
2307
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
2308
                                       SC_fields,
 
2309
                                       &qconf_comma_sfi,
 
2310
                                       SP_DEST_TMP,
 
2311
                                       SP_FORM_ASCII, 
 
2312
                                       file2, false);
 
2313
   
 
2314
   lFreeElem(&ep);
 
2315
   
 
2316
   ret = diff(file1, file2);
 
2317
   
 
2318
   unlink(file1);
 
2319
   unlink(file2);
 
2320
   FREE(file1);
 
2321
   FREE(file2);
 
2322
   
 
2323
   answer_list_output(&alp);   
 
2324
   
 
2325
   return ret;
 
2326
}
 
2327
 
 
2328
static int QU_test(void)
 
2329
{
 
2330
   int ret = 0;
 
2331
   lListElem *ep = NULL;
 
2332
   lList * alp = NULL;
 
2333
   spooling_field *fields = NULL;
 
2334
   const char *file1 = NULL, *file2 = NULL;
 
2335
   
 
2336
   ep = lCreateElem(QU_Type);
 
2337
   lSetHost(ep, QU_qhostname, "Test_Name");
 
2338
   lSetString(ep, QU_qname, "Test_Name2");
 
2339
   lSetUlong(ep, QU_state, 1);
 
2340
   lSetUlong(ep, QU_pending_signal, 2);
 
2341
   lSetUlong(ep, QU_pending_signal_delivery_time, 3);
 
2342
   lSetUlong(ep, QU_version, 4);
 
2343
 
 
2344
   printf("QU: No Args\n");   
 
2345
 
 
2346
   fields = sge_build_QU_field_list(false, true);
 
2347
   
 
2348
   /* Write a QU file using classic spooling */
 
2349
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
2350
                                       fields,
 
2351
                                       &qconf_sfi,
 
2352
                                       SP_DEST_TMP,
 
2353
                                       SP_FORM_ASCII, 
 
2354
                                       file1, false);
 
2355
   
 
2356
   /* Read a QU file using flatfile spooling */
 
2357
   lFreeElem(&ep);
 
2358
   ep = spool_flatfile_read_object(&alp, QU_Type, NULL,
 
2359
                                   fields, NULL, true, &qconf_sfi,
 
2360
                                   SP_FORM_ASCII, NULL, file1);
 
2361
   
 
2362
   /* Write a QU file using flatfile spooling */
 
2363
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
2364
                                       fields,
 
2365
                                       &qconf_sfi,
 
2366
                                       SP_DEST_TMP,
 
2367
                                       SP_FORM_ASCII, 
 
2368
                                       file2, false);
 
2369
   
 
2370
   lFreeElem(&ep);
 
2371
   
 
2372
   ret = diff(file1, file2);
 
2373
   
 
2374
   unlink(file1);
 
2375
   unlink(file2);
 
2376
   FREE(file1);
 
2377
   FREE(file2);
 
2378
 
 
2379
   FREE(fields);
 
2380
   
 
2381
   answer_list_output(&alp);   
 
2382
   
 
2383
   return ret;
 
2384
}
 
2385
 
 
2386
static int HGRP_test(void)
 
2387
{
 
2388
   int ret = 0;
 
2389
   lListElem *ep = NULL;
 
2390
   lList * alp = NULL;
 
2391
   const char *file1 = NULL, *file2 = NULL;
 
2392
   
 
2393
   ep = lCreateElem(HGRP_Type);
 
2394
   lSetHost(ep, HGRP_name, "Test_Name");
 
2395
  
 
2396
   lAddSubHost(ep, HR_name, "Test_Name2", HGRP_host_list, HR_Type);
 
2397
   lAddSubHost(ep, HR_name, "Test_Name3", HGRP_host_list, HR_Type);
 
2398
   lAddSubHost(ep, HR_name, "Test_Name4", HGRP_host_list, HR_Type);
 
2399
   
 
2400
   printf("HGRP: No Args\n");   
 
2401
   
 
2402
   /* Write a HGRP file using classic spooling */
 
2403
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
2404
                                       HGRP_fields,
 
2405
                                       &qconf_sfi,
 
2406
                                       SP_DEST_TMP,
 
2407
                                       SP_FORM_ASCII, 
 
2408
                                       file1, false);
 
2409
   
 
2410
   /* Read a HGRP file using flatfile spooling */
 
2411
   lFreeElem(&ep);
 
2412
   ep = spool_flatfile_read_object(&alp, HGRP_Type, NULL,
 
2413
                                   HGRP_fields, NULL, true, &qconf_sfi,
 
2414
                                   SP_FORM_ASCII, NULL, file1);
 
2415
   
 
2416
   /* Write a HGRP file using flatfile spooling */
 
2417
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
2418
                                       HGRP_fields,
 
2419
                                       &qconf_sfi,
 
2420
                                       SP_DEST_TMP,
 
2421
                                       SP_FORM_ASCII, 
 
2422
                                       file2, false);
 
2423
   lFreeElem(&ep);
 
2424
   
 
2425
   ret = diff(file1, file2);
 
2426
   
 
2427
   unlink(file1);
 
2428
   unlink(file2);
 
2429
   FREE(file1);
 
2430
   FREE(file2);
 
2431
   
 
2432
   answer_list_output(&alp);   
 
2433
   
 
2434
   return ret;
 
2435
}
 
2436
 
 
2437
#ifndef __SGE_NO_USERMAPPING__
 
2438
static int CU_test(void)
 
2439
{
 
2440
   int ret = 0;
 
2441
   lListElem *ep = NULL;
 
2442
   lListElem *ep2 = NULL;
 
2443
   lList * lp = NULL;
 
2444
   lList * alp = NULL;
 
2445
   const char *file1 = NULL, *file2 = NULL;
 
2446
   
 
2447
   ep = lCreateElem(CU_Type);
 
2448
   lSetString(ep, CU_name, "Test_Name");
 
2449
   
 
2450
   lp = lCreateList("Remote User List", ASTR_Type);
 
2451
   
 
2452
   ep2 = lCreateElem(ASTR_Type);
 
2453
   lSetHost(ep2, ASTR_href, "Test_Name2");
 
2454
   lSetString(ep2, ASTR_value, "value");
 
2455
   lAppendElem(lp, ep2);
 
2456
   
 
2457
   ep2 = lCreateElem(ASTR_Type);
 
2458
   lSetHost(ep2, ASTR_href, "Test_Name3");
 
2459
   lSetString(ep2, ASTR_value, "value");
 
2460
   lAppendElem(lp, ep2);
 
2461
   
 
2462
   lSetList(ep, CU_ruser_list, lp);
 
2463
   
 
2464
   lp = lCreateList("Ulong32 List", AULNG_Type);
 
2465
   
 
2466
   ep2 = lCreateElem(AULNG_Type);
 
2467
   lSetHost(ep2, AULNG_href, "Test_Name4");
 
2468
   lSetUlong(ep2, AULNG_value, 13);
 
2469
   lAppendElem(lp, ep2);
 
2470
   
 
2471
   ep2 = lCreateElem(AULNG_Type);
 
2472
   lSetHost(ep2, AULNG_href, "Test_Name5");
 
2473
   lSetUlong(ep2, AULNG_value, 14);
 
2474
   lAppendElem(lp, ep2);
 
2475
   
 
2476
   lSetList(ep, CU_ulong32, lp);
 
2477
   
 
2478
   lp = lCreateList("Boolean List", ABOOL_Type);
 
2479
   
 
2480
   ep2 = lCreateElem(ABOOL_Type);
 
2481
   lSetHost(ep2, ABOOL_href, "Test_Name6");
 
2482
   lSetBool(ep2, ABOOL_value, true);
 
2483
   lAppendElem(lp, ep2);
 
2484
   
 
2485
   ep2 = lCreateElem(ABOOL_Type);
 
2486
   lSetHost(ep2, ABOOL_href, "Test_Name7");
 
2487
   lSetBool(ep2, ABOOL_value, false);
 
2488
   lAppendElem(lp, ep2);
 
2489
   
 
2490
   lSetList(ep, CU_bool, lp);
 
2491
   
 
2492
   lp = lCreateList("Time List", ATIME_Type);
 
2493
   
 
2494
   ep2 = lCreateElem(ATIME_Type);
 
2495
   lSetHost(ep2, ATIME_href, "Test_Name8");
 
2496
   lSetString(ep2, ATIME_value, "6");
 
2497
   lAppendElem(lp, ep2);
 
2498
   
 
2499
   ep2 = lCreateElem(ATIME_Type);
 
2500
   lSetHost(ep2, ATIME_href, "Test_Name9");
 
2501
   lSetString(ep2, ATIME_value, "5");
 
2502
   lAppendElem(lp, ep2);
 
2503
   
 
2504
   lSetList(ep, CU_time, lp);
 
2505
   
 
2506
   lp = lCreateList("Memory List", AMEM_Type);
 
2507
   
 
2508
   ep2 = lCreateElem(AMEM_Type);
 
2509
   lSetHost(ep2, AMEM_href, "Test_Name10");
 
2510
   lSetString(ep2, AMEM_value, "4");
 
2511
   lAppendElem(lp, ep2);
 
2512
   
 
2513
   ep2 = lCreateElem(AMEM_Type);
 
2514
   lSetHost(ep2, AMEM_href, "Test_Name11");
 
2515
   lSetString(ep2, AMEM_value, "3");
 
2516
   lAppendElem(lp, ep2);
 
2517
   
 
2518
   lSetList(ep, CU_mem, lp);
 
2519
   
 
2520
   lp = lCreateList("Inter List", AINTER_Type);
 
2521
   
 
2522
   ep2 = lCreateElem(AINTER_Type);
 
2523
   lSetHost(ep2, AINTER_href, "Test_Name10");
 
2524
   lSetString(ep2, AINTER_value, "2");
 
2525
   lAppendElem(lp, ep2);
 
2526
   
 
2527
   ep2 = lCreateElem(AINTER_Type);
 
2528
   lSetHost(ep2, AINTER_href, "Test_Name11");
 
2529
   lSetString(ep2, AINTER_value, "1");
 
2530
   lAppendElem(lp, ep2);
 
2531
   
 
2532
   lSetList(ep, CU_inter, lp);
 
2533
   
 
2534
   printf("CU: No Args\n");   
 
2535
   
 
2536
   /* Write a CU file using classic spooling */
 
2537
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
2538
                                       CU_fields,
 
2539
                                       &qconf_comma_braced_sfi,
 
2540
                                       SP_DEST_TMP,
 
2541
                                       SP_FORM_ASCII, 
 
2542
                                       file1, false);
 
2543
   
 
2544
   /* Read a CU file using flatfile spooling */
 
2545
   lFreeElem(&ep);
 
2546
   ep = spool_flatfile_read_object(&alp, CU_Type, NULL,
 
2547
                                   CU_fields, NULL, true, &qconf_comma_braced_sfi,
 
2548
                                   SP_FORM_ASCII, NULL, file1);
 
2549
   
 
2550
   /* Write a CU file using flatfile spooling */
 
2551
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
2552
                                       CU_fields,
 
2553
                                       &qconf_comma_braced_sfi,
 
2554
                                       SP_DEST_TMP,
 
2555
                                       SP_FORM_ASCII, 
 
2556
                                       file2, false);
 
2557
   
 
2558
   lFreeElem(&ep);
 
2559
   
 
2560
   ret = diff(file1, file2);
 
2561
   
 
2562
   unlink(file1);
 
2563
   unlink(file2);
 
2564
   FREE(file1);
 
2565
   FREE(file2);
 
2566
   
 
2567
   
 
2568
   answer_list_output(&alp);   
 
2569
   
 
2570
   return ret;
 
2571
}
 
2572
#endif
 
2573
 
 
2574
static int CONF_test(void) {
 
2575
   int ret = 0;
 
2576
   lListElem *ep = NULL;
 
2577
   lListElem *ep2 = NULL;
 
2578
   lList * lp = NULL;
 
2579
   lList * alp = NULL;
 
2580
   spooling_field *fields;
 
2581
   const char *file1 = NULL;
 
2582
   const char *file2 = NULL;
 
2583
   
 
2584
   ep = lCreateElem(CONF_Type);
 
2585
   lSetUlong(ep, CONF_version, 101);
 
2586
   lSetHost(ep, CONF_name, "host1");
 
2587
   
 
2588
   lp = lCreateList("Config List", CF_Type);
 
2589
   
 
2590
   ep2 = lCreateElem(CF_Type);
 
2591
   lSetString(ep2, CF_name, "gid_range");
 
2592
   lSetString(ep2, CF_value, "1000-1100");
 
2593
   lAppendElem(lp, ep2);
 
2594
   
 
2595
   ep2 = lCreateElem(CF_Type);
 
2596
   lSetString(ep2, CF_name, "gid_range");
 
2597
   lSetString(ep2, CF_value, "1001");
 
2598
   lAppendElem(lp, ep2);
 
2599
   
 
2600
   ep2 = lCreateElem(CF_Type);
 
2601
   lSetString(ep2, CF_name, "admin_user");
 
2602
   lSetString(ep2, CF_value, "testuser");
 
2603
   lAppendElem(lp, ep2);
 
2604
   
 
2605
   ep2 = lCreateElem(CF_Type);
 
2606
   lSetString(ep2, CF_name, "user_lists");
 
2607
   lSetString(ep2, CF_value, "me you someone_else");
 
2608
   lAppendElem(lp, ep2);
 
2609
   
 
2610
   ep2 = lCreateElem(CF_Type);
 
2611
   lSetString(ep2, CF_name, "login_shells");
 
2612
   lSetString(ep2, CF_value, "sh,ksh,csh,tcsh");
 
2613
   lAppendElem(lp, ep2);
 
2614
 
 
2615
   ep2 = lCreateElem(CF_Type);
 
2616
   lSetString(ep2, CF_name, "execd_params");
 
2617
   lSetString(ep2, CF_value, "PTF_MIN_PRIORITY=20,PTF_MAX_PRIORITY=0,SET_LIB_PATH=true");
 
2618
   lAppendElem(lp, ep2);
 
2619
 
 
2620
   ep2 = lCreateElem(CF_Type);
 
2621
   lSetString(ep2, CF_name, "reporting_params");
 
2622
   lSetString(ep2, CF_value, "accounting=true reporting=false flush_time=00:00:05 joblog=true sharelog=00:10:00=true");
 
2623
   lAppendElem(lp, ep2);
 
2624
   
 
2625
   lSetList(ep, CONF_entries, lp);
 
2626
   
 
2627
   printf("CONF: No Args\n");
 
2628
 
 
2629
   fields = sge_build_CONF_field_list(true);
 
2630
   
 
2631
   /* Write a CU file using classic spooling */
 
2632
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
2633
                                       fields,
 
2634
                                       &qconf_sfi,
 
2635
                                       SP_DEST_TMP,
 
2636
                                       SP_FORM_ASCII, 
 
2637
                                       file1, true);
 
2638
 
 
2639
   
 
2640
   /* Read a CU file using flatfile spooling */
 
2641
   lFreeElem(&ep);
 
2642
   ep = spool_flatfile_read_object(&alp, CONF_Type, NULL,
 
2643
                                   fields, NULL, false, &qconf_sfi,
 
2644
                                   SP_FORM_ASCII, NULL, file1);
 
2645
 
 
2646
   /* Write a CU file using flatfile spooling */
 
2647
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
2648
                                       fields,
 
2649
                                       &qconf_sfi,
 
2650
                                       SP_DEST_TMP,
 
2651
                                       SP_FORM_ASCII, 
 
2652
                                       file2, true);
 
2653
 
 
2654
   lFreeElem(&ep);
 
2655
   
 
2656
   ret = diff(file1, file2);
 
2657
   
 
2658
   unlink(file1);
 
2659
   unlink(file2);
 
2660
   FREE(file1);
 
2661
   FREE(file2);
 
2662
   FREE(fields);
 
2663
   
 
2664
   
 
2665
   answer_list_output(&alp);   
 
2666
   
 
2667
   return ret;
 
2668
}
 
2669
 
 
2670
static int RQS_test(void) {
 
2671
   int ret = 0;
 
2672
   lListElem *ep = NULL;
 
2673
   lListElem *ep2 = NULL;
 
2674
   lListElem *ep3 = NULL;
 
2675
   lListElem *limit = NULL;
 
2676
   lList *lp1 = NULL;
 
2677
   lList *limit_list= NULL;
 
2678
   lList *alp = NULL;
 
2679
   const char *file1 = NULL;
 
2680
   const char *file2 = NULL;
 
2681
   lList* rqs_list = lCreateList("test", RQS_Type);
 
2682
 
 
2683
   ep = lCreateElem(RQS_Type);
 
2684
   lSetString(ep, RQS_name, "Test_Name1");
 
2685
   lSetString(ep, RQS_description, "Test Description");
 
2686
   lSetBool(ep, RQS_enabled, false);
 
2687
   lp1 = lCreateList("Rule_List", RQR_Type);
 
2688
   /* rule 1 */
 
2689
   ep2 = lCreateElem(RQR_Type);
 
2690
      ep3 = lCreateElem(RQRF_Type);
 
2691
      lSetBool(ep3, RQRF_expand, true);
 
2692
      lAddSubStr(ep3, ST_name, "Test_User1", RQRF_scope, ST_Type);
 
2693
 
 
2694
      lAddSubStr(ep3, ST_name, "Test_User2", RQRF_xscope, ST_Type);
 
2695
      lAddSubStr(ep3, ST_name, "Test_User3", RQRF_xscope, ST_Type);
 
2696
      lSetObject(ep2, RQR_filter_users, ep3);
 
2697
 
 
2698
      limit_list = lCreateList("Limit_List", RQRL_Type);
 
2699
      limit = lCreateElem(RQRL_Type);
 
2700
      lSetString(limit, RQRL_name, "slots");
 
2701
      lSetString(limit, RQRL_value, "2*$num_proc");
 
2702
      lAppendElem(limit_list, limit);
 
2703
      lSetList(ep2, RQR_limit, limit_list);
 
2704
   lAppendElem(lp1, ep2);
 
2705
   /* rule 2 */
 
2706
   ep2 = lCreateElem(RQR_Type);
 
2707
      ep3 = lCreateElem(RQRF_Type);
 
2708
      lSetBool(ep3, RQRF_expand, true);
 
2709
      lAddSubStr(ep3, ST_name, "Test_Queue1", RQRF_scope, ST_Type);
 
2710
 
 
2711
      lAddSubStr(ep3, ST_name, "Test_Queue2", RQRF_xscope, ST_Type);
 
2712
      lSetObject(ep2, RQR_filter_queues, ep3);
 
2713
 
 
2714
      limit_list = lCreateList("Limit_List", RQRL_Type);
 
2715
      limit = lCreateElem(RQRL_Type);
 
2716
      lSetString(limit, RQRL_name, "arch");
 
2717
      lSetString(limit, RQRL_value, "lx24-amd64");
 
2718
      lAppendElem(limit_list, limit);
 
2719
      lSetList(ep2, RQR_limit, limit_list);
 
2720
   lAppendElem(lp1, ep2);
 
2721
   /* rule 3 */
 
2722
   ep2 = lCreateElem(RQR_Type);
 
2723
   lSetString(ep2, RQR_name, "rule3");
 
2724
      ep3 = lCreateElem(RQRF_Type);
 
2725
      lSetBool(ep3, RQRF_expand, true);
 
2726
      lAddSubStr(ep3, ST_name, "Test_Pe1", RQRF_scope, ST_Type);
 
2727
 
 
2728
      lAddSubStr(ep3, ST_name, "Test_Pe2", RQRF_xscope, ST_Type);
 
2729
      lSetObject(ep2, RQR_filter_pes, ep3);
 
2730
 
 
2731
      limit_list = lCreateList("Limit_List", RQRL_Type);
 
2732
      limit = lCreateElem(RQRL_Type);
 
2733
      lSetString(limit, RQRL_name, "mem");
 
2734
      lSetString(limit, RQRL_value, "1G");
 
2735
      lAppendElem(limit_list, limit);
 
2736
      lSetList(ep2, RQR_limit, limit_list);
 
2737
   lAppendElem(lp1, ep2);
 
2738
   lSetList(ep, RQS_rule, lp1);
 
2739
   lAppendElem(rqs_list, ep);
 
2740
 
 
2741
   /* rule 4 */
 
2742
   ep = lCreateElem(RQS_Type);
 
2743
   lSetString(ep, RQS_name, "Test_Name2");
 
2744
   lSetString(ep, RQS_description, "Test Description");
 
2745
   lSetBool(ep, RQS_enabled, true);
 
2746
   lp1 = lCreateList("Rule_List", RQR_Type);
 
2747
   ep2 = lCreateElem(RQR_Type);
 
2748
      ep3 = lCreateElem(RQRF_Type);
 
2749
      lSetBool(ep3, RQRF_expand, false);
 
2750
      lAddSubStr(ep3, ST_name, "roland", RQRF_scope, ST_Type);
 
2751
 
 
2752
      lAddSubStr(ep3, ST_name, "andre", RQRF_xscope, ST_Type);
 
2753
      lSetObject(ep2, RQR_filter_users, ep3);
 
2754
 
 
2755
      limit_list = lCreateList("Limit_List", RQRL_Type);
 
2756
      /* first limit */
 
2757
      limit = lCreateElem(RQRL_Type);
 
2758
      lSetString(limit, RQRL_name, "mem");
 
2759
      lSetString(limit, RQRL_value, "10G");
 
2760
      lAppendElem(limit_list, limit);
 
2761
      /* second limit */
 
2762
      limit = lCreateElem(RQRL_Type);
 
2763
      lSetString(limit, RQRL_name, "arch");
 
2764
      lSetString(limit, RQRL_value, "sol-sparc64");
 
2765
      lAppendElem(limit_list, limit);
 
2766
 
 
2767
      lSetList(ep2, RQR_limit, limit_list);
 
2768
   lAppendElem(lp1, ep2);
 
2769
   lSetList(ep, RQS_rule, lp1);
 
2770
   lAppendElem(rqs_list, ep);
 
2771
 
 
2772
   printf("RQRF: No Args\n");   
 
2773
 
 
2774
   /* Write a RQS file using classic spooling */
 
2775
   file1 = spool_flatfile_write_list(&alp, rqs_list, RQS_fields, &qconf_rqs_sfi, SP_DEST_TMP, SP_FORM_ASCII, file1, false);
 
2776
 
 
2777
   /* Read a RQS file using flatfile spooling */
 
2778
   lFreeList(&rqs_list);
 
2779
   rqs_list = spool_flatfile_read_list(&alp, RQS_Type, RQS_fields, NULL, true, &qconf_rqs_sfi,
 
2780
                                   SP_FORM_ASCII, NULL, file1);
 
2781
 
 
2782
   /* Write a RQS file using flatfile spooling */
 
2783
   file2 = spool_flatfile_write_list(&alp, rqs_list, RQS_fields, &qconf_rqs_sfi, SP_DEST_TMP, SP_FORM_ASCII, file2, false);
 
2784
   lFreeList(&rqs_list);
 
2785
 
 
2786
   ret = diff(file1, file2);
 
2787
 
 
2788
   unlink(file1);
 
2789
   unlink(file2);
 
2790
 
 
2791
   FREE(file1);
 
2792
   FREE(file2);
 
2793
 
 
2794
   answer_list_output(&alp);
 
2795
 
 
2796
   return ret;
 
2797
}
 
2798
 
 
2799
static int AR_test(void) {
 
2800
   int ret = 0;
 
2801
   lList *lp;
 
2802
   lListElem *ep = NULL;
 
2803
   lListElem *ep1;
 
2804
   lList *alp = NULL;
 
2805
   const char *file1 = NULL, *file2 = NULL;
 
2806
   
 
2807
   ep = lCreateElem(AR_Type);
 
2808
   lSetUlong(ep, AR_id, 1);
 
2809
   lSetString(ep, AR_name, "Test_Name");
 
2810
 
 
2811
   lp = lCreateList("range_list", RN_Type);
 
2812
   ep1 = lCreateElem(RN_Type);
 
2813
   lSetUlong(ep1, RN_min, 1);
 
2814
   lSetUlong(ep1, RN_max, 2);
 
2815
   lSetUlong(ep1, RN_step, 3);
 
2816
   lAppendElem(lp, ep1);
 
2817
   ep1 = lCreateElem(RN_Type);
 
2818
   lSetUlong(ep1, RN_min, 4);
 
2819
   lSetUlong(ep1, RN_max, 5);
 
2820
   lSetUlong(ep1, RN_step, 6);
 
2821
   lAppendElem(lp, ep1);
 
2822
   lSetList(ep, AR_pe_range, lp);
 
2823
 
 
2824
   lp = lCreateList("resource_list", CE_Type);
 
2825
   ep1 = lCreateElem(CE_Type);
 
2826
   lSetString(ep1, CE_name, "ce1");
 
2827
   lSetString(ep1, CE_stringval, "101");
 
2828
   lAppendElem(lp, ep1);
 
2829
   ep1 = lCreateElem(CE_Type);
 
2830
   lSetString(ep1, CE_name, "ce2");
 
2831
   lSetDouble(ep1, CE_doubleval, 102);
 
2832
   lAppendElem(lp, ep1);
 
2833
   lSetList(ep, AR_resource_list, lp);
 
2834
 
 
2835
   lAddSubStr(ep, QR_name, "queue1.q", AR_queue_list, QR_Type);
 
2836
   lAddSubStr(ep, QR_name, "queue2.q", AR_queue_list, QR_Type);
 
2837
   lAddSubStr(ep, QR_name, "queue3.q", AR_queue_list, QR_Type);
 
2838
   lAddSubStr(ep, QR_name, "queue4.q", AR_queue_list, QR_Type);
 
2839
 
 
2840
   ep1 = lAddSubStr(ep, JG_qname, "all.q@bla", AR_granted_slots, JG_Type);
 
2841
   lSetUlong(ep1, JG_slots, 5);
 
2842
   ep1 = lAddSubStr(ep, JG_qname, "my.q@bla", AR_granted_slots, JG_Type);
 
2843
   lSetUlong(ep1, JG_slots, 10);
 
2844
 
 
2845
   lAddSubStr(ep, MR_user, "user1", AR_mail_list, MR_Type);
 
2846
   ep1 = lAddSubStr(ep, MR_user, "user2", AR_mail_list, MR_Type);
 
2847
   lSetHost(ep1, MR_host, "sun.com");
 
2848
 
 
2849
   lAddSubStr(ep, QR_name, "queue1.q", AR_master_queue_list, QR_Type);
 
2850
   lAddSubStr(ep, QR_name, "queue2.q", AR_master_queue_list, QR_Type);
 
2851
   lAddSubStr(ep, QR_name, "queue3.q", AR_master_queue_list, QR_Type);
 
2852
   lAddSubStr(ep, QR_name, "queue4.q", AR_master_queue_list, QR_Type);
 
2853
 
 
2854
   ep1 = lAddSubStr(ep, ARA_name, "user1", AR_acl_list, ARA_Type);
 
2855
   lSetString(ep1, ARA_group, "group1");
 
2856
   ep1 = lAddSubStr(ep, ARA_name, "user2", AR_acl_list, ARA_Type);
 
2857
   lSetString(ep1, ARA_group, "group2");
 
2858
   lAddSubStr(ep, ARA_name, "@userset1", AR_acl_list, ARA_Type);
 
2859
   lAddSubStr(ep, ARA_name, "@userset2", AR_acl_list, ARA_Type);
 
2860
 
 
2861
  
 
2862
   printf("AR: No Args\n");   
 
2863
   
 
2864
   /* Write a AR file using classic spooling */
 
2865
   file1 = spool_flatfile_write_object(&alp, ep, false,
 
2866
                                       AR_fields,
 
2867
                                       &qconf_sfi,
 
2868
                                       SP_DEST_TMP,
 
2869
                                       SP_FORM_ASCII, 
 
2870
                                       file1, true);
 
2871
 
 
2872
   /* Read a AR file using flatfile spooling */
 
2873
   lFreeElem(&ep);
 
2874
   ep = spool_flatfile_read_object(&alp, AR_Type, NULL,
 
2875
                                   AR_fields, NULL, true, &qconf_sfi,
 
2876
                                   SP_FORM_ASCII, NULL, file1);
 
2877
   
 
2878
   /* Write a AR file using flatfile spooling */
 
2879
   file2 = spool_flatfile_write_object(&alp, ep, false,
 
2880
                                       AR_fields,
 
2881
                                       &qconf_sfi,
 
2882
                                       SP_DEST_TMP,
 
2883
                                       SP_FORM_ASCII, 
 
2884
                                       file2, true);
 
2885
   lFreeElem(&ep);
 
2886
 
 
2887
   ret = diff(file1, file2);
 
2888
  
 
2889
   unlink(file1);
 
2890
   unlink(file2);
 
2891
   FREE(file1);
 
2892
   FREE(file2);
 
2893
   
 
2894
   answer_list_output(&alp);   
 
2895
   return ret;
 
2896
}