Merge lp:~jamesodhunt/upstart/override-support into lp:~canonical-scott/upstart/trunk
- override-support
- Merge into trunk
Proposed by
James Hunt
| Status: | Needs review |
|---|---|
| Proposed branch: | lp:~jamesodhunt/upstart/override-support |
| Merge into: | lp:~canonical-scott/upstart/trunk |
| Diff against target: |
4846 lines (+2341/-335) 12 files modified
init/conf.c (+492/-52) init/conf.h (+40/-0) init/job_class.c (+1/-1) init/man/init.5 (+144/-23) init/man/init.8 (+2/-1) init/parse_conf.c (+6/-0) init/parse_job.c (+18/-6) init/parse_job.h (+3/-3) init/paths.h (+50/-0) init/tests/test_conf.c (+1295/-2) init/tests/test_parse_job.c (+282/-243) util/man/initctl.8 (+8/-4) |
| To merge this branch: | bzr merge lp:~jamesodhunt/upstart/override-support |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Scott James Remnant | Pending | ||
|
Review via email:
|
|||
This proposal supersedes a proposal from 2011-01-12.
Commit message
Description of the change
Hi Scott,
I've re-submitted the branch with the following changes:
- init/main.c hack killed (I'm so used to writing cross-platform code, I forget about the gcc extensions :-)
- init/parse_conf.c: this assert is still there as although you are strictly correct, I do think we need a reminder of some sort.
Without the override support it isn't an issue since parse_conf() either has stanza support or it doesn't.
However, we need to ensure that if stanzas are allowed in init.conf that we not only add that support to parse_conf() but that
we also ensure that we add override support (a separate task). I'm happy to remove this assert but I feel we need something
guaranteed to force an error if we forget to add override support. I've added a test to test_override() which ensures that
override are ignored for CONF_FILE objects but that's kinda the other half of the problem.
- init/parse_job.c: simplified logic as you suggested.
- stanza_manual(): reverted to original code at your suggestion.
- init/conf.c: moved macros to paths.h as you suggested.
- toggle_conf_name() now accpepts parent pointer. Updated tests to ensure parent pointer behaviour correct.
- conf_reload: ENOENT guard. I took this out to ensure the error is thrown if conf files/dirs do not exist: with the original
code, if either of init.conf or /etc/init/ do not exist, you get no error message. This is bad in the scenario that /etc/init/ does not
exist since even if it does later get created, upstart will not see it of course. With the guard in place, the admin has no idea
there is a problem. Without the guard, you do admittedly get an error when upstart fails to read init.conf, but I thought that was
the lesser of the two evils. If you want the guard retained, maybe we could error iff we fail to read any single non-zero
conf file?
- conf_source_*: repaired all tab damage (in fact, there a a few spots where I've corrected the indentation since it was not
conformant to vim's "cinoptions=:0").
- debug_*(): yes, there are for gdb only (mentioned in commit msg).
- I've added extra tests to test_override() for non-inotify systems.
- removed typo changes - will submit them in a different branch as requested.
_______
Implemented override feature on blueprint:
https:/
* Generic
- fixed typos.
- addition of debug functions useful for gdb sessions (available
only in DEBUG build).
* init/conf.c:
- (conf_reload): Removed ENOENT check to ensure error thrown if
conf files/dirs do not exist.
- (conf_reload_path): Now takes an extra override_path parameter.
- (is_conf_
functions to determine type of given file path.
- (toggle_conf_name): New function which convert a conf file
name to an override name and vice versa.
- majority of remaining functions updated to handle override
files.
* init/man/init.5: Updated to document override file support.
* init/man/init.8: Added reference to control-
* init/paths.h: New macros CONF_EXT_OVERRIDE, CONF_EXT_STD,
IS_
* init/parse_conf.c: Added assertion to remind us forcibly to add
override-
'init.conf'.
* init/parse_job.c (parse_job): Additional parameter 'update' to
allow override files to replace existing Job details.
* init/test_conf.c
- New macros TEST_ENSURE_
- test_override(): New function.
- test_toggle_
* init/test_
- Updated for extra parse_job() parameter
- added a test feature to test_parse_job() to exercise new
parameter to parse_job().
* util/man/initctl.8: Clarified what it means to restart a job.
To test:
make check
To post a comment you must log in.
Revision history for this message
| Scott James Remnant (scott) wrote : Posted in a previous version of this proposal | # |
- 1261. By James Hunt
-
* (debug_
count_list_ entries) : Fixed debug function which always counted
conf_sources list, rather than that specified.
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Hello!
New message, please read <http://
<email address hidden>
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Hello!
New message, please read <http://
<email address hidden>
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Hey, Don't miss up this new stuff, you're going to be delighted, read more here <http://
Best, <email address hidden>
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Hey, Don't miss up this new stuff, you're going to be delighted, read more here <http://
Best, <email address hidden>
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Hello friend,
Look what I've found on the web, it is something new and really cool, you'lllove it. More info here <http://
Sincerely yours, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Hello friend,
Look what I've found on the web, it is something new and really cool, you'lllove it. More info here <http://
Sincerely yours, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Yo!
Have you read this new book already? I'm so delighted with it, please read it here http://
Hugs, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Yo!
Have you read this new book already? I'm so delighted with it, please read it here http://
Hugs, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Hey,
I'd like to show you a nice gift a friend of mine gave me recently, it's something really cool)) Please take a look http://
Hope this helps, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Hey,
I'd like to show you a nice gift a friend of mine gave me recently, it's something really cool)) Please take a look http://
Hope this helps, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Hello,
I know you're interested in stuff like that, that is something really cool, just take a look http://
Hope this helps, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Hello,
I know you're interested in stuff like that, that is something really cool, just take a look http://
Hope this helps, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Dear,
I was amazed by that shocking article I've recently read, please read it and tell me your opinion http://
Warmest regards, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Dear,
I was amazed by that shocking article I've recently read, please read it and tell me your opinion http://
Warmest regards, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Hello friend,
I've recently came across that amazing stuff, it looks nice I think, take a look http://
Yours sincerely, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Hello friend,
I've recently came across that amazing stuff, it looks nice I think, take a look http://
Yours sincerely, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : | # |
Yo!
I've recently seen some nice stuff that might be useful for you, just take a look http://
My Best, philipp
Revision history for this message
| Philipp Schlesinger (philipp-sadleder) wrote : Posted in a previous version of this proposal | # |
Yo!
I've recently seen some nice stuff that might be useful for you, just take a look http://
My Best, philipp
Unmerged revisions
- 1261. By James Hunt
-
* (debug_
count_list_ entries) : Fixed debug function which always counted
conf_sources list, rather than that specified. - 1260. By James Hunt
-
* Generic
- fixed typos.
- addition of debug functions useful for gdb sessions (available
only in DEBUG build).
* init/conf.c:
- (conf_reload): Removed ENOENT check to ensure error thrown if
conf files/dirs do not exist.
- (conf_reload_path): Now takes an extra override_path parameter.
- (is_conf_file/is_ conf_file_ std/is_ conf_file_ override) : New
functions to determine type of given file path.
- (toggle_conf_name): New function which convert a conf file
name to an override name and vice versa.
- majority of remaining functions updated to handle override
files.
* init/man/init.5: Updated to document override file support.
* init/man/init.8: Added reference to control-alt-delete( 7) man page.
* init/paths.h: New macros CONF_EXT_OVERRIDE, CONF_EXT_STD,
IS_CONF_FILE_OVERRIDE and IS_CONF_FILE_STD.
* init/parse_conf.c: Added assertion to remind us forcibly to add
override-handling code for directories if we ever allow content in
'init.conf'.
* init/parse_job.c (parse_job): Additional parameter 'update' to
allow override files to replace existing Job details.
* init/test_conf.c
- New macros TEST_ENSURE_CLEAN_ENV( ) and
TEST_FORCE_WATCH_ UPDATE( ).
- test_override(): New function.
- test_toggle_conf_name( ): New function.
* init/test_parse_job. c:
- Updated for extra parse_job() parameter
- added a test feature to test_parse_job() to exercise new
parameter to parse_job().
* util/man/initctl.8: Clarified what it means to restart a job.
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'init/conf.c' | |||
| 2 | --- init/conf.c 2009-07-08 21:05:59 +0000 | |||
| 3 | +++ init/conf.c 2011-01-21 11:55:09 +0000 | |||
| 4 | @@ -48,7 +48,7 @@ | |||
| 5 | 48 | #include "parse_conf.h" | 48 | #include "parse_conf.h" |
| 6 | 49 | #include "conf.h" | 49 | #include "conf.h" |
| 7 | 50 | #include "errors.h" | 50 | #include "errors.h" |
| 9 | 51 | 51 | #include "paths.h" | |
| 10 | 52 | 52 | ||
| 11 | 53 | /* Prototypes for static functions */ | 53 | /* Prototypes for static functions */ |
| 12 | 54 | static int conf_source_reload_file (ConfSource *source) | 54 | static int conf_source_reload_file (ConfSource *source) |
| 13 | @@ -70,9 +70,19 @@ | |||
| 14 | 70 | struct stat *statbuf) | 70 | struct stat *statbuf) |
| 15 | 71 | __attribute__ ((warn_unused_result)); | 71 | __attribute__ ((warn_unused_result)); |
| 16 | 72 | 72 | ||
| 20 | 73 | static int conf_reload_path (ConfSource *source, const char *path) | 73 | static int conf_reload_path (ConfSource *source, const char *path, |
| 21 | 74 | __attribute__ ((warn_unused_result)); | 74 | const char *override_path) |
| 22 | 75 | 75 | __attribute__ ((warn_unused_result)); | |
| 23 | 76 | |||
| 24 | 77 | static inline int is_conf_file (const char *path) | ||
| 25 | 78 | __attribute__ ((warn_unused_result)); | ||
| 26 | 79 | |||
| 27 | 80 | static inline int is_conf_file_std (const char *path) | ||
| 28 | 81 | __attribute__ ((warn_unused_result)); | ||
| 29 | 82 | |||
| 30 | 83 | static inline int | ||
| 31 | 84 | is_conf_file_override (const char *path) | ||
| 32 | 85 | __attribute__ ((warn_unused_result)); | ||
| 33 | 76 | 86 | ||
| 34 | 77 | /** | 87 | /** |
| 35 | 78 | * conf_sources: | 88 | * conf_sources: |
| 36 | @@ -85,6 +95,115 @@ | |||
| 37 | 85 | 95 | ||
| 38 | 86 | 96 | ||
| 39 | 87 | /** | 97 | /** |
| 40 | 98 | * is_conf_file_std: | ||
| 41 | 99 | * @path: path to check. | ||
| 42 | 100 | * | ||
| 43 | 101 | * Determine if specified path contains a legitimate | ||
| 44 | 102 | * configuration file name. | ||
| 45 | 103 | * | ||
| 46 | 104 | * Returns: TRUE if @path contains a valid configuration file name, | ||
| 47 | 105 | * else FALSE. | ||
| 48 | 106 | * | ||
| 49 | 107 | **/ | ||
| 50 | 108 | static inline int | ||
| 51 | 109 | is_conf_file_std (const char *path) | ||
| 52 | 110 | { | ||
| 53 | 111 | char *ptr = strrchr (path, '.'); | ||
| 54 | 112 | |||
| 55 | 113 | if (ptr && IS_CONF_EXT_STD (ptr)) | ||
| 56 | 114 | return TRUE; | ||
| 57 | 115 | |||
| 58 | 116 | return FALSE; | ||
| 59 | 117 | } | ||
| 60 | 118 | |||
| 61 | 119 | /** | ||
| 62 | 120 | * is_conf_file_override: | ||
| 63 | 121 | * @path: path to check. | ||
| 64 | 122 | * | ||
| 65 | 123 | * Determine if specified path contains a legitimate | ||
| 66 | 124 | * override file name. | ||
| 67 | 125 | * | ||
| 68 | 126 | * Returns: TRUE if @path contains a valid override file name, | ||
| 69 | 127 | * else FALSE. | ||
| 70 | 128 | * | ||
| 71 | 129 | **/ | ||
| 72 | 130 | static inline int | ||
| 73 | 131 | is_conf_file_override (const char *path) | ||
| 74 | 132 | { | ||
| 75 | 133 | char *ptr = strrchr (path, '.'); | ||
| 76 | 134 | |||
| 77 | 135 | if (ptr && IS_CONF_EXT_OVERRIDE (ptr)) | ||
| 78 | 136 | return TRUE; | ||
| 79 | 137 | |||
| 80 | 138 | return FALSE; | ||
| 81 | 139 | } | ||
| 82 | 140 | |||
| 83 | 141 | /** | ||
| 84 | 142 | * is_conf_file: | ||
| 85 | 143 | * @path: path to check. | ||
| 86 | 144 | * | ||
| 87 | 145 | * Determine if specified path contains a legitimate | ||
| 88 | 146 | * configuration file or override file name. | ||
| 89 | 147 | * | ||
| 90 | 148 | * Returns: TRUE if @path contains a valid configuration | ||
| 91 | 149 | * file or override file name, else FALSE. | ||
| 92 | 150 | * | ||
| 93 | 151 | **/ | ||
| 94 | 152 | static inline int | ||
| 95 | 153 | is_conf_file (const char *path) | ||
| 96 | 154 | { | ||
| 97 | 155 | char *ptr = strrchr (path, '.'); | ||
| 98 | 156 | |||
| 99 | 157 | if (ptr && IS_CONF_EXT (ptr)) | ||
| 100 | 158 | return TRUE; | ||
| 101 | 159 | |||
| 102 | 160 | return FALSE; | ||
| 103 | 161 | } | ||
| 104 | 162 | |||
| 105 | 163 | /** | ||
| 106 | 164 | * Convert a configuration file name to an override file name and vice | ||
| 107 | 165 | * versa. | ||
| 108 | 166 | * | ||
| 109 | 167 | * For example, if @path is "foo.conf", this function will return | ||
| 110 | 168 | * "foo.override", whereas if @path is "foo.override", it will return | ||
| 111 | 169 | * "foo.conf". | ||
| 112 | 170 | * | ||
| 113 | 171 | * Note that this function should be static, but isn't to allow the | ||
| 114 | 172 | * tests to access it. | ||
| 115 | 173 | * | ||
| 116 | 174 | * @parent: parent of returned path, | ||
| 117 | 175 | * @path: path to a configuration file. | ||
| 118 | 176 | * | ||
| 119 | 177 | * Returns: newly allocated toggled path, or NULL on error. | ||
| 120 | 178 | **/ | ||
| 121 | 179 | char * | ||
| 122 | 180 | toggle_conf_name (const void *parent, | ||
| 123 | 181 | const char *path) | ||
| 124 | 182 | { | ||
| 125 | 183 | char *new_path; | ||
| 126 | 184 | char *ext; | ||
| 127 | 185 | char *new_ext; | ||
| 128 | 186 | size_t len; | ||
| 129 | 187 | |||
| 130 | 188 | ext = strrchr (path, '.'); | ||
| 131 | 189 | if (!ext) | ||
| 132 | 190 | return NULL; | ||
| 133 | 191 | |||
| 134 | 192 | new_ext = IS_CONF_EXT_STD (ext) | ||
| 135 | 193 | ? CONF_EXT_OVERRIDE | ||
| 136 | 194 | : CONF_EXT_STD; | ||
| 137 | 195 | |||
| 138 | 196 | len = strlen (new_ext); | ||
| 139 | 197 | |||
| 140 | 198 | new_path = NIH_MUST (nih_strndup (parent, path, (ext - path) + len)); | ||
| 141 | 199 | |||
| 142 | 200 | memcpy (new_path + (ext - path), new_ext, len); | ||
| 143 | 201 | |||
| 144 | 202 | return new_path; | ||
| 145 | 203 | } | ||
| 146 | 204 | |||
| 147 | 205 | |||
| 148 | 206 | /** | ||
| 149 | 88 | * conf_init: | 207 | * conf_init: |
| 150 | 89 | * | 208 | * |
| 151 | 90 | * Initialise the conf_sources list. | 209 | * Initialise the conf_sources list. |
| 152 | @@ -232,10 +351,9 @@ | |||
| 153 | 232 | NihError *err; | 351 | NihError *err; |
| 154 | 233 | 352 | ||
| 155 | 234 | err = nih_error_get (); | 353 | err = nih_error_get (); |
| 160 | 235 | if (err->number != ENOENT) | 354 | nih_error ("%s: %s: %s", source->path, |
| 161 | 236 | nih_error ("%s: %s: %s", source->path, | 355 | _("Unable to load configuration"), |
| 162 | 237 | _("Unable to load configuration"), | 356 | err->message); |
| 159 | 238 | err->message); | ||
| 163 | 239 | nih_free (err); | 357 | nih_free (err); |
| 164 | 240 | } | 358 | } |
| 165 | 241 | } | 359 | } |
| 166 | @@ -328,10 +446,16 @@ | |||
| 167 | 328 | conf_source_reload_file (ConfSource *source) | 446 | conf_source_reload_file (ConfSource *source) |
| 168 | 329 | { | 447 | { |
| 169 | 330 | NihError *err = NULL; | 448 | NihError *err = NULL; |
| 170 | 449 | nih_local char *override_path = NULL; | ||
| 171 | 450 | |||
| 172 | 451 | struct stat statbuf; | ||
| 173 | 331 | 452 | ||
| 174 | 332 | nih_assert (source != NULL); | 453 | nih_assert (source != NULL); |
| 175 | 333 | nih_assert (source->type == CONF_FILE); | 454 | nih_assert (source->type == CONF_FILE); |
| 176 | 334 | 455 | ||
| 177 | 456 | /* this function should only be called for standard | ||
| 178 | 457 | * configuration files. | ||
| 179 | 458 | */ | ||
| 180 | 335 | if (! source->watch) { | 459 | if (! source->watch) { |
| 181 | 336 | nih_local char *dpath = NULL; | 460 | nih_local char *dpath = NULL; |
| 182 | 337 | char *dname; | 461 | char *dname; |
| 183 | @@ -360,7 +484,7 @@ | |||
| 184 | 360 | /* Parse the file itself. If this fails, then we can discard the | 484 | /* Parse the file itself. If this fails, then we can discard the |
| 185 | 361 | * inotify error, since this one will be better. | 485 | * inotify error, since this one will be better. |
| 186 | 362 | */ | 486 | */ |
| 188 | 363 | if (conf_reload_path (source, source->path) < 0) { | 487 | if (conf_reload_path (source, source->path, NULL) < 0) { |
| 189 | 364 | if (err) | 488 | if (err) |
| 190 | 365 | nih_free (err); | 489 | nih_free (err); |
| 191 | 366 | 490 | ||
| 192 | @@ -381,6 +505,26 @@ | |||
| 193 | 381 | nih_free (err); | 505 | nih_free (err); |
| 194 | 382 | } | 506 | } |
| 195 | 383 | 507 | ||
| 196 | 508 | if (! is_conf_file_std (source->path)) | ||
| 197 | 509 | return 0; | ||
| 198 | 510 | |||
| 199 | 511 | override_path = toggle_conf_name (NULL, source->path); | ||
| 200 | 512 | |||
| 201 | 513 | if (stat (override_path, &statbuf) != 0) | ||
| 202 | 514 | return 0; | ||
| 203 | 515 | |||
| 204 | 516 | nih_debug ("Updating configuration for %s from %s", | ||
| 205 | 517 | source->path, override_path); | ||
| 206 | 518 | if (conf_reload_path (source, source->path, override_path) < 0) { | ||
| 207 | 519 | NihError *err; | ||
| 208 | 520 | |||
| 209 | 521 | err = nih_error_get (); | ||
| 210 | 522 | nih_error ("%s: %s: %s", override_path, | ||
| 211 | 523 | _("Error while reloading configuration file"), | ||
| 212 | 524 | err->message); | ||
| 213 | 525 | nih_free (err); | ||
| 214 | 526 | } | ||
| 215 | 527 | |||
| 216 | 384 | return 0; | 528 | return 0; |
| 217 | 385 | } | 529 | } |
| 218 | 386 | 530 | ||
| 219 | @@ -500,19 +644,18 @@ | |||
| 220 | 500 | * @is_dir: TRUE of @path is a directory. | 644 | * @is_dir: TRUE of @path is a directory. |
| 221 | 501 | * | 645 | * |
| 222 | 502 | * This is the file filter used for the jobs directory, we only care | 646 | * This is the file filter used for the jobs directory, we only care |
| 228 | 503 | * about paths with the ".conf" extension. Directories that | 647 | * about paths with particular extensions (see IS_CONF_EXT). |
| 229 | 504 | * match the nih_file_ignore() function are also ignored. | 648 | * |
| 230 | 505 | * | 649 | * Directories that match the nih_file_ignore() function are also ignored. |
| 231 | 506 | * Returns: FALSE if @path ends in ".conf", or is the original source, | 650 | * |
| 232 | 507 | * TRUE otherwise. | 651 | * Returns: FALSE if @path ends in ".conf" or ".override", |
| 233 | 652 | * or is the original source, TRUE otherwise. | ||
| 234 | 508 | **/ | 653 | **/ |
| 235 | 509 | static int | 654 | static int |
| 236 | 510 | conf_dir_filter (ConfSource *source, | 655 | conf_dir_filter (ConfSource *source, |
| 237 | 511 | const char *path, | 656 | const char *path, |
| 238 | 512 | int is_dir) | 657 | int is_dir) |
| 239 | 513 | { | 658 | { |
| 240 | 514 | char *ptr; | ||
| 241 | 515 | |||
| 242 | 516 | nih_assert (source != NULL); | 659 | nih_assert (source != NULL); |
| 243 | 517 | nih_assert (path != NULL); | 660 | nih_assert (path != NULL); |
| 244 | 518 | 661 | ||
| 245 | @@ -522,8 +665,7 @@ | |||
| 246 | 522 | if (is_dir) | 665 | if (is_dir) |
| 247 | 523 | return nih_file_ignore (NULL, path); | 666 | return nih_file_ignore (NULL, path); |
| 248 | 524 | 667 | ||
| 251 | 525 | ptr = strrchr (path, '.'); | 668 | if (is_conf_file (path)) |
| 250 | 526 | if (ptr && (! strcmp (ptr, ".conf"))) | ||
| 252 | 527 | return FALSE; | 669 | return FALSE; |
| 253 | 528 | 670 | ||
| 254 | 529 | return TRUE; | 671 | return TRUE; |
| 255 | @@ -545,29 +687,92 @@ | |||
| 256 | 545 | * After checking that it was a regular file that was changed, we reload it; | 687 | * After checking that it was a regular file that was changed, we reload it; |
| 257 | 546 | * we expect this to fail sometimes since the file may be only partially | 688 | * we expect this to fail sometimes since the file may be only partially |
| 258 | 547 | * written. | 689 | * written. |
| 260 | 548 | **/ | 690 | **/ |
| 261 | 549 | static void | 691 | static void |
| 262 | 550 | conf_create_modify_handler (ConfSource *source, | 692 | conf_create_modify_handler (ConfSource *source, |
| 263 | 551 | NihWatch *watch, | 693 | NihWatch *watch, |
| 264 | 552 | const char *path, | 694 | const char *path, |
| 265 | 553 | struct stat *statbuf) | 695 | struct stat *statbuf) |
| 266 | 554 | { | 696 | { |
| 267 | 697 | ConfFile *file = NULL; | ||
| 268 | 698 | const char *error_path = path; | ||
| 269 | 699 | nih_local char *new_path = NULL; | ||
| 270 | 700 | int ret; | ||
| 271 | 701 | |||
| 272 | 555 | nih_assert (source != NULL); | 702 | nih_assert (source != NULL); |
| 273 | 556 | nih_assert (watch != NULL); | 703 | nih_assert (watch != NULL); |
| 274 | 557 | nih_assert (path != NULL); | 704 | nih_assert (path != NULL); |
| 275 | 558 | nih_assert (statbuf != NULL); | 705 | nih_assert (statbuf != NULL); |
| 276 | 559 | 706 | ||
| 277 | 707 | /* note that symbolic links are ignored */ | ||
| 278 | 560 | if (! S_ISREG (statbuf->st_mode)) | 708 | if (! S_ISREG (statbuf->st_mode)) |
| 279 | 561 | return; | 709 | return; |
| 280 | 562 | 710 | ||
| 282 | 563 | if (conf_reload_path (source, path) < 0) { | 711 | new_path = toggle_conf_name (NULL, path); |
| 283 | 712 | file = (ConfFile *)nih_hash_lookup (source->files, new_path); | ||
| 284 | 713 | |||
| 285 | 714 | if (is_conf_file_override (path)) { | ||
| 286 | 715 | if (! file) { | ||
| 287 | 716 | /* override file has no corresponding conf file */ | ||
| 288 | 717 | nih_debug ("Ignoring orphan override file %s", path); | ||
| 289 | 718 | return; | ||
| 290 | 719 | } | ||
| 291 | 720 | |||
| 292 | 721 | /* reload conf file */ | ||
| 293 | 722 | nih_debug ("Loading configuration file %s", new_path); | ||
| 294 | 723 | ret = conf_reload_path (source, new_path, NULL); | ||
| 295 | 724 | if (ret < 0) { | ||
| 296 | 725 | error_path = new_path; | ||
| 297 | 726 | goto error; | ||
| 298 | 727 | } | ||
| 299 | 728 | |||
| 300 | 729 | /* overlay override settings */ | ||
| 301 | 730 | nih_debug ("Loading override file %s for %s", path, new_path); | ||
| 302 | 731 | ret = conf_reload_path (source, new_path, path); | ||
| 303 | 732 | if (ret < 0) { | ||
| 304 | 733 | error_path = path; | ||
| 305 | 734 | goto error; | ||
| 306 | 735 | } | ||
| 307 | 736 | } else { | ||
| 308 | 737 | nih_debug ("Loading configuration and override files for %s", path); | ||
| 309 | 738 | |||
| 310 | 739 | /* load conf file */ | ||
| 311 | 740 | nih_debug ("Loading configuration file %s", path); | ||
| 312 | 741 | ret = conf_reload_path (source, path, NULL); | ||
| 313 | 742 | if (ret < 0) { | ||
| 314 | 743 | error_path = path; | ||
| 315 | 744 | goto error; | ||
| 316 | 745 | } | ||
| 317 | 746 | |||
| 318 | 747 | /* ensure we ignore directory changes (which won't have overrides. */ | ||
| 319 | 748 | if (is_conf_file_std (path)) { | ||
| 320 | 749 | struct stat st; | ||
| 321 | 750 | if (stat (new_path, &st) == 0) { | ||
| 322 | 751 | /* overlay override settings */ | ||
| 323 | 752 | nih_debug ("Loading override file %s for %s", new_path, path); | ||
| 324 | 753 | ret = conf_reload_path (source, path, new_path); | ||
| 325 | 754 | if (ret < 0) { | ||
| 326 | 755 | error_path = new_path; | ||
| 327 | 756 | goto error; | ||
| 328 | 757 | } | ||
| 329 | 758 | } | ||
| 330 | 759 | |||
| 331 | 760 | } | ||
| 332 | 761 | } | ||
| 333 | 762 | |||
| 334 | 763 | return; | ||
| 335 | 764 | |||
| 336 | 765 | error: | ||
| 337 | 766 | { | ||
| 338 | 564 | NihError *err; | 767 | NihError *err; |
| 339 | 565 | 768 | ||
| 340 | 566 | err = nih_error_get (); | 769 | err = nih_error_get (); |
| 344 | 567 | nih_error ("%s: %s: %s", path, | 770 | nih_error ("%s: %s: %s", error_path, |
| 345 | 568 | _("Error while loading configuration file"), | 771 | _("Error while loading configuration file"), |
| 346 | 569 | err->message); | 772 | err->message); |
| 347 | 570 | nih_free (err); | 773 | nih_free (err); |
| 348 | 774 | if (file) | ||
| 349 | 775 | nih_unref (file, source); | ||
| 350 | 571 | } | 776 | } |
| 351 | 572 | } | 777 | } |
| 352 | 573 | 778 | ||
| 353 | @@ -584,13 +789,14 @@ | |||
| 354 | 584 | * | 789 | * |
| 355 | 585 | * We lookup the file in our hash table, and if we can find it, perform | 790 | * We lookup the file in our hash table, and if we can find it, perform |
| 356 | 586 | * the usual deletion of it. | 791 | * the usual deletion of it. |
| 358 | 587 | **/ | 792 | **/ |
| 359 | 588 | static void | 793 | static void |
| 360 | 589 | conf_delete_handler (ConfSource *source, | 794 | conf_delete_handler (ConfSource *source, |
| 361 | 590 | NihWatch *watch, | 795 | NihWatch *watch, |
| 362 | 591 | const char *path) | 796 | const char *path) |
| 363 | 592 | { | 797 | { |
| 364 | 593 | ConfFile *file; | 798 | ConfFile *file; |
| 365 | 799 | nih_local char *new_path = NULL; | ||
| 366 | 594 | 800 | ||
| 367 | 595 | nih_assert (source != NULL); | 801 | nih_assert (source != NULL); |
| 368 | 596 | nih_assert (watch != NULL); | 802 | nih_assert (watch != NULL); |
| 369 | @@ -602,7 +808,11 @@ | |||
| 370 | 602 | * it's probably a directory or something, so just ignore it. | 808 | * it's probably a directory or something, so just ignore it. |
| 371 | 603 | */ | 809 | */ |
| 372 | 604 | file = (ConfFile *)nih_hash_lookup (source->files, path); | 810 | file = (ConfFile *)nih_hash_lookup (source->files, path); |
| 374 | 605 | if (! file) { | 811 | /* Note we have to be careful to consider deletion of directories too. |
| 375 | 812 | * This is handled implicitly by the override check which will return | ||
| 376 | 813 | * false if passed a directory in this case. | ||
| 377 | 814 | */ | ||
| 378 | 815 | if (! file && ! is_conf_file_override (path)) { | ||
| 379 | 606 | if (! strcmp (watch->path, path)) { | 816 | if (! strcmp (watch->path, path)) { |
| 380 | 607 | nih_warn ("%s: %s", source->path, | 817 | nih_warn ("%s: %s", source->path, |
| 381 | 608 | _("Configuration directory deleted")); | 818 | _("Configuration directory deleted")); |
| 382 | @@ -613,7 +823,30 @@ | |||
| 383 | 613 | return; | 823 | return; |
| 384 | 614 | } | 824 | } |
| 385 | 615 | 825 | ||
| 387 | 616 | nih_unref (file, source); | 826 | /* non-override files (and directories) are the simple case, so handle |
| 388 | 827 | * them and leave. | ||
| 389 | 828 | */ | ||
| 390 | 829 | if (! is_conf_file_override (path)) { | ||
| 391 | 830 | nih_unref (file, source); | ||
| 392 | 831 | return; | ||
| 393 | 832 | } | ||
| 394 | 833 | |||
| 395 | 834 | /* if an override file is deleted for which there is a corresponding | ||
| 396 | 835 | * conf file, reload the conf file to remove any modifications | ||
| 397 | 836 | * introduced by the override file. | ||
| 398 | 837 | */ | ||
| 399 | 838 | new_path = toggle_conf_name (NULL, path); | ||
| 400 | 839 | file = (ConfFile *)nih_hash_lookup (source->files, new_path); | ||
| 401 | 840 | |||
| 402 | 841 | if (file) { | ||
| 403 | 842 | nih_debug ("Reloading configuration for %s on deletion of overide (%s)", | ||
| 404 | 843 | new_path, path); | ||
| 405 | 844 | |||
| 406 | 845 | if ( conf_reload_path (source, new_path, NULL) < 0 ) { | ||
| 407 | 846 | nih_warn ("%s: %s", new_path, | ||
| 408 | 847 | _("Unable to reload configuration after override deletion")); | ||
| 409 | 848 | } | ||
| 410 | 849 | } | ||
| 411 | 617 | } | 850 | } |
| 412 | 618 | 851 | ||
| 413 | 619 | /** | 852 | /** |
| 414 | @@ -636,22 +869,61 @@ | |||
| 415 | 636 | const char *path, | 869 | const char *path, |
| 416 | 637 | struct stat *statbuf) | 870 | struct stat *statbuf) |
| 417 | 638 | { | 871 | { |
| 418 | 872 | ConfFile *file = NULL; | ||
| 419 | 873 | nih_local char *new_path = NULL; | ||
| 420 | 874 | |||
| 421 | 639 | nih_assert (source != NULL); | 875 | nih_assert (source != NULL); |
| 422 | 640 | nih_assert (dirname != NULL); | 876 | nih_assert (dirname != NULL); |
| 423 | 641 | nih_assert (path != NULL); | 877 | nih_assert (path != NULL); |
| 424 | 642 | nih_assert (statbuf != NULL); | 878 | nih_assert (statbuf != NULL); |
| 425 | 643 | 879 | ||
| 426 | 880 | /* We assume that CONF_EXT_STD files are visited before | ||
| 427 | 881 | * CONF_EXT_OVERRIDE files. Happily, this assumption is currently | ||
| 428 | 882 | * valid since CONF_EXT_STD comes before CONF_EXT_OVERRIDE if ordered | ||
| 429 | 883 | * alphabetically. | ||
| 430 | 884 | * | ||
| 431 | 885 | * If this were ever to change (for example if we decided to | ||
| 432 | 886 | * rename the CONF_EXT_OVERRIDE files to end in ".abc", say), the logic | ||
| 433 | 887 | * in this function would be erroneous since it would never be possible when | ||
| 434 | 888 | * visiting an override file (before a conf file) to lookup a conf file | ||
| 435 | 889 | * in the hash, since the conf file would not yet have been seen and thus would | ||
| 436 | 890 | * not exist in the hash (yet). | ||
| 437 | 891 | */ | ||
| 438 | 892 | nih_assert (CONF_EXT_STD[1] < CONF_EXT_OVERRIDE[1]); | ||
| 439 | 893 | |||
| 440 | 644 | if (! S_ISREG (statbuf->st_mode)) | 894 | if (! S_ISREG (statbuf->st_mode)) |
| 441 | 645 | return 0; | 895 | return 0; |
| 442 | 646 | 896 | ||
| 451 | 647 | if (conf_reload_path (source, path) < 0) { | 897 | if (is_conf_file_std (path)) { |
| 452 | 648 | NihError *err; | 898 | if (conf_reload_path (source, path, NULL) < 0) { |
| 453 | 649 | 899 | NihError *err; | |
| 454 | 650 | err = nih_error_get (); | 900 | |
| 455 | 651 | nih_error ("%s: %s: %s", path, | 901 | err = nih_error_get (); |
| 456 | 652 | _("Error while loading configuration file"), | 902 | nih_error ("%s: %s: %s", path, |
| 457 | 653 | err->message); | 903 | _("Error while loading configuration file"), |
| 458 | 654 | nih_free (err); | 904 | err->message); |
| 459 | 905 | nih_free (err); | ||
| 460 | 906 | } | ||
| 461 | 907 | return 0; | ||
| 462 | 908 | } | ||
| 463 | 909 | |||
| 464 | 910 | new_path = toggle_conf_name (NULL, path); | ||
| 465 | 911 | file = (ConfFile *)nih_hash_lookup (source->files, new_path); | ||
| 466 | 912 | |||
| 467 | 913 | if (file) { | ||
| 468 | 914 | /* we're visiting an override file with an associated conf file that | ||
| 469 | 915 | * has already been loaded, so just overlay the override file. If | ||
| 470 | 916 | * there is no corresponding conf file, we ignore the override file. | ||
| 471 | 917 | */ | ||
| 472 | 918 | if (conf_reload_path (source, new_path, path) < 0) { | ||
| 473 | 919 | NihError *err; | ||
| 474 | 920 | |||
| 475 | 921 | err = nih_error_get (); | ||
| 476 | 922 | nih_error ("%s: %s: %s", new_path, | ||
| 477 | 923 | _("Error while reloading configuration file"), | ||
| 478 | 924 | err->message); | ||
| 479 | 925 | nih_free (err); | ||
| 480 | 926 | } | ||
| 481 | 655 | } | 927 | } |
| 482 | 656 | 928 | ||
| 483 | 657 | return 0; | 929 | return 0; |
| 484 | @@ -661,12 +933,15 @@ | |||
| 485 | 661 | /** | 933 | /** |
| 486 | 662 | * conf_reload_path: | 934 | * conf_reload_path: |
| 487 | 663 | * @source: configuration source, | 935 | * @source: configuration source, |
| 489 | 664 | * @path: path of file to be reloaded. | 936 | * @path: path of conf file to be reloaded. |
| 490 | 937 | * @override_path: if TRUE and @path refers to a path associated with @source, | ||
| 491 | 938 | * overlay the contents of @path into the existing @source entry for | ||
| 492 | 939 | * @path. If FALSE, discard any existing knowledge of @path. | ||
| 493 | 665 | * | 940 | * |
| 498 | 666 | * This function is used to parse the file at @path in the context of the | 941 | * This function is used to parse the file at @path (or @override_path) in the |
| 499 | 667 | * given configuration @source. Necessary ConfFile structures are allocated | 942 | * context of the given configuration @source. Necessary ConfFile structures |
| 500 | 668 | * and attached to @source as appropriate. CONF_FILE sources always have | 943 | * are allocated and attached to @source as appropriate. CONF_FILE sources |
| 501 | 669 | * a single ConfFile when the file exists. | 944 | * always have a single ConfFile when the file exists. |
| 502 | 670 | * | 945 | * |
| 503 | 671 | * If the file has been parsed before, then the existing item is deleted and | 946 | * If the file has been parsed before, then the existing item is deleted and |
| 504 | 672 | * freed if the file fails to load, or after the new item has been parsed. | 947 | * freed if the file fails to load, or after the new item has been parsed. |
| 505 | @@ -678,36 +953,43 @@ | |||
| 506 | 678 | **/ | 953 | **/ |
| 507 | 679 | static int | 954 | static int |
| 508 | 680 | conf_reload_path (ConfSource *source, | 955 | conf_reload_path (ConfSource *source, |
| 510 | 681 | const char *path) | 956 | const char *path, |
| 511 | 957 | const char *override_path) | ||
| 512 | 682 | { | 958 | { |
| 514 | 683 | ConfFile *file; | 959 | ConfFile *file = NULL; |
| 515 | 684 | nih_local char *buf = NULL; | 960 | nih_local char *buf = NULL; |
| 516 | 685 | const char *start, *end; | 961 | const char *start, *end; |
| 517 | 686 | nih_local char *name = NULL; | 962 | nih_local char *name = NULL; |
| 518 | 687 | size_t len, pos, lineno; | 963 | size_t len, pos, lineno; |
| 519 | 688 | NihError *err = NULL; | 964 | NihError *err = NULL; |
| 520 | 965 | const char *path_to_load; | ||
| 521 | 689 | 966 | ||
| 522 | 690 | nih_assert (source != NULL); | 967 | nih_assert (source != NULL); |
| 523 | 691 | nih_assert (path != NULL); | 968 | nih_assert (path != NULL); |
| 524 | 692 | 969 | ||
| 527 | 693 | /* Look up the old file in memory, and then free it. In cases | 970 | path_to_load = ( override_path ? override_path : path); |
| 528 | 694 | * of failure, we discard it anyway, so there's no particular reason | 971 | |
| 529 | 972 | /* If there is no corresponding override file, look up the old | ||
| 530 | 973 | * conf file in memory, and then free it. In cases of failure, | ||
| 531 | 974 | * we discard it anyway, so there's no particular reason | ||
| 532 | 695 | * to keep it around anymore. | 975 | * to keep it around anymore. |
| 533 | 696 | */ | 976 | */ |
| 534 | 697 | file = (ConfFile *)nih_hash_lookup (source->files, path); | 977 | file = (ConfFile *)nih_hash_lookup (source->files, path); |
| 536 | 698 | if (file) | 978 | if (! override_path && file) |
| 537 | 699 | nih_unref (file, source); | 979 | nih_unref (file, source); |
| 538 | 700 | 980 | ||
| 539 | 701 | /* Read the file into memory for parsing, if this fails we don't | 981 | /* Read the file into memory for parsing, if this fails we don't |
| 540 | 702 | * bother creating a new ConfFile structure for it and bail out | 982 | * bother creating a new ConfFile structure for it and bail out |
| 541 | 703 | * now. | 983 | * now. |
| 542 | 704 | */ | 984 | */ |
| 544 | 705 | buf = nih_file_read (NULL, path, &len); | 985 | buf = nih_file_read (NULL, path_to_load, &len); |
| 545 | 706 | if (! buf) | 986 | if (! buf) |
| 546 | 707 | return -1; | 987 | return -1; |
| 547 | 708 | 988 | ||
| 550 | 709 | /* Parse the file, storing the item in a new ConfFile structure. */ | 989 | /* Create a new ConfFile structure (if no override_path was specified) */ |
| 551 | 710 | file = NIH_MUST (conf_file_new (source, path)); | 990 | file = (ConfFile *)nih_hash_lookup (source->files, path); |
| 552 | 991 | if (! file) | ||
| 553 | 992 | file = NIH_MUST (conf_file_new (source, path)); | ||
| 554 | 711 | 993 | ||
| 555 | 712 | pos = 0; | 994 | pos = 0; |
| 556 | 713 | lineno = 1; | 995 | lineno = 1; |
| 557 | @@ -716,7 +998,14 @@ | |||
| 558 | 716 | case CONF_FILE: | 998 | case CONF_FILE: |
| 559 | 717 | case CONF_DIR: | 999 | case CONF_DIR: |
| 560 | 718 | /* Simple file of options; usually no item attached to it. */ | 1000 | /* Simple file of options; usually no item attached to it. */ |
| 562 | 719 | nih_debug ("Loading configuration from %s", path); | 1001 | if (override_path) { |
| 563 | 1002 | nih_debug ("Updating configuration for %s from %s", | ||
| 564 | 1003 | path, override_path); | ||
| 565 | 1004 | } else { | ||
| 566 | 1005 | nih_debug ("Loading configuration from %s %s", | ||
| 567 | 1006 | (source->type == CONF_DIR ? "directory" : "file"), path); | ||
| 568 | 1007 | } | ||
| 569 | 1008 | |||
| 570 | 720 | if (parse_conf (file, buf, len, &pos, &lineno) < 0) | 1009 | if (parse_conf (file, buf, len, &pos, &lineno) < 0) |
| 571 | 721 | err = nih_error_get (); | 1010 | err = nih_error_get (); |
| 572 | 722 | 1011 | ||
| 573 | @@ -734,7 +1023,7 @@ | |||
| 574 | 734 | start++; | 1023 | start++; |
| 575 | 735 | 1024 | ||
| 576 | 736 | end = strrchr (start, '.'); | 1025 | end = strrchr (start, '.'); |
| 578 | 737 | if (end && (! strcmp (end, ".conf"))) { | 1026 | if (end && IS_CONF_EXT (end)) { |
| 579 | 738 | name = NIH_MUST (nih_strndup (NULL, start, end - start)); | 1027 | name = NIH_MUST (nih_strndup (NULL, start, end - start)); |
| 580 | 739 | } else { | 1028 | } else { |
| 581 | 740 | name = NIH_MUST (nih_strdup (NULL, start)); | 1029 | name = NIH_MUST (nih_strdup (NULL, start)); |
| 582 | @@ -743,8 +1032,13 @@ | |||
| 583 | 743 | /* Create a new job item and parse the buffer to produce | 1032 | /* Create a new job item and parse the buffer to produce |
| 584 | 744 | * the job definition. | 1033 | * the job definition. |
| 585 | 745 | */ | 1034 | */ |
| 588 | 746 | nih_debug ("Loading %s from %s", name, path); | 1035 | if (override_path) { |
| 589 | 747 | file->job = parse_job (NULL, name, buf, len, &pos, &lineno); | 1036 | nih_debug ("Updating %s (%s) with %s", |
| 590 | 1037 | name, path, override_path); | ||
| 591 | 1038 | } else { | ||
| 592 | 1039 | nih_debug ("Loading %s from %s", name, path); | ||
| 593 | 1040 | } | ||
| 594 | 1041 | file->job = parse_job (NULL, file->job, name, buf, len, &pos, &lineno); | ||
| 595 | 748 | if (file->job) { | 1042 | if (file->job) { |
| 596 | 749 | job_class_consider (file->job); | 1043 | job_class_consider (file->job); |
| 597 | 750 | } else { | 1044 | } else { |
| 598 | @@ -778,7 +1072,7 @@ | |||
| 599 | 778 | case PARSE_EXPECTED_OPERATOR: | 1072 | case PARSE_EXPECTED_OPERATOR: |
| 600 | 779 | case PARSE_EXPECTED_VARIABLE: | 1073 | case PARSE_EXPECTED_VARIABLE: |
| 601 | 780 | case PARSE_MISMATCHED_PARENS: | 1074 | case PARSE_MISMATCHED_PARENS: |
| 603 | 781 | nih_error ("%s:%zi: %s", path, lineno, err->message); | 1075 | nih_error ("%s:%zi: %s", path_to_load, lineno, err->message); |
| 604 | 782 | nih_free (err); | 1076 | nih_free (err); |
| 605 | 783 | err = NULL; | 1077 | err = NULL; |
| 606 | 784 | break; | 1078 | break; |
| 607 | @@ -881,3 +1175,149 @@ | |||
| 608 | 881 | 1175 | ||
| 609 | 882 | return NULL; | 1176 | return NULL; |
| 610 | 883 | } | 1177 | } |
| 611 | 1178 | |||
| 612 | 1179 | #ifdef DEBUG | ||
| 613 | 1180 | |||
| 614 | 1181 | size_t | ||
| 615 | 1182 | debug_count_list_entries (const NihList *list) | ||
| 616 | 1183 | { | ||
| 617 | 1184 | size_t i = 0; | ||
| 618 | 1185 | NIH_LIST_FOREACH (list, iter) { | ||
| 619 | 1186 | i++; | ||
| 620 | 1187 | } | ||
| 621 | 1188 | return i; | ||
| 622 | 1189 | } | ||
| 623 | 1190 | |||
| 624 | 1191 | size_t | ||
| 625 | 1192 | debug_count_hash_entries (const NihHash *hash) | ||
| 626 | 1193 | { | ||
| 627 | 1194 | size_t i = 0; | ||
| 628 | 1195 | NIH_HASH_FOREACH_SAFE (hash, iter) { | ||
| 629 | 1196 | i++; | ||
| 630 | 1197 | } | ||
| 631 | 1198 | return i; | ||
| 632 | 1199 | } | ||
| 633 | 1200 | |||
| 634 | 1201 | void | ||
| 635 | 1202 | debug_show_job_class (const JobClass *job) | ||
| 636 | 1203 | { | ||
| 637 | 1204 | int i; | ||
| 638 | 1205 | char **env = (char **)job->env; | ||
| 639 | 1206 | char **export = (char **)job->export; | ||
| 640 | 1207 | |||
| 641 | 1208 | nih_assert (job); | ||
| 642 | 1209 | |||
| 643 | 1210 | nih_debug ("JobClass %p: name='%s', path='%s', task=%d, " | ||
| 644 | 1211 | "respawn=%d, console=%x, deleted=%d, debug=%d", | ||
| 645 | 1212 | job, job->name, job->path, job->task, | ||
| 646 | 1213 | job->respawn, job->console, job->deleted, job->debug); | ||
| 647 | 1214 | |||
| 648 | 1215 | nih_debug ("\tstart_on=%p, stop_on=%p, emits=%p, process=%p", | ||
| 649 | 1216 | job->start_on, job->stop_on, job->emits, job->process); | ||
| 650 | 1217 | |||
| 651 | 1218 | nih_debug ("\tauthor='%s', description='%s'", | ||
| 652 | 1219 | job->author, job->description); | ||
| 653 | 1220 | |||
| 654 | 1221 | if (env && *env) { | ||
| 655 | 1222 | nih_debug ("\tenv:"); | ||
| 656 | 1223 | i = 0; | ||
| 657 | 1224 | while ( *env ) { | ||
| 658 | 1225 | nih_debug ("\t\tenv[%d]='%s' (len=%u+1)", | ||
| 659 | 1226 | i, *env, strlen (*env)); | ||
| 660 | 1227 | env++; | ||
| 661 | 1228 | ++i; | ||
| 662 | 1229 | } | ||
| 663 | 1230 | } else { | ||
| 664 | 1231 | nih_debug ("\tenv: none."); | ||
| 665 | 1232 | } | ||
| 666 | 1233 | |||
| 667 | 1234 | |||
| 668 | 1235 | if (export && *export) { | ||
| 669 | 1236 | nih_debug ("\texport:"); | ||
| 670 | 1237 | i = 0; | ||
| 671 | 1238 | while ( *export ) { | ||
| 672 | 1239 | nih_debug ("\t\tenv[%d]='%s' (len=%u+1)", | ||
| 673 | 1240 | i, *export, strlen (*export)); | ||
| 674 | 1241 | export++; | ||
| 675 | 1242 | ++i; | ||
| 676 | 1243 | } | ||
| 677 | 1244 | } | ||
| 678 | 1245 | else { | ||
| 679 | 1246 | nih_debug ("\texport: none"); | ||
| 680 | 1247 | } | ||
| 681 | 1248 | } | ||
| 682 | 1249 | |||
| 683 | 1250 | void | ||
| 684 | 1251 | debug_show_job_classes (void) | ||
| 685 | 1252 | { | ||
| 686 | 1253 | nih_debug ("job_classes:"); | ||
| 687 | 1254 | |||
| 688 | 1255 | NIH_HASH_FOREACH_SAFE (job_classes, iter) { | ||
| 689 | 1256 | JobClass *job = (JobClass *)iter; | ||
| 690 | 1257 | debug_show_job_class (job); | ||
| 691 | 1258 | } | ||
| 692 | 1259 | } | ||
| 693 | 1260 | |||
| 694 | 1261 | void | ||
| 695 | 1262 | debug_show_event (const Event *event) | ||
| 696 | 1263 | { | ||
| 697 | 1264 | nih_assert (event); | ||
| 698 | 1265 | |||
| 699 | 1266 | nih_debug ("Event %p: name='%s', progress=%x, failed=%d, " | ||
| 700 | 1267 | "blockers=%d, blocking=%p", | ||
| 701 | 1268 | event, event->name, event->progress, event->failed, | ||
| 702 | 1269 | event->blockers, (void *)&event->blocking); | ||
| 703 | 1270 | } | ||
| 704 | 1271 | |||
| 705 | 1272 | void | ||
| 706 | 1273 | debug_show_conf_file (const ConfFile *file) | ||
| 707 | 1274 | { | ||
| 708 | 1275 | nih_assert (file); | ||
| 709 | 1276 | |||
| 710 | 1277 | nih_debug ("ConfFile %p: path='%s', source=%p, flag=%x, job=%p", | ||
| 711 | 1278 | file, file->path, file->source, file->flag, file->job); | ||
| 712 | 1279 | |||
| 713 | 1280 | /* Some ConfFile objects won't have any JobClass details, for example, | ||
| 714 | 1281 | * the ConfFile object associated with "/etc/init.conf". | ||
| 715 | 1282 | */ | ||
| 716 | 1283 | if (! file->job) { | ||
| 717 | 1284 | nih_debug ("ConfFile %p: job: no JobClass object.", file); | ||
| 718 | 1285 | return; | ||
| 719 | 1286 | } | ||
| 720 | 1287 | |||
| 721 | 1288 | nih_debug ("ConfFile %p: job:", file); | ||
| 722 | 1289 | debug_show_job_class (file->job); | ||
| 723 | 1290 | } | ||
| 724 | 1291 | |||
| 725 | 1292 | void | ||
| 726 | 1293 | debug_show_conf_source (const ConfSource *source) | ||
| 727 | 1294 | { | ||
| 728 | 1295 | nih_assert (source); | ||
| 729 | 1296 | |||
| 730 | 1297 | nih_debug ("ConfSource %p: path='%s', type=%x, flag=%x", | ||
| 731 | 1298 | source, source->path, source->type, source->flag); | ||
| 732 | 1299 | |||
| 733 | 1300 | nih_debug ("ConfSource %p files (%d):", source, | ||
| 734 | 1301 | debug_count_hash_entries (source->files)); | ||
| 735 | 1302 | |||
| 736 | 1303 | NIH_HASH_FOREACH (source->files, file_iter) { | ||
| 737 | 1304 | ConfFile *file = (ConfFile *)file_iter; | ||
| 738 | 1305 | debug_show_conf_file (file); | ||
| 739 | 1306 | } | ||
| 740 | 1307 | } | ||
| 741 | 1308 | |||
| 742 | 1309 | void | ||
| 743 | 1310 | debug_show_conf_sources (void) | ||
| 744 | 1311 | { | ||
| 745 | 1312 | nih_assert (conf_sources); | ||
| 746 | 1313 | |||
| 747 | 1314 | nih_debug ("conf_sources:"); | ||
| 748 | 1315 | |||
| 749 | 1316 | NIH_LIST_FOREACH (conf_sources, iter) { | ||
| 750 | 1317 | ConfSource *source = (ConfSource *)iter; | ||
| 751 | 1318 | debug_show_conf_source (source); | ||
| 752 | 1319 | } | ||
| 753 | 1320 | } | ||
| 754 | 1321 | |||
| 755 | 1322 | #endif /* DEBUG */ | ||
| 756 | 1323 | |||
| 757 | 884 | 1324 | ||
| 758 | === modified file 'init/conf.h' | |||
| 759 | --- init/conf.h 2009-07-09 08:36:52 +0000 | |||
| 760 | +++ init/conf.h 2011-01-21 11:55:09 +0000 | |||
| 761 | @@ -124,6 +124,46 @@ | |||
| 762 | 124 | 124 | ||
| 763 | 125 | JobClass * conf_select_job (const char *name); | 125 | JobClass * conf_select_job (const char *name); |
| 764 | 126 | 126 | ||
| 765 | 127 | char *toggle_conf_name (const void *parent, const char *path) | ||
| 766 | 128 | __attribute__ ((warn_unused_result, malloc)); | ||
| 767 | 129 | |||
| 768 | 130 | #ifdef DEBUG | ||
| 769 | 131 | |||
| 770 | 132 | /* used for debugging only */ | ||
| 771 | 133 | |||
| 772 | 134 | size_t | ||
| 773 | 135 | debug_count_hash_entries (const NihHash *hash); | ||
| 774 | 136 | |||
| 775 | 137 | size_t | ||
| 776 | 138 | debug_count_list_entries (const NihList *list) | ||
| 777 | 139 | __attribute__ ((unused)); | ||
| 778 | 140 | |||
| 779 | 141 | void | ||
| 780 | 142 | debug_show_job_class (const JobClass *job) | ||
| 781 | 143 | __attribute__ ((unused)); | ||
| 782 | 144 | |||
| 783 | 145 | void | ||
| 784 | 146 | debug_show_job_classes (void) | ||
| 785 | 147 | __attribute__ ((unused)); | ||
| 786 | 148 | |||
| 787 | 149 | void | ||
| 788 | 150 | debug_show_event (const Event *event) | ||
| 789 | 151 | __attribute__ ((unused)); | ||
| 790 | 152 | |||
| 791 | 153 | void | ||
| 792 | 154 | debug_show_conf_file(const ConfFile *file) | ||
| 793 | 155 | __attribute__ ((unused)); | ||
| 794 | 156 | |||
| 795 | 157 | void | ||
| 796 | 158 | debug_show_conf_source(const ConfSource *source) | ||
| 797 | 159 | __attribute__ ((unused)); | ||
| 798 | 160 | |||
| 799 | 161 | void | ||
| 800 | 162 | debug_show_conf_sources(void) | ||
| 801 | 163 | __attribute__ ((unused)); | ||
| 802 | 164 | |||
| 803 | 165 | #endif | ||
| 804 | 166 | |||
| 805 | 127 | NIH_END_EXTERN | 167 | NIH_END_EXTERN |
| 806 | 128 | 168 | ||
| 807 | 129 | #endif /* INIT_CONF_H */ | 169 | #endif /* INIT_CONF_H */ |
| 808 | 130 | 170 | ||
| 809 | === modified file 'init/job_class.c' | |||
| 810 | --- init/job_class.c 2010-12-14 15:30:06 +0000 | |||
| 811 | +++ init/job_class.c 2011-01-21 11:55:09 +0000 | |||
| 812 | @@ -220,7 +220,7 @@ | |||
| 813 | 220 | class->chdir = NULL; | 220 | class->chdir = NULL; |
| 814 | 221 | 221 | ||
| 815 | 222 | class->deleted = FALSE; | 222 | class->deleted = FALSE; |
| 817 | 223 | class->debug = FALSE; | 223 | class->debug = FALSE; |
| 818 | 224 | 224 | ||
| 819 | 225 | return class; | 225 | return class; |
| 820 | 226 | 226 | ||
| 821 | 227 | 227 | ||
| 822 | === modified file 'init/man/init.5' | |||
| 823 | --- init/man/init.5 2010-12-14 16:20:38 +0000 | |||
| 824 | +++ init/man/init.5 2011-01-21 11:55:09 +0000 | |||
| 825 | @@ -1,42 +1,79 @@ | |||
| 827 | 1 | .TH init 5 2010-12-14 "Upstart" | 1 | .TH init 5 2011-01-12 "Upstart" |
| 828 | 2 | .\" | 2 | .\" |
| 829 | 3 | .SH NAME | 3 | .SH NAME |
| 830 | 4 | init \- Upstart init daemon job configuration | 4 | init \- Upstart init daemon job configuration |
| 831 | 5 | .\" | 5 | .\" |
| 832 | 6 | .SH SYNOPSIS | 6 | .SH SYNOPSIS |
| 834 | 7 | .B /etc/init | 7 | .B /etc/init/ |
| 835 | 8 | .\" | 8 | .\" |
| 836 | 9 | .SH DESCRIPTION | 9 | .SH DESCRIPTION |
| 837 | 10 | On startup, the Upstart | 10 | On startup, the Upstart |
| 838 | 11 | .BR init (8) | 11 | .BR init (8) |
| 842 | 12 | daemon reads its job configuration from the | 12 | daemon reads its job configuration from files in the |
| 843 | 13 | .I /etc/init | 13 | .I /etc/init/ |
| 844 | 14 | directory, and watches for future changes using | 14 | directory, and watches for future changes to these files using |
| 845 | 15 | .BR inotify (7). | 15 | .BR inotify (7). |
| 846 | 16 | 16 | ||
| 848 | 17 | Files in this directory must end in | 17 | To be considered by Upstart, files in this directory must have a |
| 849 | 18 | recognized suffix and may also be present in sub-directories. There are | ||
| 850 | 19 | two recognized suffixes: | ||
| 851 | 20 | |||
| 852 | 21 | .IP \(bu 4 | ||
| 853 | 22 | Files ending in | ||
| 854 | 18 | .I .conf | 23 | .I .conf |
| 860 | 19 | and may also be present in sub-directories. | 24 | are called configuration files, or simply "conf files" for short. |
| 861 | 20 | 25 | These are the primary vehicle for specifying a job. | |
| 862 | 21 | Each file defines a single service or task, with the name taken from its | 26 | .IP \(bu 4 |
| 863 | 22 | relative path within the directory without the extension. For example a | 27 | Files ending in |
| 864 | 23 | job defined in | 28 | .I .override |
| 865 | 29 | are called override files. If an override file is present, the stanzas | ||
| 866 | 30 | it contains take precedence over those equivalently named stanzas in the | ||
| 867 | 31 | corresponding configuration file contents for a particular job. | ||
| 868 | 32 | The main use for override files is to modify how a job will run without | ||
| 869 | 33 | having to modify its configuration file directly. See the section | ||
| 870 | 34 | \fBOverride File Handling\fP below for further details. | ||
| 871 | 35 | .P | ||
| 872 | 36 | A job can thus be defined by either: | ||
| 873 | 37 | .IP \[bu] 2 | ||
| 874 | 38 | A single configuration file. | ||
| 875 | 39 | .IP \[bu] | ||
| 876 | 40 | A single configuration file \fBand\fP a single override file. | ||
| 877 | 41 | .P | ||
| 878 | 42 | Unless explicitly stated otherwise, any reference to a jobs | ||
| 879 | 43 | configuration can refer both to a configuration file or an override | ||
| 880 | 44 | file. | ||
| 881 | 45 | |||
| 882 | 46 | Each configuration file defines the template for a single \fIservice\fP | ||
| 883 | 47 | (long-running process or daemon) or \fItask\fP (short-lived process). | ||
| 884 | 48 | |||
| 885 | 49 | Note that a configuration file is not itself a job: it is a description | ||
| 886 | 50 | of an environmenta job could be run in. A job is the runtime embodiment | ||
| 887 | 51 | of a configuration file. | ||
| 888 | 52 | |||
| 889 | 53 | The configuration file name as displayed by Upstart and associated | ||
| 890 | 54 | tooling is taken from its relative path within the directory without the | ||
| 891 | 55 | extension. For example a configuration file | ||
| 892 | 24 | .I /etc/init/rc-sysinit.conf | 56 | .I /etc/init/rc-sysinit.conf |
| 893 | 25 | is named | 57 | is named |
| 894 | 26 | .IR rc-sysinit , | 58 | .IR rc-sysinit , |
| 896 | 27 | while a job defined in | 59 | while a configuration file |
| 897 | 28 | .I /etc/init/net/apache.conf | 60 | .I /etc/init/net/apache.conf |
| 898 | 29 | is named | 61 | is named |
| 899 | 30 | .IR net/apache . | 62 | .IR net/apache . |
| 900 | 63 | Since override files only modify the way a configuration file is | ||
| 901 | 64 | interpreted, they are not named. | ||
| 902 | 31 | 65 | ||
| 904 | 32 | These files are plain text and should not be executable. | 66 | Configuration files are plain text and should not be executable. |
| 905 | 33 | .\" | 67 | .\" |
| 907 | 34 | .SS Format | 68 | .SS Configuration File Format |
| 908 | 35 | Each line begins with a configuration stanza and continues until either | 69 | Each line begins with a configuration stanza and continues until either |
| 909 | 36 | the end of the line or a line containing a closing stanza. Line breaks | 70 | the end of the line or a line containing a closing stanza. Line breaks |
| 910 | 37 | within a stanza are permitted within single or double quotes, or if | 71 | within a stanza are permitted within single or double quotes, or if |
| 911 | 38 | preceeded by a blackslash. | 72 | preceeded by a blackslash. |
| 912 | 39 | 73 | ||
| 913 | 74 | If a stanza is duplicated, the last occurence will be used. Unrecognized | ||
| 914 | 75 | stanzas will generate parse errors, which will stop a job from running. | ||
| 915 | 76 | |||
| 916 | 40 | Stanzas and their arguments are delimited by whitespace, which consists | 77 | Stanzas and their arguments are delimited by whitespace, which consists |
| 917 | 41 | of one or more space or tab characters which are otherwise ignored unless | 78 | of one or more space or tab characters which are otherwise ignored unless |
| 918 | 42 | placed within single or double quotes. | 79 | placed within single or double quotes. |
| 919 | @@ -144,10 +181,10 @@ | |||
| 920 | 144 | such as removing temporary directories. | 181 | such as removing temporary directories. |
| 921 | 145 | 182 | ||
| 922 | 146 | .PP | 183 | .PP |
| 927 | 147 | All of these processes, including the main process, are optional. Services | 184 | All of these processes, including the main process, are optional. |
| 928 | 148 | without a main process will appear to be running until they are stopped, | 185 | Services without a main process will appear to be running until they are |
| 929 | 149 | this is commonly used to define states such as runlevels. It's quite | 186 | stopped: this is commonly used to define states such as runlevels. It |
| 930 | 150 | permissable to have no main process, but to have | 187 | is permissable to have no main process, but to have |
| 931 | 151 | .B pre-start | 188 | .B pre-start |
| 932 | 152 | and | 189 | and |
| 933 | 153 | .B post-stop | 190 | .B post-stop |
| 934 | @@ -249,7 +286,7 @@ | |||
| 935 | 249 | .B stop on | 286 | .B stop on |
| 936 | 250 | stanza defines the set of events that will cause the job to be automatically | 287 | stanza defines the set of events that will cause the job to be automatically |
| 937 | 251 | stopped. It has the same syntax as | 288 | stopped. It has the same syntax as |
| 939 | 252 | .B start on | 289 | \fBstart on\fP. |
| 940 | 253 | 290 | ||
| 941 | 254 | .I VALUE | 291 | .I VALUE |
| 942 | 255 | may additionally expand the value of any variable that came from the | 292 | may additionally expand the value of any variable that came from the |
| 943 | @@ -306,7 +343,8 @@ | |||
| 944 | 306 | .B env \fIKEY\fR[=\fIVALUE\fR] | 343 | .B env \fIKEY\fR[=\fIVALUE\fR] |
| 945 | 307 | Defines a default environment variable, the value of which may be overriden | 344 | Defines a default environment variable, the value of which may be overriden |
| 946 | 308 | by the event or command that starts the job. | 345 | by the event or command that starts the job. |
| 948 | 309 | If no value is given, then the value is taken from the | 346 | If \'KEY=VALUE\' is specified, the variable KEY is given the value VALUE. |
| 949 | 347 | If only \'KEY\' is given, then the value is taken from the | ||
| 950 | 310 | .BR init (8) | 348 | .BR init (8) |
| 951 | 311 | daemon's own environment. | 349 | daemon's own environment. |
| 952 | 312 | .\" | 350 | .\" |
| 953 | @@ -366,7 +404,7 @@ | |||
| 954 | 366 | times in | 404 | times in |
| 955 | 367 | .I INTERVAL | 405 | .I INTERVAL |
| 956 | 368 | seconds, it will be considered to be having deeper problems and will | 406 | seconds, it will be considered to be having deeper problems and will |
| 958 | 369 | be stopped. | 407 | be stopped. Default COUNT is 10. Default INTERVAL is 5 seconds. |
| 959 | 370 | 408 | ||
| 960 | 371 | This only applies to automatic respawns and not the | 409 | This only applies to automatic respawns and not the |
| 961 | 372 | .BR restart (8) | 410 | .BR restart (8) |
| 962 | @@ -385,7 +423,8 @@ | |||
| 963 | 385 | .SS Instances | 423 | .SS Instances |
| 964 | 386 | By default, only one instance of any job is permitted to exist at one | 424 | By default, only one instance of any job is permitted to exist at one |
| 965 | 387 | time. Attempting to start a job when it's already starting or running | 425 | time. Attempting to start a job when it's already starting or running |
| 967 | 388 | results in an error. | 426 | results in an error. Note that a job is considered to be running if its |
| 968 | 427 | pre-start process is running. | ||
| 969 | 389 | 428 | ||
| 970 | 390 | Multiple instances may be permitted by defining the names of those | 429 | Multiple instances may be permitted by defining the names of those |
| 971 | 391 | instances. If an instance with the same name is not already starting | 430 | instances. If an instance with the same name is not already starting |
| 972 | @@ -561,6 +600,46 @@ | |||
| 973 | 561 | .B unlimited | 600 | .B unlimited |
| 974 | 562 | may be specified for either. | 601 | may be specified for either. |
| 975 | 563 | .\" | 602 | .\" |
| 976 | 603 | .SS Override File Handling | ||
| 977 | 604 | Override files allow a jobs environment to be changed without modifying | ||
| 978 | 605 | the jobs configuration file. Rules governing override files: | ||
| 979 | 606 | |||
| 980 | 607 | .IP \[bu] 2 | ||
| 981 | 608 | If a job is embodied with only a configuration file, the contents of | ||
| 982 | 609 | this file define the job. | ||
| 983 | 610 | .IP \[bu] | ||
| 984 | 611 | If an override files exists where there is no existing cofiguration | ||
| 985 | 612 | file, the override file is ignored. | ||
| 986 | 613 | .IP \[bu] | ||
| 987 | 614 | If both a configuration file \fBand\fP an override file exist for a job | ||
| 988 | 615 | and both files are syntactically correct: | ||
| 989 | 616 | .RS | ||
| 990 | 617 | .IP \[bu] 2 | ||
| 991 | 618 | stanzas in the override file will take precedence over stanzas present | ||
| 992 | 619 | in the corresponding configuration file. | ||
| 993 | 620 | .IP \[bu] | ||
| 994 | 621 | stanzas in the override file which are not present in the corresponding | ||
| 995 | 622 | configuration file will be honoured when the job runs. | ||
| 996 | 623 | .RE | ||
| 997 | 624 | .IP \[bu] | ||
| 998 | 625 | If both a configuration file and an override file exist for a job and | ||
| 999 | 626 | subsequently the override file is deleted, the configuration file is | ||
| 1000 | 627 | automatically reloaded with the effect that any changes introduced by | ||
| 1001 | 628 | the override file are undone and the configuration file alone now defines | ||
| 1002 | 629 | the job. | ||
| 1003 | 630 | .IP \[bu] | ||
| 1004 | 631 | If both a configuration file and an override file exist for a job and | ||
| 1005 | 632 | subsequently the configuration file is deleted, a new instance of the | ||
| 1006 | 633 | job can no longer be started (since without a corresponding | ||
| 1007 | 634 | configuration file an override file is ignored). | ||
| 1008 | 635 | .IP \[bu] | ||
| 1009 | 636 | If both a configuration file and an override file exist for a job and | ||
| 1010 | 637 | any of the contents of the override file are invalid, the override file | ||
| 1011 | 638 | is ignored and only the contents of the configuration file are | ||
| 1012 | 639 | considered. | ||
| 1013 | 640 | .P | ||
| 1014 | 641 | |||
| 1015 | 642 | .\" | ||
| 1016 | 564 | .SS Miscellaneous | 643 | .SS Miscellaneous |
| 1017 | 565 | .TP | 644 | .TP |
| 1018 | 566 | .B kill timeout \fIINTERVAL | 645 | .B kill timeout \fIINTERVAL |
| 1019 | @@ -568,7 +647,7 @@ | |||
| 1020 | 568 | .I SIGTERM | 647 | .I SIGTERM |
| 1021 | 569 | and | 648 | and |
| 1022 | 570 | .I SIGKILL | 649 | .I SIGKILL |
| 1024 | 571 | signals when stopping the running job. | 650 | signals when stopping the running job. Default is 5 seconds. |
| 1025 | 572 | .\" | 651 | .\" |
| 1026 | 573 | .TP | 652 | .TP |
| 1027 | 574 | .B expect stop | 653 | .B expect stop |
| 1028 | @@ -609,6 +688,48 @@ | |||
| 1029 | 609 | is unable to supervise forking processes and will believe them to have | 688 | is unable to supervise forking processes and will believe them to have |
| 1030 | 610 | stopped as soon as they fork on startup. | 689 | stopped as soon as they fork on startup. |
| 1031 | 611 | .\" | 690 | .\" |
| 1032 | 691 | .SH BUGS | ||
| 1033 | 692 | The | ||
| 1034 | 693 | .B and | ||
| 1035 | 694 | and | ||
| 1036 | 695 | .B or | ||
| 1037 | 696 | operators allowed with | ||
| 1038 | 697 | .B start on | ||
| 1039 | 698 | and | ||
| 1040 | 699 | .B stop on | ||
| 1041 | 700 | do not work intuitively: operands to the right of either operator are | ||
| 1042 | 701 | only evaluated once and state information is then discarded. This can | ||
| 1043 | 702 | lead to jobs with complex \fBstart on\fP or \fPstop on\fP conditions | ||
| 1044 | 703 | not behaving as expected \fIwhen restarted\fP. For example, if a job | ||
| 1045 | 704 | encodes the following condition: | ||
| 1046 | 705 | .ti +4 | ||
| 1047 | 706 | .sp 1 | ||
| 1048 | 707 | .nf | ||
| 1049 | 708 | start on A and (B or C) | ||
| 1050 | 709 | .fi | ||
| 1051 | 710 | |||
| 1052 | 711 | When 'A' and 'B' become true, the condition is satisfied so the job will | ||
| 1053 | 712 | be run. However, if the job ends and subsequently 'A' and 'C' become true, | ||
| 1054 | 713 | the job will \fInot\fP be re-run even though the condtion is satisfied. | ||
| 1055 | 714 | Avoid using complex conditions with jobs which need to be restarted. | ||
| 1056 | 715 | .\" | ||
| 1057 | 716 | .SH AUTHOR | ||
| 1058 | 717 | Manual page written by Scott James Remnant | ||
| 1059 | 718 | .RB < scott@netsplit.com > | ||
| 1060 | 719 | and James Hunt | ||
| 1061 | 720 | .RB < james.hunt@canonical.com > . | ||
| 1062 | 721 | .\" | ||
| 1063 | 722 | .SH REPORTING BUGS | ||
| 1064 | 723 | Report bugs at | ||
| 1065 | 724 | .RB < https://launchpad.net/upstart/+bugs > | ||
| 1066 | 725 | .\" | ||
| 1067 | 726 | .SH COPYRIGHT | ||
| 1068 | 727 | Copyright \(co 2010 Canonical Ltd. | ||
| 1069 | 728 | .br | ||
| 1070 | 729 | This is free software; see the source for copying conditions. There is NO | ||
| 1071 | 730 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | ||
| 1072 | 731 | |||
| 1073 | 732 | .\" | ||
| 1074 | 612 | .SH SEE ALSO | 733 | .SH SEE ALSO |
| 1075 | 613 | .BR init (8) | 734 | .BR init (8) |
| 1076 | 614 | .BR sh (1) | 735 | .BR sh (1) |
| 1077 | 615 | 736 | ||
| 1078 | === modified file 'init/man/init.8' | |||
| 1079 | --- init/man/init.8 2010-02-04 19:26:17 +0000 | |||
| 1080 | +++ init/man/init.8 2011-01-21 11:55:09 +0000 | |||
| 1081 | @@ -96,12 +96,13 @@ | |||
| 1082 | 96 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | 96 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| 1083 | 97 | .\" | 97 | .\" |
| 1084 | 98 | .SH SEE ALSO | 98 | .SH SEE ALSO |
| 1085 | 99 | .BR control-alt-delete (7) | ||
| 1086 | 99 | .BR init (5) | 100 | .BR init (5) |
| 1087 | 100 | .BR initctl (8) | 101 | .BR initctl (8) |
| 1088 | 101 | .BR telinit (8) | ||
| 1089 | 102 | .BR runlevel (7) | 102 | .BR runlevel (7) |
| 1090 | 103 | .BR startup (7) | 103 | .BR startup (7) |
| 1091 | 104 | .BR starting (7) | 104 | .BR starting (7) |
| 1092 | 105 | .BR started (7) | 105 | .BR started (7) |
| 1093 | 106 | .BR stopping (7) | 106 | .BR stopping (7) |
| 1094 | 107 | .BR stopped (7) | 107 | .BR stopped (7) |
| 1095 | 108 | .BR telinit (8) | ||
| 1096 | 108 | 109 | ||
| 1097 | === modified file 'init/parse_conf.c' | |||
| 1098 | --- init/parse_conf.c 2009-06-23 09:29:35 +0000 | |||
| 1099 | +++ init/parse_conf.c 2011-01-21 11:55:09 +0000 | |||
| 1100 | @@ -74,6 +74,12 @@ | |||
| 1101 | 74 | nih_assert (file != NULL); | 74 | nih_assert (file != NULL); |
| 1102 | 75 | nih_assert (pos != NULL); | 75 | nih_assert (pos != NULL); |
| 1103 | 76 | 76 | ||
| 1104 | 77 | /* If we update 'stanzas' to allow content in init.conf, this | ||
| 1105 | 78 | * function must be updated in a similar manner to parse_job() | ||
| 1106 | 79 | * to handle overrides files. | ||
| 1107 | 80 | */ | ||
| 1108 | 81 | nih_assert (sizeof(stanzas) / sizeof(stanzas[0]) == 1); | ||
| 1109 | 82 | |||
| 1110 | 77 | if (nih_config_parse_file (file, len, pos, lineno, | 83 | if (nih_config_parse_file (file, len, pos, lineno, |
| 1111 | 78 | stanzas, conffile) < 0) | 84 | stanzas, conffile) < 0) |
| 1112 | 79 | return -1; | 85 | return -1; |
| 1113 | 80 | 86 | ||
| 1114 | === modified file 'init/parse_job.c' | |||
| 1115 | --- init/parse_job.c 2010-12-14 16:37:15 +0000 | |||
| 1116 | +++ init/parse_job.c 2011-01-21 11:55:09 +0000 | |||
| 1117 | @@ -263,6 +263,7 @@ | |||
| 1118 | 263 | /** | 263 | /** |
| 1119 | 264 | * parse_job: | 264 | * parse_job: |
| 1120 | 265 | * @parent: parent object for new job, | 265 | * @parent: parent object for new job, |
| 1121 | 266 | * @update: If not NULL, update the existing specified JobClass, | ||
| 1122 | 266 | * @name: name of new job, | 267 | * @name: name of new job, |
| 1123 | 267 | * @file: file or string to parse, | 268 | * @file: file or string to parse, |
| 1124 | 268 | * @len: length of @file, | 269 | * @len: length of @file, |
| 1125 | @@ -278,10 +279,12 @@ | |||
| 1126 | 278 | * of the returned job are freed, the returned job will also be | 279 | * of the returned job are freed, the returned job will also be |
| 1127 | 279 | * freed. | 280 | * freed. |
| 1128 | 280 | * | 281 | * |
| 1130 | 281 | * Returns: new JobClass structure on success, NULL on raised error. | 282 | * Returns: if @update is NULL, returns new JobClass structure on success, NULL on raised error. |
| 1131 | 283 | * If @update is not NULL, returns @update or NULL on error. | ||
| 1132 | 282 | **/ | 284 | **/ |
| 1133 | 283 | JobClass * | 285 | JobClass * |
| 1134 | 284 | parse_job (const void *parent, | 286 | parse_job (const void *parent, |
| 1135 | 287 | JobClass *update, | ||
| 1136 | 285 | const char *name, | 288 | const char *name, |
| 1137 | 286 | const char *file, | 289 | const char *file, |
| 1138 | 287 | size_t len, | 290 | size_t len, |
| 1139 | @@ -294,13 +297,22 @@ | |||
| 1140 | 294 | nih_assert (file != NULL); | 297 | nih_assert (file != NULL); |
| 1141 | 295 | nih_assert (pos != NULL); | 298 | nih_assert (pos != NULL); |
| 1142 | 296 | 299 | ||
| 1146 | 297 | class = job_class_new (parent, name); | 300 | if (update) { |
| 1147 | 298 | if (! class) | 301 | class = update; |
| 1148 | 299 | nih_return_system_error (NULL); | 302 | nih_debug ("Reusing JobClass %s (%s)", |
| 1149 | 303 | class->name, class->path); | ||
| 1150 | 304 | } else { | ||
| 1151 | 305 | nih_debug ("Creating new JobClass %s", | ||
| 1152 | 306 | name); | ||
| 1153 | 307 | class = job_class_new (parent, name); | ||
| 1154 | 308 | if (! class) | ||
| 1155 | 309 | nih_return_system_error (NULL); | ||
| 1156 | 310 | } | ||
| 1157 | 300 | 311 | ||
| 1158 | 301 | if (nih_config_parse_file (file, len, pos, lineno, | 312 | if (nih_config_parse_file (file, len, pos, lineno, |
| 1161 | 302 | stanzas, class) < 0) { | 313 | stanzas, class) < 0) { |
| 1162 | 303 | nih_free (class); | 314 | if (!update) |
| 1163 | 315 | nih_free (class); | ||
| 1164 | 304 | return NULL; | 316 | return NULL; |
| 1165 | 305 | } | 317 | } |
| 1166 | 306 | 318 | ||
| 1167 | 307 | 319 | ||
| 1168 | === modified file 'init/parse_job.h' | |||
| 1169 | --- init/parse_job.h 2009-06-23 09:29:35 +0000 | |||
| 1170 | +++ init/parse_job.h 2011-01-21 11:55:09 +0000 | |||
| 1171 | @@ -27,9 +27,9 @@ | |||
| 1172 | 27 | 27 | ||
| 1173 | 28 | NIH_BEGIN_EXTERN | 28 | NIH_BEGIN_EXTERN |
| 1174 | 29 | 29 | ||
| 1178 | 30 | JobClass *parse_job (const void *parent, const char *name, | 30 | JobClass *parse_job (const void *parent, JobClass *update, |
| 1179 | 31 | const char *file, size_t len, | 31 | const char *name, const char *file, |
| 1180 | 32 | size_t *pos, size_t *lineno) | 32 | size_t len, size_t *pos, size_t *lineno) |
| 1181 | 33 | __attribute__ ((warn_unused_result, malloc)); | 33 | __attribute__ ((warn_unused_result, malloc)); |
| 1182 | 34 | 34 | ||
| 1183 | 35 | NIH_END_EXTERN | 35 | NIH_END_EXTERN |
| 1184 | 36 | 36 | ||
| 1185 | === modified file 'init/paths.h' | |||
| 1186 | --- init/paths.h 2010-02-26 15:27:14 +0000 | |||
| 1187 | +++ init/paths.h 2011-01-21 11:55:09 +0000 | |||
| 1188 | @@ -103,5 +103,55 @@ | |||
| 1189 | 103 | #define TELINIT SBINDIR "/telinit" | 103 | #define TELINIT SBINDIR "/telinit" |
| 1190 | 104 | #endif | 104 | #endif |
| 1191 | 105 | 105 | ||
| 1192 | 106 | /** | ||
| 1193 | 107 | * File extension for standard configuration files. | ||
| 1194 | 108 | **/ | ||
| 1195 | 109 | #define CONF_EXT_STD ".conf" | ||
| 1196 | 110 | |||
| 1197 | 111 | /** | ||
| 1198 | 112 | * File extension for override files. | ||
| 1199 | 113 | * | ||
| 1200 | 114 | * Note that override files are not stored in the ConfSource 'files' hash: | ||
| 1201 | 115 | * all JobClass information from override files is added to the JobClass for | ||
| 1202 | 116 | * the corresponding (CONF_EXT_STD) object. | ||
| 1203 | 117 | **/ | ||
| 1204 | 118 | #define CONF_EXT_OVERRIDE ".override" | ||
| 1205 | 119 | |||
| 1206 | 120 | /** | ||
| 1207 | 121 | * Determine if specified path extension representes a standard | ||
| 1208 | 122 | * configuration file. | ||
| 1209 | 123 | * | ||
| 1210 | 124 | * @period: pointer to last period in path to check. | ||
| 1211 | 125 | * | ||
| 1212 | 126 | * Returns 1 if specified path extension matches that for a | ||
| 1213 | 127 | * standard configuration file, else return 0. | ||
| 1214 | 128 | **/ | ||
| 1215 | 129 | #define IS_CONF_EXT_STD(period) \ | ||
| 1216 | 130 | (!strcmp (period, CONF_EXT_STD)) | ||
| 1217 | 131 | |||
| 1218 | 132 | /** | ||
| 1219 | 133 | * Determine if specified path extension representes an | ||
| 1220 | 134 | * override file. | ||
| 1221 | 135 | * | ||
| 1222 | 136 | * @period: pointer to last period in path to check. | ||
| 1223 | 137 | * | ||
| 1224 | 138 | * Returns 1 if specified path extension matches that for | ||
| 1225 | 139 | * an override file, else return 0. | ||
| 1226 | 140 | **/ | ||
| 1227 | 141 | #define IS_CONF_EXT_OVERRIDE(period) \ | ||
| 1228 | 142 | (!strcmp (period, CONF_EXT_OVERRIDE)) | ||
| 1229 | 143 | |||
| 1230 | 144 | /** | ||
| 1231 | 145 | * Determine if specified filename has a valid configuration | ||
| 1232 | 146 | * file name extension. | ||
| 1233 | 147 | * | ||
| 1234 | 148 | * @period: pointer to last period in filename. | ||
| 1235 | 149 | * | ||
| 1236 | 150 | * Returns: TRUE if extension beyond @period is one of the | ||
| 1237 | 151 | * recognized types, else FALSE. | ||
| 1238 | 152 | **/ | ||
| 1239 | 153 | #define IS_CONF_EXT(period) \ | ||
| 1240 | 154 | (IS_CONF_EXT_STD(period) || \ | ||
| 1241 | 155 | IS_CONF_EXT_OVERRIDE(period)) | ||
| 1242 | 106 | 156 | ||
| 1243 | 107 | #endif /* INIT_PATHS_H */ | 157 | #endif /* INIT_PATHS_H */ |
| 1244 | 108 | 158 | ||
| 1245 | === modified file 'init/tests/test_conf.c' | |||
| 1246 | --- init/tests/test_conf.c 2009-07-08 21:05:59 +0000 | |||
| 1247 | +++ init/tests/test_conf.c 2011-01-21 11:55:09 +0000 | |||
| 1248 | @@ -46,6 +46,50 @@ | |||
| 1249 | 46 | #include "job.h" | 46 | #include "job.h" |
| 1250 | 47 | #include "conf.h" | 47 | #include "conf.h" |
| 1251 | 48 | 48 | ||
| 1252 | 49 | /* macro to try and ensure the environment is as pristine as possible | ||
| 1253 | 50 | * (to avoid follow-on errors caused by not freeing objects in a | ||
| 1254 | 51 | * previous test, say) | ||
| 1255 | 52 | */ | ||
| 1256 | 53 | #define TEST_ENSURE_CLEAN_ENV() \ | ||
| 1257 | 54 | { \ | ||
| 1258 | 55 | setvbuf(stdout, NULL, _IONBF, 0); \ | ||
| 1259 | 56 | \ | ||
| 1260 | 57 | if (job_classes) { \ | ||
| 1261 | 58 | TEST_HASH_EMPTY (job_classes); \ | ||
| 1262 | 59 | } \ | ||
| 1263 | 60 | \ | ||
| 1264 | 61 | if (conf_sources) { \ | ||
| 1265 | 62 | TEST_LIST_EMPTY (conf_sources); \ | ||
| 1266 | 63 | } \ | ||
| 1267 | 64 | \ | ||
| 1268 | 65 | if (nih_io_watches) { \ | ||
| 1269 | 66 | TEST_LIST_EMPTY (nih_io_watches); \ | ||
| 1270 | 67 | } \ | ||
| 1271 | 68 | \ | ||
| 1272 | 69 | if (nih_timers) { \ | ||
| 1273 | 70 | TEST_LIST_EMPTY (nih_timers); \ | ||
| 1274 | 71 | } \ | ||
| 1275 | 72 | \ | ||
| 1276 | 73 | if (events) { \ | ||
| 1277 | 74 | TEST_LIST_EMPTY (events); \ | ||
| 1278 | 75 | } \ | ||
| 1279 | 76 | } | ||
| 1280 | 77 | |||
| 1281 | 78 | /* Force an inotify watch update */ | ||
| 1282 | 79 | #define TEST_FORCE_WATCH_UPDATE() \ | ||
| 1283 | 80 | { \ | ||
| 1284 | 81 | int nfds = 0; \ | ||
| 1285 | 82 | fd_set readfds, writefds, exceptfds; \ | ||
| 1286 | 83 | \ | ||
| 1287 | 84 | FD_ZERO (&readfds); \ | ||
| 1288 | 85 | FD_ZERO (&writefds); \ | ||
| 1289 | 86 | FD_ZERO (&exceptfds); \ | ||
| 1290 | 87 | \ | ||
| 1291 | 88 | nih_debug("calling nih_io_select_fds"); \ | ||
| 1292 | 89 | nih_io_select_fds (&nfds, &readfds, &writefds, &exceptfds); \ | ||
| 1293 | 90 | nih_debug("calling nih_io_handle_fds"); \ | ||
| 1294 | 91 | nih_io_handle_fds (&readfds, &writefds, &exceptfds); \ | ||
| 1295 | 92 | } | ||
| 1296 | 49 | 93 | ||
| 1297 | 50 | void | 94 | void |
| 1298 | 51 | test_source_new (void) | 95 | test_source_new (void) |
| 1299 | @@ -2270,6 +2314,1255 @@ | |||
| 1300 | 2270 | } | 2314 | } |
| 1301 | 2271 | } | 2315 | } |
| 1302 | 2272 | 2316 | ||
| 1303 | 2317 | void | ||
| 1304 | 2318 | test_toggle_conf_name (void) | ||
| 1305 | 2319 | { | ||
| 1306 | 2320 | char override_ext[] = ".override"; | ||
| 1307 | 2321 | char dirname[PATH_MAX]; | ||
| 1308 | 2322 | char filename[PATH_MAX]; | ||
| 1309 | 2323 | JobClass *job; | ||
| 1310 | 2324 | char *f; | ||
| 1311 | 2325 | char *p; | ||
| 1312 | 2326 | |||
| 1313 | 2327 | TEST_FUNCTION_FEATURE ("toggle_conf_name", | ||
| 1314 | 2328 | "changing conf to override"); | ||
| 1315 | 2329 | |||
| 1316 | 2330 | TEST_FILENAME (dirname); | ||
| 1317 | 2331 | strcpy (filename, dirname); | ||
| 1318 | 2332 | strcat (filename, "/foo.conf"); | ||
| 1319 | 2333 | f = toggle_conf_name (NULL, filename); | ||
| 1320 | 2334 | TEST_NE_P (f, NULL); | ||
| 1321 | 2335 | |||
| 1322 | 2336 | p = strstr (f, ".override"); | ||
| 1323 | 2337 | TEST_NE_P (p, NULL); | ||
| 1324 | 2338 | TEST_EQ_P (p, f+strlen (f) - strlen (override_ext)); | ||
| 1325 | 2339 | nih_free (f); | ||
| 1326 | 2340 | |||
| 1327 | 2341 | TEST_FEATURE ("changing override to conf"); | ||
| 1328 | 2342 | strcpy (filename, dirname); | ||
| 1329 | 2343 | strcat (filename, "/bar.override"); | ||
| 1330 | 2344 | f = toggle_conf_name (NULL, filename); | ||
| 1331 | 2345 | TEST_NE_P (f, NULL); | ||
| 1332 | 2346 | |||
| 1333 | 2347 | p = strstr (f, ".conf"); | ||
| 1334 | 2348 | TEST_NE_P (p, NULL); | ||
| 1335 | 2349 | TEST_EQ_P (p, f+strlen (f) - strlen (".conf")); | ||
| 1336 | 2350 | nih_free (f); | ||
| 1337 | 2351 | |||
| 1338 | 2352 | /* test parent param */ | ||
| 1339 | 2353 | job = job_class_new (NULL, "foo"); | ||
| 1340 | 2354 | TEST_NE_P (job, NULL); | ||
| 1341 | 2355 | |||
| 1342 | 2356 | f = toggle_conf_name (job, filename); | ||
| 1343 | 2357 | TEST_NE_P (f, NULL); | ||
| 1344 | 2358 | |||
| 1345 | 2359 | TEST_EQ (TRUE, nih_alloc_parent (f, job)); | ||
| 1346 | 2360 | |||
| 1347 | 2361 | nih_free (job); | ||
| 1348 | 2362 | } | ||
| 1349 | 2363 | |||
| 1350 | 2364 | void | ||
| 1351 | 2365 | test_override (void) | ||
| 1352 | 2366 | { | ||
| 1353 | 2367 | ConfSource *source; | ||
| 1354 | 2368 | ConfFile *file; | ||
| 1355 | 2369 | FILE *f; | ||
| 1356 | 2370 | int ret, fd[4096], i = 0; | ||
| 1357 | 2371 | char dirname[PATH_MAX]; | ||
| 1358 | 2372 | char filename[PATH_MAX], override[PATH_MAX]; | ||
| 1359 | 2373 | JobClass *job; | ||
| 1360 | 2374 | NihError *err; | ||
| 1361 | 2375 | |||
| 1362 | 2376 | program_name = "test"; | ||
| 1363 | 2377 | nih_log_set_priority (NIH_LOG_FATAL); | ||
| 1364 | 2378 | |||
| 1365 | 2379 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1366 | 2380 | TEST_GROUP ("override files"); | ||
| 1367 | 2381 | |||
| 1368 | 2382 | /* Make sure that we have inotify before performing some tests... */ | ||
| 1369 | 2383 | if ((fd[0] = inotify_init ()) < 0) { | ||
| 1370 | 2384 | printf ("SKIP: inotify not available\n"); | ||
| 1371 | 2385 | goto no_inotify; | ||
| 1372 | 2386 | } | ||
| 1373 | 2387 | close (fd[0]); | ||
| 1374 | 2388 | |||
| 1375 | 2389 | |||
| 1376 | 2390 | /* Explicit test of behaviour prior to introduction of override files. | ||
| 1377 | 2391 | * | ||
| 1378 | 2392 | * conf with no override before watch: | ||
| 1379 | 2393 | * create conf | ||
| 1380 | 2394 | * create watch | ||
| 1381 | 2395 | * ensure conf loaded | ||
| 1382 | 2396 | * update conf | ||
| 1383 | 2397 | * ensure conf updated | ||
| 1384 | 2398 | * delete conf | ||
| 1385 | 2399 | * ensure conf deleted | ||
| 1386 | 2400 | */ | ||
| 1387 | 2401 | TEST_FEATURE ("with pre-override environment (conf with no override before watch)"); | ||
| 1388 | 2402 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1389 | 2403 | TEST_FILENAME (dirname); | ||
| 1390 | 2404 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 1391 | 2405 | |||
| 1392 | 2406 | /* create conf */ | ||
| 1393 | 2407 | strcpy (filename, dirname); | ||
| 1394 | 2408 | strcat (filename, "/foo.conf"); | ||
| 1395 | 2409 | f = fopen (filename, "w"); | ||
| 1396 | 2410 | TEST_NE_P (f, NULL); | ||
| 1397 | 2411 | fprintf (f, "start on started\n"); | ||
| 1398 | 2412 | fprintf (f, "emits hello\n"); | ||
| 1399 | 2413 | fclose (f); | ||
| 1400 | 2414 | |||
| 1401 | 2415 | /* create watch */ | ||
| 1402 | 2416 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 1403 | 2417 | TEST_NE_P (source, NULL); | ||
| 1404 | 2418 | ret = conf_source_reload (source); | ||
| 1405 | 2419 | TEST_EQ (ret, 0); | ||
| 1406 | 2420 | |||
| 1407 | 2421 | /* ensure conf loaded */ | ||
| 1408 | 2422 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1409 | 2423 | TEST_NE_P (file, NULL); | ||
| 1410 | 2424 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1411 | 2425 | TEST_NE_P (job, NULL); | ||
| 1412 | 2426 | TEST_EQ_P (file->job, job); | ||
| 1413 | 2427 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1414 | 2428 | TEST_NE_P (job->start_on, NULL); | ||
| 1415 | 2429 | |||
| 1416 | 2430 | /* update conf */ | ||
| 1417 | 2431 | f = fopen (filename, "a"); | ||
| 1418 | 2432 | TEST_NE_P (f, NULL); | ||
| 1419 | 2433 | fprintf (f, "manual\n"); | ||
| 1420 | 2434 | fclose (f); | ||
| 1421 | 2435 | |||
| 1422 | 2436 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1423 | 2437 | |||
| 1424 | 2438 | /* ensure conf updated */ | ||
| 1425 | 2439 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1426 | 2440 | TEST_NE_P (file, NULL); | ||
| 1427 | 2441 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1428 | 2442 | TEST_NE_P (job, NULL); | ||
| 1429 | 2443 | TEST_EQ_P (job->start_on, NULL); | ||
| 1430 | 2444 | |||
| 1431 | 2445 | /* delete conf */ | ||
| 1432 | 2446 | unlink (filename); | ||
| 1433 | 2447 | |||
| 1434 | 2448 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1435 | 2449 | |||
| 1436 | 2450 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1437 | 2451 | TEST_EQ_P (job, NULL); | ||
| 1438 | 2452 | TEST_HASH_EMPTY (job_classes); | ||
| 1439 | 2453 | TEST_HASH_EMPTY (source->files); | ||
| 1440 | 2454 | |||
| 1441 | 2455 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1442 | 2456 | |||
| 1443 | 2457 | /* ensure conf deleted */ | ||
| 1444 | 2458 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1445 | 2459 | TEST_EQ_P (file, NULL); | ||
| 1446 | 2460 | |||
| 1447 | 2461 | nih_free (source); | ||
| 1448 | 2462 | TEST_EQ (rmdir (dirname), 0); | ||
| 1449 | 2463 | |||
| 1450 | 2464 | |||
| 1451 | 2465 | /* Explicit test of behaviour prior to introduction of override files. | ||
| 1452 | 2466 | * | ||
| 1453 | 2467 | * conf with no override after watch: | ||
| 1454 | 2468 | * create watch | ||
| 1455 | 2469 | * create conf | ||
| 1456 | 2470 | * ensure conf loaded | ||
| 1457 | 2471 | * update conf | ||
| 1458 | 2472 | * ensure conf updated | ||
| 1459 | 2473 | * delete conf | ||
| 1460 | 2474 | * ensure conf deleted | ||
| 1461 | 2475 | */ | ||
| 1462 | 2476 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1463 | 2477 | TEST_FEATURE ("with pre-override environment (conf with no override after watch)"); | ||
| 1464 | 2478 | TEST_FILENAME (dirname); | ||
| 1465 | 2479 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 1466 | 2480 | |||
| 1467 | 2481 | /* create watch */ | ||
| 1468 | 2482 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 1469 | 2483 | TEST_NE_P (source, NULL); | ||
| 1470 | 2484 | ret = conf_source_reload (source); | ||
| 1471 | 2485 | TEST_EQ (ret, 0); | ||
| 1472 | 2486 | |||
| 1473 | 2487 | /* create conf */ | ||
| 1474 | 2488 | strcpy (filename, dirname); | ||
| 1475 | 2489 | strcat (filename, "/foo.conf"); | ||
| 1476 | 2490 | f = fopen (filename, "w"); | ||
| 1477 | 2491 | TEST_NE_P (f, NULL); | ||
| 1478 | 2492 | fprintf (f, "start on started\n"); | ||
| 1479 | 2493 | fprintf (f, "emits hello\n"); | ||
| 1480 | 2494 | fclose (f); | ||
| 1481 | 2495 | |||
| 1482 | 2496 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1483 | 2497 | |||
| 1484 | 2498 | /* ensure conf loaded */ | ||
| 1485 | 2499 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1486 | 2500 | TEST_NE_P (file, NULL); | ||
| 1487 | 2501 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1488 | 2502 | TEST_NE_P (job, NULL); | ||
| 1489 | 2503 | TEST_EQ_P (file->job, job); | ||
| 1490 | 2504 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1491 | 2505 | |||
| 1492 | 2506 | /* update conf */ | ||
| 1493 | 2507 | f = fopen (filename, "a"); | ||
| 1494 | 2508 | TEST_NE_P (f, NULL); | ||
| 1495 | 2509 | fprintf (f, "manual\n"); | ||
| 1496 | 2510 | fclose (f); | ||
| 1497 | 2511 | |||
| 1498 | 2512 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1499 | 2513 | |||
| 1500 | 2514 | /* ensure conf updated */ | ||
| 1501 | 2515 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1502 | 2516 | TEST_NE_P (job, NULL); | ||
| 1503 | 2517 | TEST_EQ_P (job->start_on, NULL); | ||
| 1504 | 2518 | |||
| 1505 | 2519 | /* delete conf */ | ||
| 1506 | 2520 | unlink (filename); | ||
| 1507 | 2521 | |||
| 1508 | 2522 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1509 | 2523 | |||
| 1510 | 2524 | /* ensure conf deleted */ | ||
| 1511 | 2525 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1512 | 2526 | TEST_EQ_P (file, NULL); | ||
| 1513 | 2527 | nih_free (source); | ||
| 1514 | 2528 | TEST_EQ (rmdir (dirname), 0); | ||
| 1515 | 2529 | |||
| 1516 | 2530 | |||
| 1517 | 2531 | TEST_FEATURE ("ensure lone override ignored before watch"); | ||
| 1518 | 2532 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1519 | 2533 | TEST_FILENAME (dirname); | ||
| 1520 | 2534 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 1521 | 2535 | |||
| 1522 | 2536 | /* create override */ | ||
| 1523 | 2537 | strcpy (filename, dirname); | ||
| 1524 | 2538 | strcat (filename, "/foo.override"); | ||
| 1525 | 2539 | f = fopen (filename, "w"); | ||
| 1526 | 2540 | TEST_NE_P (f, NULL); | ||
| 1527 | 2541 | fprintf (f, "manual\n"); | ||
| 1528 | 2542 | fclose (f); | ||
| 1529 | 2543 | |||
| 1530 | 2544 | /* create watch */ | ||
| 1531 | 2545 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 1532 | 2546 | TEST_NE_P (source, NULL); | ||
| 1533 | 2547 | ret = conf_source_reload (source); | ||
| 1534 | 2548 | TEST_EQ (ret, 0); | ||
| 1535 | 2549 | |||
| 1536 | 2550 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1537 | 2551 | |||
| 1538 | 2552 | /* ensure no conf object created */ | ||
| 1539 | 2553 | TEST_HASH_EMPTY (source->files); | ||
| 1540 | 2554 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1541 | 2555 | TEST_EQ_P (file, NULL); | ||
| 1542 | 2556 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1543 | 2557 | TEST_EQ_P (job, NULL); | ||
| 1544 | 2558 | |||
| 1545 | 2559 | /* update override */ | ||
| 1546 | 2560 | f = fopen (filename, "a"); | ||
| 1547 | 2561 | TEST_NE_P (f, NULL); | ||
| 1548 | 2562 | fprintf (f, "author \"me\"\n"); | ||
| 1549 | 2563 | fclose (f); | ||
| 1550 | 2564 | |||
| 1551 | 2565 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1552 | 2566 | |||
| 1553 | 2567 | /* ensure no conf object created */ | ||
| 1554 | 2568 | TEST_HASH_EMPTY (source->files); | ||
| 1555 | 2569 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1556 | 2570 | TEST_EQ_P (file, NULL); | ||
| 1557 | 2571 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1558 | 2572 | TEST_EQ_P (job, NULL); | ||
| 1559 | 2573 | |||
| 1560 | 2574 | /* delete override */ | ||
| 1561 | 2575 | unlink (filename); | ||
| 1562 | 2576 | nih_free (source); | ||
| 1563 | 2577 | TEST_EQ (rmdir (dirname), 0); | ||
| 1564 | 2578 | |||
| 1565 | 2579 | |||
| 1566 | 2580 | TEST_FEATURE ("ensure lone override ignored after watch"); | ||
| 1567 | 2581 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1568 | 2582 | TEST_FILENAME (dirname); | ||
| 1569 | 2583 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 1570 | 2584 | |||
| 1571 | 2585 | /* create watch */ | ||
| 1572 | 2586 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 1573 | 2587 | TEST_NE_P (source, NULL); | ||
| 1574 | 2588 | ret = conf_source_reload (source); | ||
| 1575 | 2589 | TEST_EQ (ret, 0); | ||
| 1576 | 2590 | |||
| 1577 | 2591 | strcpy (filename, dirname); | ||
| 1578 | 2592 | strcat (filename, "/bar.override"); | ||
| 1579 | 2593 | f = fopen (filename, "w"); | ||
| 1580 | 2594 | TEST_NE_P (f, NULL); | ||
| 1581 | 2595 | fprintf (f, "manual\n"); | ||
| 1582 | 2596 | fclose (f); | ||
| 1583 | 2597 | |||
| 1584 | 2598 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1585 | 2599 | |||
| 1586 | 2600 | /* ensure no conf object created */ | ||
| 1587 | 2601 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1588 | 2602 | TEST_EQ_P (file, NULL); | ||
| 1589 | 2603 | job = (JobClass *)nih_hash_lookup (job_classes, "bar"); | ||
| 1590 | 2604 | TEST_EQ_P (job, NULL); | ||
| 1591 | 2605 | |||
| 1592 | 2606 | /* delete override */ | ||
| 1593 | 2607 | unlink (filename); | ||
| 1594 | 2608 | |||
| 1595 | 2609 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1596 | 2610 | |||
| 1597 | 2611 | /* ensure override still not present */ | ||
| 1598 | 2612 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1599 | 2613 | TEST_EQ_P (file, NULL); | ||
| 1600 | 2614 | job = (JobClass *)nih_hash_lookup (job_classes, "bar"); | ||
| 1601 | 2615 | TEST_EQ_P (job, NULL); | ||
| 1602 | 2616 | |||
| 1603 | 2617 | nih_free (source); | ||
| 1604 | 2618 | TEST_EQ (rmdir (dirname), 0); | ||
| 1605 | 2619 | |||
| 1606 | 2620 | |||
| 1607 | 2621 | TEST_FEATURE ("create conf, watch, then create/modify/delete override"); | ||
| 1608 | 2622 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1609 | 2623 | TEST_FILENAME (dirname); | ||
| 1610 | 2624 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 1611 | 2625 | |||
| 1612 | 2626 | /* create conf */ | ||
| 1613 | 2627 | strcpy (filename, dirname); | ||
| 1614 | 2628 | strcat (filename, "/foo.conf"); | ||
| 1615 | 2629 | f = fopen (filename, "w"); | ||
| 1616 | 2630 | TEST_NE_P (f, NULL); | ||
| 1617 | 2631 | fprintf (f, "start on started\n"); | ||
| 1618 | 2632 | fprintf (f, "emits hello\n"); | ||
| 1619 | 2633 | fclose (f); | ||
| 1620 | 2634 | |||
| 1621 | 2635 | /* create watch */ | ||
| 1622 | 2636 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 1623 | 2637 | TEST_NE_P (source, NULL); | ||
| 1624 | 2638 | ret = conf_source_reload (source); | ||
| 1625 | 2639 | TEST_EQ (ret, 0); | ||
| 1626 | 2640 | |||
| 1627 | 2641 | /* ensure conf loaded */ | ||
| 1628 | 2642 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 1629 | 2643 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1630 | 2644 | TEST_NE_P (file, NULL); | ||
| 1631 | 2645 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1632 | 2646 | TEST_NE_P (job, NULL); | ||
| 1633 | 2647 | TEST_EQ_P (file->job, job); | ||
| 1634 | 2648 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1635 | 2649 | TEST_EQ_P ((job->emits)[1], NULL); | ||
| 1636 | 2650 | TEST_NE_P (job->start_on, NULL); | ||
| 1637 | 2651 | |||
| 1638 | 2652 | /* create override */ | ||
| 1639 | 2653 | strcpy (override, dirname); | ||
| 1640 | 2654 | strcat (override, "/foo.override"); | ||
| 1641 | 2655 | f = fopen (override, "w"); | ||
| 1642 | 2656 | TEST_NE_P (f, NULL); | ||
| 1643 | 2657 | fprintf (f, "manual\n"); | ||
| 1644 | 2658 | fclose (f); | ||
| 1645 | 2659 | |||
| 1646 | 2660 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 1647 | 2661 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1648 | 2662 | |||
| 1649 | 2663 | /* ensure conf updated */ | ||
| 1650 | 2664 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 1651 | 2665 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1652 | 2666 | TEST_NE_P (file, NULL); | ||
| 1653 | 2667 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1654 | 2668 | TEST_NE_P (job, NULL); | ||
| 1655 | 2669 | TEST_EQ_P (job->start_on, NULL); | ||
| 1656 | 2670 | |||
| 1657 | 2671 | /* ensure no override in hash */ | ||
| 1658 | 2672 | file = (ConfFile *)nih_hash_lookup (source->files, override); | ||
| 1659 | 2673 | TEST_EQ_P (file, NULL); | ||
| 1660 | 2674 | |||
| 1661 | 2675 | /* modify override */ | ||
| 1662 | 2676 | f = fopen (override, "a"); | ||
| 1663 | 2677 | TEST_NE_P (f, NULL); | ||
| 1664 | 2678 | fprintf (f, "emits world\n"); | ||
| 1665 | 2679 | fclose (f); | ||
| 1666 | 2680 | |||
| 1667 | 2681 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1668 | 2682 | |||
| 1669 | 2683 | /* ensure conf updated */ | ||
| 1670 | 2684 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1671 | 2685 | TEST_NE_P (file, NULL); | ||
| 1672 | 2686 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1673 | 2687 | TEST_NE_P (job, NULL); | ||
| 1674 | 2688 | TEST_EQ_P (job->start_on, NULL); | ||
| 1675 | 2689 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1676 | 2690 | TEST_EQ_STR ((job->emits)[1], "world"); | ||
| 1677 | 2691 | |||
| 1678 | 2692 | /* delete override */ | ||
| 1679 | 2693 | unlink (override); | ||
| 1680 | 2694 | |||
| 1681 | 2695 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1682 | 2696 | |||
| 1683 | 2697 | /* ensure conf reverted */ | ||
| 1684 | 2698 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1685 | 2699 | TEST_NE_P (file, NULL); | ||
| 1686 | 2700 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1687 | 2701 | TEST_NE_P (job, NULL); | ||
| 1688 | 2702 | TEST_NE_P (job->start_on, NULL); | ||
| 1689 | 2703 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1690 | 2704 | TEST_EQ_P ((job->emits)[1], NULL); | ||
| 1691 | 2705 | |||
| 1692 | 2706 | nih_free (source); | ||
| 1693 | 2707 | unlink (filename); | ||
| 1694 | 2708 | TEST_EQ (rmdir (dirname), 0); | ||
| 1695 | 2709 | |||
| 1696 | 2710 | |||
| 1697 | 2711 | TEST_FEATURE ("create watch, conf, then create/modify/delete override"); | ||
| 1698 | 2712 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1699 | 2713 | TEST_FILENAME (dirname); | ||
| 1700 | 2714 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 1701 | 2715 | |||
| 1702 | 2716 | /* create watch */ | ||
| 1703 | 2717 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 1704 | 2718 | TEST_NE_P (source, NULL); | ||
| 1705 | 2719 | ret = conf_source_reload (source); | ||
| 1706 | 2720 | TEST_EQ (ret, 0); | ||
| 1707 | 2721 | |||
| 1708 | 2722 | /* create conf */ | ||
| 1709 | 2723 | strcpy (filename, dirname); | ||
| 1710 | 2724 | strcat (filename, "/foo.conf"); | ||
| 1711 | 2725 | f = fopen (filename, "w"); | ||
| 1712 | 2726 | TEST_NE_P (f, NULL); | ||
| 1713 | 2727 | fprintf (f, "start on started\n"); | ||
| 1714 | 2728 | fprintf (f, "emits hello\n"); | ||
| 1715 | 2729 | fclose (f); | ||
| 1716 | 2730 | |||
| 1717 | 2731 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1718 | 2732 | |||
| 1719 | 2733 | /* ensure conf loaded */ | ||
| 1720 | 2734 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 1721 | 2735 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1722 | 2736 | TEST_NE_P (file, NULL); | ||
| 1723 | 2737 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1724 | 2738 | TEST_NE_P (job, NULL); | ||
| 1725 | 2739 | TEST_EQ_P (file->job, job); | ||
| 1726 | 2740 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1727 | 2741 | TEST_EQ_P ((job->emits)[1], NULL); | ||
| 1728 | 2742 | TEST_NE_P (job->start_on, NULL); | ||
| 1729 | 2743 | |||
| 1730 | 2744 | /* create override */ | ||
| 1731 | 2745 | strcpy (override, dirname); | ||
| 1732 | 2746 | strcat (override, "/foo.override"); | ||
| 1733 | 2747 | f = fopen (override, "w"); | ||
| 1734 | 2748 | TEST_NE_P (f, NULL); | ||
| 1735 | 2749 | fprintf (f, "manual\n"); | ||
| 1736 | 2750 | fclose (f); | ||
| 1737 | 2751 | |||
| 1738 | 2752 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 1739 | 2753 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1740 | 2754 | |||
| 1741 | 2755 | /* ensure conf updated */ | ||
| 1742 | 2756 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 1743 | 2757 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1744 | 2758 | TEST_NE_P (file, NULL); | ||
| 1745 | 2759 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1746 | 2760 | TEST_NE_P (job, NULL); | ||
| 1747 | 2761 | TEST_EQ_P (job->start_on, NULL); | ||
| 1748 | 2762 | |||
| 1749 | 2763 | /* ensure no override in hash */ | ||
| 1750 | 2764 | file = (ConfFile *)nih_hash_lookup (source->files, override); | ||
| 1751 | 2765 | TEST_EQ_P (file, NULL); | ||
| 1752 | 2766 | |||
| 1753 | 2767 | /* modify override */ | ||
| 1754 | 2768 | f = fopen (override, "a"); | ||
| 1755 | 2769 | TEST_NE_P (f, NULL); | ||
| 1756 | 2770 | fprintf (f, "emits world\n"); | ||
| 1757 | 2771 | fclose (f); | ||
| 1758 | 2772 | |||
| 1759 | 2773 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1760 | 2774 | |||
| 1761 | 2775 | /* ensure conf updated */ | ||
| 1762 | 2776 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1763 | 2777 | TEST_NE_P (file, NULL); | ||
| 1764 | 2778 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1765 | 2779 | TEST_NE_P (job, NULL); | ||
| 1766 | 2780 | TEST_EQ_P (job->start_on, NULL); | ||
| 1767 | 2781 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1768 | 2782 | TEST_EQ_STR ((job->emits)[1], "world"); | ||
| 1769 | 2783 | |||
| 1770 | 2784 | /* delete override */ | ||
| 1771 | 2785 | unlink (override); | ||
| 1772 | 2786 | |||
| 1773 | 2787 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1774 | 2788 | |||
| 1775 | 2789 | /* ensure conf reverted */ | ||
| 1776 | 2790 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1777 | 2791 | TEST_NE_P (file, NULL); | ||
| 1778 | 2792 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1779 | 2793 | TEST_NE_P (job, NULL); | ||
| 1780 | 2794 | TEST_NE_P (job->start_on, NULL); | ||
| 1781 | 2795 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1782 | 2796 | TEST_EQ_P ((job->emits)[1], NULL); | ||
| 1783 | 2797 | |||
| 1784 | 2798 | nih_free (source); | ||
| 1785 | 2799 | unlink (filename); | ||
| 1786 | 2800 | TEST_EQ (rmdir (dirname), 0); | ||
| 1787 | 2801 | |||
| 1788 | 2802 | |||
| 1789 | 2803 | TEST_FEATURE ("create override, watch, then create/modify/delete conf"); | ||
| 1790 | 2804 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1791 | 2805 | TEST_FILENAME (dirname); | ||
| 1792 | 2806 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 1793 | 2807 | |||
| 1794 | 2808 | strcpy (filename, dirname); | ||
| 1795 | 2809 | strcat (filename, "/foo.conf"); | ||
| 1796 | 2810 | strcpy (override, dirname); | ||
| 1797 | 2811 | strcat (override, "/foo.override"); | ||
| 1798 | 2812 | |||
| 1799 | 2813 | /* create override */ | ||
| 1800 | 2814 | f = fopen (override, "w"); | ||
| 1801 | 2815 | TEST_NE_P (f, NULL); | ||
| 1802 | 2816 | fprintf (f, "manual\n"); | ||
| 1803 | 2817 | fprintf (f, "author \"bar\"\n"); | ||
| 1804 | 2818 | fclose (f); | ||
| 1805 | 2819 | |||
| 1806 | 2820 | /* create watch */ | ||
| 1807 | 2821 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 1808 | 2822 | TEST_NE_P (source, NULL); | ||
| 1809 | 2823 | ret = conf_source_reload (source); | ||
| 1810 | 2824 | TEST_EQ (ret, 0); | ||
| 1811 | 2825 | |||
| 1812 | 2826 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1813 | 2827 | |||
| 1814 | 2828 | /* ensure no conf object created */ | ||
| 1815 | 2829 | TEST_HASH_EMPTY (source->files); | ||
| 1816 | 2830 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1817 | 2831 | TEST_EQ_P (file, NULL); | ||
| 1818 | 2832 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1819 | 2833 | TEST_EQ_P (job, NULL); | ||
| 1820 | 2834 | |||
| 1821 | 2835 | /* create conf */ | ||
| 1822 | 2836 | f = fopen (filename, "w"); | ||
| 1823 | 2837 | TEST_NE_P (f, NULL); | ||
| 1824 | 2838 | fprintf (f, "start on started\n"); | ||
| 1825 | 2839 | fprintf (f, "emits hello\n"); | ||
| 1826 | 2840 | fprintf (f, "author \"foo\"\n"); | ||
| 1827 | 2841 | fclose (f); | ||
| 1828 | 2842 | |||
| 1829 | 2843 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1830 | 2844 | |||
| 1831 | 2845 | /* ensure conf loaded */ | ||
| 1832 | 2846 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1833 | 2847 | TEST_NE_P (file, NULL); | ||
| 1834 | 2848 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1835 | 2849 | TEST_NE_P (job, NULL); | ||
| 1836 | 2850 | TEST_EQ_P (file->job, job); | ||
| 1837 | 2851 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1838 | 2852 | |||
| 1839 | 2853 | /* should pick up override, *NOT* conf */ | ||
| 1840 | 2854 | TEST_EQ_P (job->start_on, NULL); | ||
| 1841 | 2855 | TEST_EQ_STR (job->author, "bar"); | ||
| 1842 | 2856 | |||
| 1843 | 2857 | /* modify conf */ | ||
| 1844 | 2858 | f = fopen (filename, "w"); | ||
| 1845 | 2859 | TEST_NE_P (f, NULL); | ||
| 1846 | 2860 | fprintf (f, "start on wibble\n"); | ||
| 1847 | 2861 | fprintf (f, "emits moo\n"); | ||
| 1848 | 2862 | fclose (f); | ||
| 1849 | 2863 | |||
| 1850 | 2864 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1851 | 2865 | |||
| 1852 | 2866 | /* ensure conf reloaded and updated with override */ | ||
| 1853 | 2867 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1854 | 2868 | TEST_NE_P (file, NULL); | ||
| 1855 | 2869 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1856 | 2870 | TEST_NE_P (job, NULL); | ||
| 1857 | 2871 | TEST_EQ_P (file->job, job); | ||
| 1858 | 2872 | TEST_EQ_STR ((job->emits)[0], "moo"); | ||
| 1859 | 2873 | |||
| 1860 | 2874 | /* should pick up override, *NOT* conf */ | ||
| 1861 | 2875 | TEST_EQ_P (job->start_on, NULL); | ||
| 1862 | 2876 | TEST_EQ_STR (job->author, "bar"); | ||
| 1863 | 2877 | |||
| 1864 | 2878 | /* delete conf */ | ||
| 1865 | 2879 | unlink (filename); | ||
| 1866 | 2880 | |||
| 1867 | 2881 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1868 | 2882 | |||
| 1869 | 2883 | /* ensure conf object deleted */ | ||
| 1870 | 2884 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1871 | 2885 | TEST_EQ_P (file, NULL); | ||
| 1872 | 2886 | TEST_HASH_EMPTY (source->files); | ||
| 1873 | 2887 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1874 | 2888 | TEST_EQ_P (job, NULL); | ||
| 1875 | 2889 | file = (ConfFile *)nih_hash_lookup (source->files, override); | ||
| 1876 | 2890 | TEST_EQ_P (file, NULL); | ||
| 1877 | 2891 | |||
| 1878 | 2892 | unlink (override); | ||
| 1879 | 2893 | |||
| 1880 | 2894 | /* ensure no conf object still */ | ||
| 1881 | 2895 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1882 | 2896 | TEST_EQ_P (file, NULL); | ||
| 1883 | 2897 | TEST_HASH_EMPTY (source->files); | ||
| 1884 | 2898 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1885 | 2899 | TEST_EQ_P (job, NULL); | ||
| 1886 | 2900 | file = (ConfFile *)nih_hash_lookup (source->files, override); | ||
| 1887 | 2901 | TEST_EQ_P (file, NULL); | ||
| 1888 | 2902 | |||
| 1889 | 2903 | nih_free (source); | ||
| 1890 | 2904 | TEST_EQ (rmdir (dirname), 0); | ||
| 1891 | 2905 | |||
| 1892 | 2906 | |||
| 1893 | 2907 | TEST_FEATURE ("create watch, override, then create/modify/delete conf"); | ||
| 1894 | 2908 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1895 | 2909 | TEST_FILENAME (dirname); | ||
| 1896 | 2910 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 1897 | 2911 | |||
| 1898 | 2912 | /* create watch */ | ||
| 1899 | 2913 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 1900 | 2914 | TEST_NE_P (source, NULL); | ||
| 1901 | 2915 | ret = conf_source_reload (source); | ||
| 1902 | 2916 | TEST_EQ (ret, 0); | ||
| 1903 | 2917 | |||
| 1904 | 2918 | strcpy (filename, dirname); | ||
| 1905 | 2919 | strcat (filename, "/foo.conf"); | ||
| 1906 | 2920 | strcpy (override, dirname); | ||
| 1907 | 2921 | strcat (override, "/foo.override"); | ||
| 1908 | 2922 | |||
| 1909 | 2923 | /* create override */ | ||
| 1910 | 2924 | f = fopen (override, "w"); | ||
| 1911 | 2925 | TEST_NE_P (f, NULL); | ||
| 1912 | 2926 | fprintf (f, "manual\n"); | ||
| 1913 | 2927 | fprintf (f, "author \"bar\"\n"); | ||
| 1914 | 2928 | fclose (f); | ||
| 1915 | 2929 | |||
| 1916 | 2930 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1917 | 2931 | |||
| 1918 | 2932 | /* ensure no conf object created */ | ||
| 1919 | 2933 | TEST_HASH_EMPTY (source->files); | ||
| 1920 | 2934 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1921 | 2935 | TEST_EQ_P (file, NULL); | ||
| 1922 | 2936 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1923 | 2937 | TEST_EQ_P (job, NULL); | ||
| 1924 | 2938 | |||
| 1925 | 2939 | /* create conf */ | ||
| 1926 | 2940 | f = fopen (filename, "w"); | ||
| 1927 | 2941 | TEST_NE_P (f, NULL); | ||
| 1928 | 2942 | fprintf (f, "start on started\n"); | ||
| 1929 | 2943 | fprintf (f, "emits hello\n"); | ||
| 1930 | 2944 | fprintf (f, "author \"foo\"\n"); | ||
| 1931 | 2945 | fclose (f); | ||
| 1932 | 2946 | |||
| 1933 | 2947 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1934 | 2948 | |||
| 1935 | 2949 | /* ensure conf loaded */ | ||
| 1936 | 2950 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1937 | 2951 | TEST_NE_P (file, NULL); | ||
| 1938 | 2952 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1939 | 2953 | TEST_NE_P (job, NULL); | ||
| 1940 | 2954 | TEST_EQ_P (file->job, job); | ||
| 1941 | 2955 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 1942 | 2956 | |||
| 1943 | 2957 | /* should pick up override, *NOT* conf */ | ||
| 1944 | 2958 | TEST_EQ_P (job->start_on, NULL); | ||
| 1945 | 2959 | TEST_EQ_STR (job->author, "bar"); | ||
| 1946 | 2960 | |||
| 1947 | 2961 | /* modify conf */ | ||
| 1948 | 2962 | f = fopen (filename, "w"); | ||
| 1949 | 2963 | TEST_NE_P (f, NULL); | ||
| 1950 | 2964 | fprintf (f, "start on wibble\n"); | ||
| 1951 | 2965 | fprintf (f, "emits moo\n"); | ||
| 1952 | 2966 | fclose (f); | ||
| 1953 | 2967 | |||
| 1954 | 2968 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1955 | 2969 | |||
| 1956 | 2970 | /* ensure conf reloaded and updated with override */ | ||
| 1957 | 2971 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1958 | 2972 | TEST_NE_P (file, NULL); | ||
| 1959 | 2973 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1960 | 2974 | TEST_NE_P (job, NULL); | ||
| 1961 | 2975 | TEST_EQ_P (file->job, job); | ||
| 1962 | 2976 | TEST_EQ_STR ((job->emits)[0], "moo"); | ||
| 1963 | 2977 | |||
| 1964 | 2978 | /* should pick up override, *NOT* conf */ | ||
| 1965 | 2979 | TEST_EQ_P (job->start_on, NULL); | ||
| 1966 | 2980 | TEST_EQ_STR (job->author, "bar"); | ||
| 1967 | 2981 | |||
| 1968 | 2982 | /* delete conf */ | ||
| 1969 | 2983 | unlink (filename); | ||
| 1970 | 2984 | |||
| 1971 | 2985 | TEST_FORCE_WATCH_UPDATE(); | ||
| 1972 | 2986 | |||
| 1973 | 2987 | /* ensure conf object deleted */ | ||
| 1974 | 2988 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1975 | 2989 | TEST_EQ_P (file, NULL); | ||
| 1976 | 2990 | TEST_HASH_EMPTY (source->files); | ||
| 1977 | 2991 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1978 | 2992 | TEST_EQ_P (job, NULL); | ||
| 1979 | 2993 | file = (ConfFile *)nih_hash_lookup (source->files, override); | ||
| 1980 | 2994 | TEST_EQ_P (file, NULL); | ||
| 1981 | 2995 | |||
| 1982 | 2996 | unlink (override); | ||
| 1983 | 2997 | |||
| 1984 | 2998 | /* ensure no conf object still */ | ||
| 1985 | 2999 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 1986 | 3000 | TEST_EQ_P (file, NULL); | ||
| 1987 | 3001 | TEST_HASH_EMPTY (source->files); | ||
| 1988 | 3002 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 1989 | 3003 | TEST_EQ_P (job, NULL); | ||
| 1990 | 3004 | file = (ConfFile *)nih_hash_lookup (source->files, override); | ||
| 1991 | 3005 | TEST_EQ_P (file, NULL); | ||
| 1992 | 3006 | |||
| 1993 | 3007 | nih_free (source); | ||
| 1994 | 3008 | TEST_EQ (rmdir (dirname), 0); | ||
| 1995 | 3009 | |||
| 1996 | 3010 | |||
| 1997 | 3011 | TEST_FEATURE ("create override, watch, conf, then modify/delete override"); | ||
| 1998 | 3012 | TEST_ENSURE_CLEAN_ENV (); | ||
| 1999 | 3013 | TEST_FILENAME (dirname); | ||
| 2000 | 3014 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 2001 | 3015 | |||
| 2002 | 3016 | strcpy (filename, dirname); | ||
| 2003 | 3017 | strcat (filename, "/foo.conf"); | ||
| 2004 | 3018 | strcpy (override, dirname); | ||
| 2005 | 3019 | strcat (override, "/foo.override"); | ||
| 2006 | 3020 | |||
| 2007 | 3021 | /* create override */ | ||
| 2008 | 3022 | f = fopen (override, "w"); | ||
| 2009 | 3023 | TEST_NE_P (f, NULL); | ||
| 2010 | 3024 | fprintf (f, "manual\n"); | ||
| 2011 | 3025 | fprintf (f, "author \"bar\"\n"); | ||
| 2012 | 3026 | fclose (f); | ||
| 2013 | 3027 | |||
| 2014 | 3028 | /* create watch */ | ||
| 2015 | 3029 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 2016 | 3030 | TEST_NE_P (source, NULL); | ||
| 2017 | 3031 | ret = conf_source_reload (source); | ||
| 2018 | 3032 | TEST_EQ (ret, 0); | ||
| 2019 | 3033 | |||
| 2020 | 3034 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2021 | 3035 | |||
| 2022 | 3036 | /* ensure no conf object created */ | ||
| 2023 | 3037 | TEST_HASH_EMPTY (source->files); | ||
| 2024 | 3038 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2025 | 3039 | TEST_EQ_P (file, NULL); | ||
| 2026 | 3040 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2027 | 3041 | TEST_EQ_P (job, NULL); | ||
| 2028 | 3042 | |||
| 2029 | 3043 | /* create conf */ | ||
| 2030 | 3044 | f = fopen (filename, "w"); | ||
| 2031 | 3045 | TEST_NE_P (f, NULL); | ||
| 2032 | 3046 | fprintf (f, "start on started\n"); | ||
| 2033 | 3047 | fprintf (f, "emits hello\n"); | ||
| 2034 | 3048 | fprintf (f, "author \"foo\"\n"); | ||
| 2035 | 3049 | fclose (f); | ||
| 2036 | 3050 | |||
| 2037 | 3051 | /* FIXME: crashes here */ | ||
| 2038 | 3052 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2039 | 3053 | |||
| 2040 | 3054 | /* ensure conf loaded */ | ||
| 2041 | 3055 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2042 | 3056 | TEST_NE_P (file, NULL); | ||
| 2043 | 3057 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2044 | 3058 | TEST_NE_P (job, NULL); | ||
| 2045 | 3059 | TEST_EQ_P (file->job, job); | ||
| 2046 | 3060 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2047 | 3061 | |||
| 2048 | 3062 | /* should pick up override, *NOT* conf */ | ||
| 2049 | 3063 | TEST_EQ_P (job->start_on, NULL); | ||
| 2050 | 3064 | TEST_EQ_STR (job->author, "bar"); | ||
| 2051 | 3065 | |||
| 2052 | 3066 | /* modify override */ | ||
| 2053 | 3067 | f = fopen (override, "w"); | ||
| 2054 | 3068 | TEST_NE_P (f, NULL); | ||
| 2055 | 3069 | fprintf (f, "author \"meh\"\n"); | ||
| 2056 | 3070 | fprintf (f, "env wibble=wobble\n"); | ||
| 2057 | 3071 | fprintf (f, "manual\n"); | ||
| 2058 | 3072 | fclose (f); | ||
| 2059 | 3073 | |||
| 2060 | 3074 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2061 | 3075 | |||
| 2062 | 3076 | /* ensure conf reloaded and updated with override */ | ||
| 2063 | 3077 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2064 | 3078 | TEST_NE_P (file, NULL); | ||
| 2065 | 3079 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2066 | 3080 | TEST_NE_P (job, NULL); | ||
| 2067 | 3081 | TEST_EQ_P (file->job, job); | ||
| 2068 | 3082 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2069 | 3083 | |||
| 2070 | 3084 | /* should pick up override, *NOT* conf */ | ||
| 2071 | 3085 | TEST_EQ_P (job->start_on, NULL); | ||
| 2072 | 3086 | TEST_EQ_STR (job->author, "meh"); | ||
| 2073 | 3087 | TEST_EQ_STR ((job->env)[0], "wibble=wobble"); | ||
| 2074 | 3088 | |||
| 2075 | 3089 | /* delete override */ | ||
| 2076 | 3090 | unlink (override); | ||
| 2077 | 3091 | |||
| 2078 | 3092 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2079 | 3093 | |||
| 2080 | 3094 | /* ensure conf object reverted */ | ||
| 2081 | 3095 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2082 | 3096 | TEST_NE_P (file, NULL); | ||
| 2083 | 3097 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2084 | 3098 | TEST_NE_P (job, NULL); | ||
| 2085 | 3099 | TEST_NE_P (job->start_on, NULL); | ||
| 2086 | 3100 | TEST_EQ_STR (job->author, "foo"); | ||
| 2087 | 3101 | TEST_EQ_P (job->env, NULL); | ||
| 2088 | 3102 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2089 | 3103 | |||
| 2090 | 3104 | unlink (filename); | ||
| 2091 | 3105 | nih_free (source); | ||
| 2092 | 3106 | TEST_EQ (rmdir (dirname), 0); | ||
| 2093 | 3107 | |||
| 2094 | 3108 | |||
| 2095 | 3109 | TEST_FEATURE ("create watch, override, conf, then modify/delete override"); | ||
| 2096 | 3110 | TEST_ENSURE_CLEAN_ENV (); | ||
| 2097 | 3111 | TEST_FILENAME (dirname); | ||
| 2098 | 3112 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 2099 | 3113 | |||
| 2100 | 3114 | strcpy (filename, dirname); | ||
| 2101 | 3115 | strcat (filename, "/foo.conf"); | ||
| 2102 | 3116 | strcpy (override, dirname); | ||
| 2103 | 3117 | strcat (override, "/foo.override"); | ||
| 2104 | 3118 | |||
| 2105 | 3119 | /* create watch */ | ||
| 2106 | 3120 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 2107 | 3121 | TEST_NE_P (source, NULL); | ||
| 2108 | 3122 | ret = conf_source_reload (source); | ||
| 2109 | 3123 | TEST_EQ (ret, 0); | ||
| 2110 | 3124 | |||
| 2111 | 3125 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2112 | 3126 | |||
| 2113 | 3127 | /* create override */ | ||
| 2114 | 3128 | f = fopen (override, "w"); | ||
| 2115 | 3129 | TEST_NE_P (f, NULL); | ||
| 2116 | 3130 | fprintf (f, "manual\n"); | ||
| 2117 | 3131 | fprintf (f, "author \"bar\"\n"); | ||
| 2118 | 3132 | fclose (f); | ||
| 2119 | 3133 | |||
| 2120 | 3134 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2121 | 3135 | |||
| 2122 | 3136 | /* create conf */ | ||
| 2123 | 3137 | f = fopen (filename, "w"); | ||
| 2124 | 3138 | TEST_NE_P (f, NULL); | ||
| 2125 | 3139 | fprintf (f, "start on started\n"); | ||
| 2126 | 3140 | fprintf (f, "emits hello\n"); | ||
| 2127 | 3141 | fprintf (f, "author \"foo\"\n"); | ||
| 2128 | 3142 | fclose (f); | ||
| 2129 | 3143 | |||
| 2130 | 3144 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2131 | 3145 | |||
| 2132 | 3146 | /* ensure conf loaded */ | ||
| 2133 | 3147 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2134 | 3148 | TEST_NE_P (file, NULL); | ||
| 2135 | 3149 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2136 | 3150 | TEST_NE_P (job, NULL); | ||
| 2137 | 3151 | TEST_EQ_P (file->job, job); | ||
| 2138 | 3152 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2139 | 3153 | |||
| 2140 | 3154 | /* should pick up override, *NOT* conf */ | ||
| 2141 | 3155 | TEST_EQ_P (job->start_on, NULL); | ||
| 2142 | 3156 | TEST_EQ_STR (job->author, "bar"); | ||
| 2143 | 3157 | |||
| 2144 | 3158 | /* update override */ | ||
| 2145 | 3159 | f = fopen (override, "a"); | ||
| 2146 | 3160 | TEST_NE_P (f, NULL); | ||
| 2147 | 3161 | fprintf (f, "author \"me\"\n"); | ||
| 2148 | 3162 | fprintf (f, "env wibble=wobble\n"); | ||
| 2149 | 3163 | fclose (f); | ||
| 2150 | 3164 | |||
| 2151 | 3165 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2152 | 3166 | |||
| 2153 | 3167 | /* ensure conf reloaded and updated with override */ | ||
| 2154 | 3168 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2155 | 3169 | TEST_NE_P (file, NULL); | ||
| 2156 | 3170 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2157 | 3171 | TEST_NE_P (job, NULL); | ||
| 2158 | 3172 | TEST_EQ_P (file->job, job); | ||
| 2159 | 3173 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2160 | 3174 | |||
| 2161 | 3175 | /* should pick up override, *NOT* conf */ | ||
| 2162 | 3176 | TEST_EQ_P (job->start_on, NULL); | ||
| 2163 | 3177 | TEST_EQ_STR (job->author, "me"); | ||
| 2164 | 3178 | TEST_EQ_STR ((job->env)[0], "wibble=wobble"); | ||
| 2165 | 3179 | |||
| 2166 | 3180 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2167 | 3181 | |||
| 2168 | 3182 | /* delete override */ | ||
| 2169 | 3183 | unlink (override); | ||
| 2170 | 3184 | |||
| 2171 | 3185 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2172 | 3186 | |||
| 2173 | 3187 | /* ensure conf loaded */ | ||
| 2174 | 3188 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2175 | 3189 | TEST_NE_P (file, NULL); | ||
| 2176 | 3190 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2177 | 3191 | TEST_NE_P (job, NULL); | ||
| 2178 | 3192 | TEST_EQ_P (file->job, job); | ||
| 2179 | 3193 | TEST_EQ_STR (job->author, "foo"); | ||
| 2180 | 3194 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2181 | 3195 | TEST_NE_P (job->start_on, NULL); | ||
| 2182 | 3196 | TEST_EQ_P (job->env, NULL); | ||
| 2183 | 3197 | |||
| 2184 | 3198 | unlink (filename); | ||
| 2185 | 3199 | nih_free (source); | ||
| 2186 | 3200 | TEST_EQ (rmdir (dirname), 0); | ||
| 2187 | 3201 | |||
| 2188 | 3202 | |||
| 2189 | 3203 | TEST_FEATURE ("create both conf+override files, watch, then modify/delete conf"); | ||
| 2190 | 3204 | TEST_ENSURE_CLEAN_ENV (); | ||
| 2191 | 3205 | TEST_FILENAME (dirname); | ||
| 2192 | 3206 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 2193 | 3207 | |||
| 2194 | 3208 | /* create conf */ | ||
| 2195 | 3209 | strcpy (filename, dirname); | ||
| 2196 | 3210 | strcat (filename, "/foo.conf"); | ||
| 2197 | 3211 | f = fopen (filename, "w"); | ||
| 2198 | 3212 | TEST_NE_P (f, NULL); | ||
| 2199 | 3213 | fprintf (f, "start on started\n"); | ||
| 2200 | 3214 | fprintf (f, "author \"me\"\n"); | ||
| 2201 | 3215 | fprintf (f, "env foo=bar\n"); | ||
| 2202 | 3216 | fprintf (f, "emits hello\n"); | ||
| 2203 | 3217 | fclose (f); | ||
| 2204 | 3218 | |||
| 2205 | 3219 | /* create override */ | ||
| 2206 | 3220 | strcpy (override, dirname); | ||
| 2207 | 3221 | strcat (override, "/foo.override"); | ||
| 2208 | 3222 | f = fopen (override, "w"); | ||
| 2209 | 3223 | TEST_NE_P (f, NULL); | ||
| 2210 | 3224 | fprintf (f, "manual\n"); | ||
| 2211 | 3225 | fprintf (f, "author \"you\"\n"); | ||
| 2212 | 3226 | fclose (f); | ||
| 2213 | 3227 | |||
| 2214 | 3228 | /* create watch */ | ||
| 2215 | 3229 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 2216 | 3230 | TEST_NE_P (source, NULL); | ||
| 2217 | 3231 | ret = conf_source_reload (source); | ||
| 2218 | 3232 | TEST_EQ (ret, 0); | ||
| 2219 | 3233 | |||
| 2220 | 3234 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2221 | 3235 | |||
| 2222 | 3236 | /* ensure conf loaded */ | ||
| 2223 | 3237 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 2224 | 3238 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2225 | 3239 | TEST_NE_P (file, NULL); | ||
| 2226 | 3240 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2227 | 3241 | TEST_NE_P (job, NULL); | ||
| 2228 | 3242 | TEST_EQ_P (file->job, job); | ||
| 2229 | 3243 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2230 | 3244 | TEST_EQ_STR (job->author, "you"); | ||
| 2231 | 3245 | TEST_EQ_P (job->start_on, NULL); | ||
| 2232 | 3246 | TEST_EQ_STR ((job->env)[0], "foo=bar"); | ||
| 2233 | 3247 | TEST_EQ_P (job->export, NULL); | ||
| 2234 | 3248 | |||
| 2235 | 3249 | /* modify conf */ | ||
| 2236 | 3250 | f = fopen (filename, "a"); | ||
| 2237 | 3251 | TEST_NE_P (f, NULL); | ||
| 2238 | 3252 | fprintf (f, "export foo\n"); | ||
| 2239 | 3253 | fclose (f); | ||
| 2240 | 3254 | |||
| 2241 | 3255 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2242 | 3256 | |||
| 2243 | 3257 | /* ensure conf updated */ | ||
| 2244 | 3258 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 2245 | 3259 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2246 | 3260 | TEST_NE_P (file, NULL); | ||
| 2247 | 3261 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2248 | 3262 | TEST_NE_P (job, NULL); | ||
| 2249 | 3263 | TEST_EQ_STR ((job->env)[0], "foo=bar"); | ||
| 2250 | 3264 | TEST_NE_P (job->export, NULL); | ||
| 2251 | 3265 | TEST_EQ_STR ((job->export)[0], "foo"); | ||
| 2252 | 3266 | |||
| 2253 | 3267 | /* delete conf */ | ||
| 2254 | 3268 | unlink (filename); | ||
| 2255 | 3269 | |||
| 2256 | 3270 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2257 | 3271 | |||
| 2258 | 3272 | /* ensure conf object deleted */ | ||
| 2259 | 3273 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2260 | 3274 | TEST_EQ_P (file, NULL); | ||
| 2261 | 3275 | TEST_HASH_EMPTY (source->files); | ||
| 2262 | 3276 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2263 | 3277 | TEST_EQ_P (job, NULL); | ||
| 2264 | 3278 | file = (ConfFile *)nih_hash_lookup (source->files, override); | ||
| 2265 | 3279 | TEST_EQ_P (file, NULL); | ||
| 2266 | 3280 | |||
| 2267 | 3281 | unlink (override); | ||
| 2268 | 3282 | nih_free (source); | ||
| 2269 | 3283 | TEST_EQ (rmdir (dirname), 0); | ||
| 2270 | 3284 | |||
| 2271 | 3285 | TEST_FEATURE ("create both conf+override files, watch, then modify/delete override"); | ||
| 2272 | 3286 | TEST_ENSURE_CLEAN_ENV (); | ||
| 2273 | 3287 | TEST_FILENAME (dirname); | ||
| 2274 | 3288 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 2275 | 3289 | |||
| 2276 | 3290 | /* create conf */ | ||
| 2277 | 3291 | strcpy (filename, dirname); | ||
| 2278 | 3292 | strcat (filename, "/foo.conf"); | ||
| 2279 | 3293 | f = fopen (filename, "w"); | ||
| 2280 | 3294 | TEST_NE_P (f, NULL); | ||
| 2281 | 3295 | fprintf (f, "start on started\n"); | ||
| 2282 | 3296 | fprintf (f, "author \"me\"\n"); | ||
| 2283 | 3297 | fprintf (f, "env foo=bar\n"); | ||
| 2284 | 3298 | fprintf (f, "emits hello\n"); | ||
| 2285 | 3299 | fclose (f); | ||
| 2286 | 3300 | |||
| 2287 | 3301 | /* create override */ | ||
| 2288 | 3302 | strcpy (override, dirname); | ||
| 2289 | 3303 | strcat (override, "/foo.override"); | ||
| 2290 | 3304 | f = fopen (override, "w"); | ||
| 2291 | 3305 | TEST_NE_P (f, NULL); | ||
| 2292 | 3306 | fprintf (f, "manual\n"); | ||
| 2293 | 3307 | fprintf (f, "author \"you\"\n"); | ||
| 2294 | 3308 | fclose (f); | ||
| 2295 | 3309 | |||
| 2296 | 3310 | /* create watch */ | ||
| 2297 | 3311 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 2298 | 3312 | TEST_NE_P (source, NULL); | ||
| 2299 | 3313 | ret = conf_source_reload (source); | ||
| 2300 | 3314 | TEST_EQ (ret, 0); | ||
| 2301 | 3315 | |||
| 2302 | 3316 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2303 | 3317 | |||
| 2304 | 3318 | /* ensure conf loaded */ | ||
| 2305 | 3319 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 2306 | 3320 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2307 | 3321 | TEST_NE_P (file, NULL); | ||
| 2308 | 3322 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2309 | 3323 | TEST_NE_P (job, NULL); | ||
| 2310 | 3324 | TEST_EQ_P (file->job, job); | ||
| 2311 | 3325 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2312 | 3326 | TEST_EQ_STR (job->author, "you"); | ||
| 2313 | 3327 | TEST_EQ_P (job->start_on, NULL); | ||
| 2314 | 3328 | TEST_EQ_STR ((job->env)[0], "foo=bar"); | ||
| 2315 | 3329 | TEST_EQ_P (job->export, NULL); | ||
| 2316 | 3330 | |||
| 2317 | 3331 | /* modify override */ | ||
| 2318 | 3332 | f = fopen (override, "w"); | ||
| 2319 | 3333 | TEST_NE_P (f, NULL); | ||
| 2320 | 3334 | fprintf (f, "description \"hello world\"\n"); | ||
| 2321 | 3335 | fprintf (f, "author \"ubuntu\"\n"); | ||
| 2322 | 3336 | fclose (f); | ||
| 2323 | 3337 | |||
| 2324 | 3338 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2325 | 3339 | |||
| 2326 | 3340 | /* ensure conf updated */ | ||
| 2327 | 3341 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2328 | 3342 | TEST_NE_P (file, NULL); | ||
| 2329 | 3343 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2330 | 3344 | TEST_NE_P (job, NULL); | ||
| 2331 | 3345 | TEST_EQ_P (file->job, job); | ||
| 2332 | 3346 | TEST_EQ_STR (job->author, "ubuntu"); | ||
| 2333 | 3347 | TEST_NE_P (job->description, NULL); | ||
| 2334 | 3348 | TEST_EQ_STR (job->description, "hello world"); | ||
| 2335 | 3349 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2336 | 3350 | TEST_NE_P (job->start_on, NULL); | ||
| 2337 | 3351 | |||
| 2338 | 3352 | /* delete override */ | ||
| 2339 | 3353 | unlink (override); | ||
| 2340 | 3354 | |||
| 2341 | 3355 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2342 | 3356 | |||
| 2343 | 3357 | /* ensure conf updated */ | ||
| 2344 | 3358 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2345 | 3359 | TEST_NE_P (file, NULL); | ||
| 2346 | 3360 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2347 | 3361 | TEST_NE_P (job, NULL); | ||
| 2348 | 3362 | TEST_EQ_P (file->job, job); | ||
| 2349 | 3363 | TEST_NE_P (job->start_on, NULL); | ||
| 2350 | 3364 | TEST_EQ_STR ((job->env)[0], "foo=bar"); | ||
| 2351 | 3365 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2352 | 3366 | TEST_EQ_STR (job->author, "me"); | ||
| 2353 | 3367 | TEST_EQ_P (job->description, NULL); | ||
| 2354 | 3368 | |||
| 2355 | 3369 | nih_free (source); | ||
| 2356 | 3370 | unlink (filename); | ||
| 2357 | 3371 | TEST_EQ (rmdir (dirname), 0); | ||
| 2358 | 3372 | |||
| 2359 | 3373 | |||
| 2360 | 3374 | TEST_FEATURE ("create conf, watch, then create invalid override, delete override"); | ||
| 2361 | 3375 | TEST_ENSURE_CLEAN_ENV (); | ||
| 2362 | 3376 | TEST_FILENAME (dirname); | ||
| 2363 | 3377 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 2364 | 3378 | |||
| 2365 | 3379 | /* create conf */ | ||
| 2366 | 3380 | strcpy (filename, dirname); | ||
| 2367 | 3381 | strcat (filename, "/foo.conf"); | ||
| 2368 | 3382 | f = fopen (filename, "w"); | ||
| 2369 | 3383 | TEST_NE_P (f, NULL); | ||
| 2370 | 3384 | fprintf (f, "start on started\n"); | ||
| 2371 | 3385 | fprintf (f, "author \"wibble\"\n"); | ||
| 2372 | 3386 | fprintf (f, "emits hello\n"); | ||
| 2373 | 3387 | fclose (f); | ||
| 2374 | 3388 | |||
| 2375 | 3389 | /* create watch */ | ||
| 2376 | 3390 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 2377 | 3391 | TEST_NE_P (source, NULL); | ||
| 2378 | 3392 | ret = conf_source_reload (source); | ||
| 2379 | 3393 | TEST_EQ (ret, 0); | ||
| 2380 | 3394 | |||
| 2381 | 3395 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2382 | 3396 | |||
| 2383 | 3397 | /* ensure conf loaded */ | ||
| 2384 | 3398 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 2385 | 3399 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2386 | 3400 | TEST_NE_P (file, NULL); | ||
| 2387 | 3401 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2388 | 3402 | TEST_NE_P (job, NULL); | ||
| 2389 | 3403 | TEST_EQ_P (file->job, job); | ||
| 2390 | 3404 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2391 | 3405 | TEST_NE_P (job->start_on, NULL); | ||
| 2392 | 3406 | |||
| 2393 | 3407 | /* create (partially) invalid override (which should be | ||
| 2394 | 3408 | * fully ignored) | ||
| 2395 | 3409 | */ | ||
| 2396 | 3410 | strcpy (override, dirname); | ||
| 2397 | 3411 | strcat (override, "/foo.override"); | ||
| 2398 | 3412 | f = fopen (override, "w"); | ||
| 2399 | 3413 | TEST_NE_P (f, NULL); | ||
| 2400 | 3414 | fprintf (f, "manual\n"); | ||
| 2401 | 3415 | fprintf (f, "bleaugh!\n"); | ||
| 2402 | 3416 | fprintf (f, "wha...?\n"); | ||
| 2403 | 3417 | fprintf (f, "author \"moo\"\n"); | ||
| 2404 | 3418 | fclose (f); | ||
| 2405 | 3419 | |||
| 2406 | 3420 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2407 | 3421 | |||
| 2408 | 3422 | unlink (override); | ||
| 2409 | 3423 | |||
| 2410 | 3424 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2411 | 3425 | |||
| 2412 | 3426 | /* ensure conf still loaded */ | ||
| 2413 | 3427 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 2414 | 3428 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2415 | 3429 | TEST_NE_P (file, NULL); | ||
| 2416 | 3430 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2417 | 3431 | TEST_NE_P (job, NULL); | ||
| 2418 | 3432 | TEST_EQ_P (file->job, job); | ||
| 2419 | 3433 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2420 | 3434 | TEST_NE_P (job->start_on, NULL); | ||
| 2421 | 3435 | TEST_EQ_STR (job->author, "wibble"); | ||
| 2422 | 3436 | |||
| 2423 | 3437 | nih_free (source); | ||
| 2424 | 3438 | unlink (filename); | ||
| 2425 | 3439 | TEST_EQ (rmdir (dirname), 0); | ||
| 2426 | 3440 | |||
| 2427 | 3441 | TEST_FEATURE ("ensure override ignored for CONF_FILE"); | ||
| 2428 | 3442 | TEST_ENSURE_CLEAN_ENV (); | ||
| 2429 | 3443 | TEST_FILENAME (dirname); | ||
| 2430 | 3444 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 2431 | 3445 | |||
| 2432 | 3446 | /* create empty conf */ | ||
| 2433 | 3447 | strcpy (filename, dirname); | ||
| 2434 | 3448 | strcat (filename, "/init.conf"); | ||
| 2435 | 3449 | f = fopen (filename, "w"); | ||
| 2436 | 3450 | TEST_NE_P (f, NULL); | ||
| 2437 | 3451 | fclose (f); | ||
| 2438 | 3452 | |||
| 2439 | 3453 | /* create watch */ | ||
| 2440 | 3454 | source = conf_source_new (NULL, dirname, CONF_FILE); | ||
| 2441 | 3455 | TEST_NE_P (source, NULL); | ||
| 2442 | 3456 | ret = conf_source_reload (source); | ||
| 2443 | 3457 | |||
| 2444 | 3458 | /* We expect conf_source_reload to fail in this situation since | ||
| 2445 | 3459 | * although "init.conf" is a supported config file, it is not | ||
| 2446 | 3460 | * allowed to contain any stanzas, implying that it can only | ||
| 2447 | 3461 | * contain comments. In fact, if the file exists but is zero | ||
| 2448 | 3462 | * size that is currently an error since upstart blindly calls | ||
| 2449 | 3463 | * nih_file_read(), which will fail since there are no bytes to | ||
| 2450 | 3464 | * read. | ||
| 2451 | 3465 | */ | ||
| 2452 | 3466 | TEST_NE (ret, 0); | ||
| 2453 | 3467 | err = nih_error_steal (); | ||
| 2454 | 3468 | TEST_EQ (err->number, EILSEQ); | ||
| 2455 | 3469 | nih_free (err); | ||
| 2456 | 3470 | |||
| 2457 | 3471 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2458 | 3472 | |||
| 2459 | 3473 | /* ensure conf NOT loaded */ | ||
| 2460 | 3474 | TEST_HASH_EMPTY (source->files); | ||
| 2461 | 3475 | |||
| 2462 | 3476 | /* create override */ | ||
| 2463 | 3477 | strcpy (override, dirname); | ||
| 2464 | 3478 | strcat (override, "/init.override"); | ||
| 2465 | 3479 | f = fopen (override, "w"); | ||
| 2466 | 3480 | TEST_NE_P (f, NULL); | ||
| 2467 | 3481 | fprintf (f, "manual\n"); | ||
| 2468 | 3482 | fclose (f); | ||
| 2469 | 3483 | |||
| 2470 | 3484 | TEST_FORCE_WATCH_UPDATE(); | ||
| 2471 | 3485 | |||
| 2472 | 3486 | /* ensure conf still NOT loaded */ | ||
| 2473 | 3487 | TEST_HASH_EMPTY (source->files); | ||
| 2474 | 3488 | |||
| 2475 | 3489 | nih_free (source); | ||
| 2476 | 3490 | unlink (filename); | ||
| 2477 | 3491 | unlink (override); | ||
| 2478 | 3492 | TEST_EQ (rmdir (dirname), 0); | ||
| 2479 | 3493 | |||
| 2480 | 3494 | /* Consume all available inotify instances so that the following | ||
| 2481 | 3495 | * tests run without inotify. | ||
| 2482 | 3496 | */ | ||
| 2483 | 3497 | for (i = 0; i < 4096; i++) | ||
| 2484 | 3498 | if ((fd[i] = inotify_init ()) < 0) | ||
| 2485 | 3499 | break; | ||
| 2486 | 3500 | |||
| 2487 | 3501 | no_inotify: | ||
| 2488 | 3502 | /* If you don't have inotify, any override file must exist | ||
| 2489 | 3503 | * before the system boots. | ||
| 2490 | 3504 | */ | ||
| 2491 | 3505 | |||
| 2492 | 3506 | TEST_FEATURE ("both conf+override files with no inotify support"); | ||
| 2493 | 3507 | TEST_ENSURE_CLEAN_ENV (); | ||
| 2494 | 3508 | TEST_FILENAME (dirname); | ||
| 2495 | 3509 | TEST_EQ (mkdir (dirname, 0755), 0); | ||
| 2496 | 3510 | |||
| 2497 | 3511 | /* create conf */ | ||
| 2498 | 3512 | strcpy (filename, dirname); | ||
| 2499 | 3513 | strcat (filename, "/foo.conf"); | ||
| 2500 | 3514 | f = fopen (filename, "w"); | ||
| 2501 | 3515 | TEST_NE_P (f, NULL); | ||
| 2502 | 3516 | fprintf (f, "start on started\n"); | ||
| 2503 | 3517 | fprintf (f, "author \"me\"\n"); | ||
| 2504 | 3518 | fprintf (f, "env foo=bar\n"); | ||
| 2505 | 3519 | fprintf (f, "emits hello\n"); | ||
| 2506 | 3520 | fclose (f); | ||
| 2507 | 3521 | |||
| 2508 | 3522 | /* create override */ | ||
| 2509 | 3523 | strcpy (override, dirname); | ||
| 2510 | 3524 | strcat (override, "/foo.override"); | ||
| 2511 | 3525 | f = fopen (override, "w"); | ||
| 2512 | 3526 | TEST_NE_P (f, NULL); | ||
| 2513 | 3527 | fprintf (f, "manual\n"); | ||
| 2514 | 3528 | fprintf (f, "author \"you\"\n"); | ||
| 2515 | 3529 | fclose (f); | ||
| 2516 | 3530 | |||
| 2517 | 3531 | /* create watch */ | ||
| 2518 | 3532 | source = conf_source_new (NULL, dirname, CONF_JOB_DIR); | ||
| 2519 | 3533 | TEST_NE_P (source, NULL); | ||
| 2520 | 3534 | ret = conf_source_reload (source); | ||
| 2521 | 3535 | TEST_EQ (ret, 0); | ||
| 2522 | 3536 | |||
| 2523 | 3537 | /* ensure conf loaded */ | ||
| 2524 | 3538 | TEST_HASH_NOT_EMPTY (source->files); | ||
| 2525 | 3539 | file = (ConfFile *)nih_hash_lookup (source->files, filename); | ||
| 2526 | 3540 | TEST_NE_P (file, NULL); | ||
| 2527 | 3541 | job = (JobClass *)nih_hash_lookup (job_classes, "foo"); | ||
| 2528 | 3542 | TEST_NE_P (job, NULL); | ||
| 2529 | 3543 | TEST_EQ_P (file->job, job); | ||
| 2530 | 3544 | TEST_EQ_STR ((job->emits)[0], "hello"); | ||
| 2531 | 3545 | TEST_EQ_STR (job->author, "you"); | ||
| 2532 | 3546 | TEST_EQ_P (job->start_on, NULL); | ||
| 2533 | 3547 | TEST_EQ_STR ((job->env)[0], "foo=bar"); | ||
| 2534 | 3548 | TEST_EQ_P (job->export, NULL); | ||
| 2535 | 3549 | |||
| 2536 | 3550 | nih_free (source); | ||
| 2537 | 3551 | unlink (filename); | ||
| 2538 | 3552 | unlink (override); | ||
| 2539 | 3553 | TEST_EQ (rmdir (dirname), 0); | ||
| 2540 | 3554 | |||
| 2541 | 3555 | |||
| 2542 | 3556 | nih_log_set_priority (NIH_LOG_MESSAGE); | ||
| 2543 | 3557 | |||
| 2544 | 3558 | /* Release consumed instances */ | ||
| 2545 | 3559 | for (i = 0; i < 4096; i++) { | ||
| 2546 | 3560 | if (fd[i] < 0) | ||
| 2547 | 3561 | break; | ||
| 2548 | 3562 | |||
| 2549 | 3563 | close (fd[i]); | ||
| 2550 | 3564 | } | ||
| 2551 | 3565 | } | ||
| 2552 | 2273 | 3566 | ||
| 2553 | 2274 | void | 3567 | void |
| 2554 | 2275 | test_source_reload_file (void) | 3568 | test_source_reload_file (void) |
| 2555 | @@ -2822,8 +4115,6 @@ | |||
| 2556 | 2822 | TEST_HASH_EMPTY (source->files); | 4115 | TEST_HASH_EMPTY (source->files); |
| 2557 | 2823 | 4116 | ||
| 2558 | 2824 | nih_free (source); | 4117 | nih_free (source); |
| 2559 | 2825 | |||
| 2560 | 2826 | |||
| 2561 | 2827 | /* Consume all available inotify instances so that the following | 4118 | /* Consume all available inotify instances so that the following |
| 2562 | 2828 | * tests run without inotify. | 4119 | * tests run without inotify. |
| 2563 | 2829 | */ | 4120 | */ |
| 2564 | @@ -3309,6 +4600,8 @@ | |||
| 2565 | 3309 | test_source_reload_conf_dir (); | 4600 | test_source_reload_conf_dir (); |
| 2566 | 3310 | test_source_reload_file (); | 4601 | test_source_reload_file (); |
| 2567 | 3311 | test_source_reload (); | 4602 | test_source_reload (); |
| 2568 | 4603 | test_toggle_conf_name (); | ||
| 2569 | 4604 | test_override (); | ||
| 2570 | 3312 | test_file_destroy (); | 4605 | test_file_destroy (); |
| 2571 | 3313 | test_select_job (); | 4606 | test_select_job (); |
| 2572 | 3314 | 4607 | ||
| 2573 | 3315 | 4608 | ||
| 2574 | === modified file 'init/tests/test_parse_job.c' | |||
| 2575 | --- init/tests/test_parse_job.c 2010-12-14 16:20:38 +0000 | |||
| 2576 | +++ init/tests/test_parse_job.c 2011-01-21 11:55:09 +0000 | |||
| 2577 | @@ -64,7 +64,7 @@ | |||
| 2578 | 64 | TEST_ALLOC_FAIL { | 64 | TEST_ALLOC_FAIL { |
| 2579 | 65 | pos = 0; | 65 | pos = 0; |
| 2580 | 66 | lineno = 1; | 66 | lineno = 1; |
| 2582 | 67 | job = parse_job (NULL, "test", buf, strlen (buf), | 67 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2583 | 68 | &pos, &lineno); | 68 | &pos, &lineno); |
| 2584 | 69 | 69 | ||
| 2585 | 70 | if (test_alloc_failed) { | 70 | if (test_alloc_failed) { |
| 2586 | @@ -110,7 +110,7 @@ | |||
| 2587 | 110 | TEST_ALLOC_FAIL { | 110 | TEST_ALLOC_FAIL { |
| 2588 | 111 | pos = 0; | 111 | pos = 0; |
| 2589 | 112 | lineno = 1; | 112 | lineno = 1; |
| 2591 | 113 | job = parse_job (NULL, "test", buf, strlen (buf), | 113 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2592 | 114 | &pos, &lineno); | 114 | &pos, &lineno); |
| 2593 | 115 | 115 | ||
| 2594 | 116 | if (test_alloc_failed) { | 116 | if (test_alloc_failed) { |
| 2595 | @@ -131,6 +131,45 @@ | |||
| 2596 | 131 | 131 | ||
| 2597 | 132 | nih_free (job); | 132 | nih_free (job); |
| 2598 | 133 | } | 133 | } |
| 2599 | 134 | |||
| 2600 | 135 | TEST_FEATURE ("with non-NULL update parameter (override)"); | ||
| 2601 | 136 | { | ||
| 2602 | 137 | JobClass *tmp = NULL; | ||
| 2603 | 138 | |||
| 2604 | 139 | strcpy (buf, "start on starting\n"); | ||
| 2605 | 140 | strcat (buf, "author \"me\"\n"); | ||
| 2606 | 141 | |||
| 2607 | 142 | pos = 0; | ||
| 2608 | 143 | lineno = 1; | ||
| 2609 | 144 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), | ||
| 2610 | 145 | &pos, &lineno); | ||
| 2611 | 146 | |||
| 2612 | 147 | TEST_NE_P (job, NULL); | ||
| 2613 | 148 | TEST_EQ_STR (job->author, "me"); | ||
| 2614 | 149 | TEST_NE_P (job->start_on, NULL); | ||
| 2615 | 150 | |||
| 2616 | 151 | strcat (buf, "author \"you\"\n"); | ||
| 2617 | 152 | strcat (buf, "manual\n"); | ||
| 2618 | 153 | strcat (buf, "description \"my description\"\n"); | ||
| 2619 | 154 | |||
| 2620 | 155 | pos = 0; | ||
| 2621 | 156 | lineno = 1; | ||
| 2622 | 157 | tmp = parse_job (NULL, job, "test", buf, strlen (buf), | ||
| 2623 | 158 | &pos, &lineno); | ||
| 2624 | 159 | TEST_NE_P (tmp, NULL); | ||
| 2625 | 160 | |||
| 2626 | 161 | /* if passed a job, the same object should be returned. | ||
| 2627 | 162 | */ | ||
| 2628 | 163 | TEST_EQ_P (tmp, job); | ||
| 2629 | 164 | |||
| 2630 | 165 | TEST_EQ_STR (tmp->author, "you"); | ||
| 2631 | 166 | TEST_EQ_P (tmp->start_on, NULL); | ||
| 2632 | 167 | TEST_NE_P (tmp->description, NULL); | ||
| 2633 | 168 | |||
| 2634 | 169 | TEST_EQ_STR (tmp->description, "my description"); | ||
| 2635 | 170 | |||
| 2636 | 171 | nih_free (job); | ||
| 2637 | 172 | } | ||
| 2638 | 134 | } | 173 | } |
| 2639 | 135 | 174 | ||
| 2640 | 136 | void | 175 | void |
| 2641 | @@ -153,7 +192,7 @@ | |||
| 2642 | 153 | TEST_ALLOC_FAIL { | 192 | TEST_ALLOC_FAIL { |
| 2643 | 154 | pos = 0; | 193 | pos = 0; |
| 2644 | 155 | lineno = 1; | 194 | lineno = 1; |
| 2646 | 156 | job = parse_job (NULL, "test", buf, strlen (buf), | 195 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2647 | 157 | &pos, &lineno); | 196 | &pos, &lineno); |
| 2648 | 158 | 197 | ||
| 2649 | 159 | if (test_alloc_failed) { | 198 | if (test_alloc_failed) { |
| 2650 | @@ -190,7 +229,7 @@ | |||
| 2651 | 190 | TEST_ALLOC_FAIL { | 229 | TEST_ALLOC_FAIL { |
| 2652 | 191 | pos = 0; | 230 | pos = 0; |
| 2653 | 192 | lineno = 1; | 231 | lineno = 1; |
| 2655 | 193 | job = parse_job (NULL, "test", buf, strlen (buf), | 232 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2656 | 194 | &pos, &lineno); | 233 | &pos, &lineno); |
| 2657 | 195 | 234 | ||
| 2658 | 196 | if (test_alloc_failed) { | 235 | if (test_alloc_failed) { |
| 2659 | @@ -229,7 +268,7 @@ | |||
| 2660 | 229 | TEST_ALLOC_FAIL { | 268 | TEST_ALLOC_FAIL { |
| 2661 | 230 | pos = 0; | 269 | pos = 0; |
| 2662 | 231 | lineno = 1; | 270 | lineno = 1; |
| 2664 | 232 | job = parse_job (NULL, "test", buf, strlen (buf), | 271 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2665 | 233 | &pos, &lineno); | 272 | &pos, &lineno); |
| 2666 | 234 | 273 | ||
| 2667 | 235 | if (test_alloc_failed) { | 274 | if (test_alloc_failed) { |
| 2668 | @@ -266,7 +305,7 @@ | |||
| 2669 | 266 | 305 | ||
| 2670 | 267 | pos = 0; | 306 | pos = 0; |
| 2671 | 268 | lineno = 1; | 307 | lineno = 1; |
| 2673 | 269 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 308 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2674 | 270 | 309 | ||
| 2675 | 271 | TEST_EQ_P (job, NULL); | 310 | TEST_EQ_P (job, NULL); |
| 2676 | 272 | 311 | ||
| 2677 | @@ -299,7 +338,7 @@ | |||
| 2678 | 299 | TEST_ALLOC_FAIL { | 338 | TEST_ALLOC_FAIL { |
| 2679 | 300 | pos = 0; | 339 | pos = 0; |
| 2680 | 301 | lineno = 1; | 340 | lineno = 1; |
| 2682 | 302 | job = parse_job (NULL, "test", buf, strlen (buf), | 341 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2683 | 303 | &pos, &lineno); | 342 | &pos, &lineno); |
| 2684 | 304 | 343 | ||
| 2685 | 305 | if (test_alloc_failed) { | 344 | if (test_alloc_failed) { |
| 2686 | @@ -340,7 +379,7 @@ | |||
| 2687 | 340 | TEST_ALLOC_FAIL { | 379 | TEST_ALLOC_FAIL { |
| 2688 | 341 | pos = 0; | 380 | pos = 0; |
| 2689 | 342 | lineno = 1; | 381 | lineno = 1; |
| 2691 | 343 | job = parse_job (NULL, "test", buf, strlen (buf), | 382 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2692 | 344 | &pos, &lineno); | 383 | &pos, &lineno); |
| 2693 | 345 | 384 | ||
| 2694 | 346 | if (test_alloc_failed) { | 385 | if (test_alloc_failed) { |
| 2695 | @@ -379,7 +418,7 @@ | |||
| 2696 | 379 | TEST_ALLOC_FAIL { | 418 | TEST_ALLOC_FAIL { |
| 2697 | 380 | pos = 0; | 419 | pos = 0; |
| 2698 | 381 | lineno = 1; | 420 | lineno = 1; |
| 2700 | 382 | job = parse_job (NULL, "test", buf, strlen (buf), | 421 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2701 | 383 | &pos, &lineno); | 422 | &pos, &lineno); |
| 2702 | 384 | 423 | ||
| 2703 | 385 | if (test_alloc_failed) { | 424 | if (test_alloc_failed) { |
| 2704 | @@ -416,7 +455,7 @@ | |||
| 2705 | 416 | 455 | ||
| 2706 | 417 | pos = 0; | 456 | pos = 0; |
| 2707 | 418 | lineno = 1; | 457 | lineno = 1; |
| 2709 | 419 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 458 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2710 | 420 | 459 | ||
| 2711 | 421 | TEST_EQ_P (job, NULL); | 460 | TEST_EQ_P (job, NULL); |
| 2712 | 422 | 461 | ||
| 2713 | @@ -447,7 +486,7 @@ | |||
| 2714 | 447 | TEST_ALLOC_FAIL { | 486 | TEST_ALLOC_FAIL { |
| 2715 | 448 | pos = 0; | 487 | pos = 0; |
| 2716 | 449 | lineno = 1; | 488 | lineno = 1; |
| 2718 | 450 | job = parse_job (NULL, "test", buf, strlen (buf), | 489 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2719 | 451 | &pos, &lineno); | 490 | &pos, &lineno); |
| 2720 | 452 | 491 | ||
| 2721 | 453 | if (test_alloc_failed) { | 492 | if (test_alloc_failed) { |
| 2722 | @@ -484,7 +523,7 @@ | |||
| 2723 | 484 | TEST_ALLOC_FAIL { | 523 | TEST_ALLOC_FAIL { |
| 2724 | 485 | pos = 0; | 524 | pos = 0; |
| 2725 | 486 | lineno = 1; | 525 | lineno = 1; |
| 2727 | 487 | job = parse_job (NULL, "test", buf, strlen (buf), | 526 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2728 | 488 | &pos, &lineno); | 527 | &pos, &lineno); |
| 2729 | 489 | 528 | ||
| 2730 | 490 | if (test_alloc_failed) { | 529 | if (test_alloc_failed) { |
| 2731 | @@ -524,7 +563,7 @@ | |||
| 2732 | 524 | TEST_ALLOC_FAIL { | 563 | TEST_ALLOC_FAIL { |
| 2733 | 525 | pos = 0; | 564 | pos = 0; |
| 2734 | 526 | lineno = 1; | 565 | lineno = 1; |
| 2736 | 527 | job = parse_job (NULL, "test", buf, strlen (buf), | 566 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2737 | 528 | &pos, &lineno); | 567 | &pos, &lineno); |
| 2738 | 529 | 568 | ||
| 2739 | 530 | if (test_alloc_failed) { | 569 | if (test_alloc_failed) { |
| 2740 | @@ -565,7 +604,7 @@ | |||
| 2741 | 565 | TEST_ALLOC_FAIL { | 604 | TEST_ALLOC_FAIL { |
| 2742 | 566 | pos = 0; | 605 | pos = 0; |
| 2743 | 567 | lineno = 1; | 606 | lineno = 1; |
| 2745 | 568 | job = parse_job (NULL, "test", buf, strlen (buf), | 607 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2746 | 569 | &pos, &lineno); | 608 | &pos, &lineno); |
| 2747 | 570 | 609 | ||
| 2748 | 571 | if (test_alloc_failed) { | 610 | if (test_alloc_failed) { |
| 2749 | @@ -604,7 +643,7 @@ | |||
| 2750 | 604 | TEST_ALLOC_FAIL { | 643 | TEST_ALLOC_FAIL { |
| 2751 | 605 | pos = 0; | 644 | pos = 0; |
| 2752 | 606 | lineno = 1; | 645 | lineno = 1; |
| 2754 | 607 | job = parse_job (NULL, "test", buf, strlen (buf), | 646 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2755 | 608 | &pos, &lineno); | 647 | &pos, &lineno); |
| 2756 | 609 | 648 | ||
| 2757 | 610 | if (test_alloc_failed) { | 649 | if (test_alloc_failed) { |
| 2758 | @@ -643,7 +682,7 @@ | |||
| 2759 | 643 | TEST_ALLOC_FAIL { | 682 | TEST_ALLOC_FAIL { |
| 2760 | 644 | pos = 0; | 683 | pos = 0; |
| 2761 | 645 | lineno = 1; | 684 | lineno = 1; |
| 2763 | 646 | job = parse_job (NULL, "test", buf, strlen (buf), | 685 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2764 | 647 | &pos, &lineno); | 686 | &pos, &lineno); |
| 2765 | 648 | 687 | ||
| 2766 | 649 | if (test_alloc_failed) { | 688 | if (test_alloc_failed) { |
| 2767 | @@ -680,7 +719,7 @@ | |||
| 2768 | 680 | 719 | ||
| 2769 | 681 | pos = 0; | 720 | pos = 0; |
| 2770 | 682 | lineno = 1; | 721 | lineno = 1; |
| 2772 | 683 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 722 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2773 | 684 | 723 | ||
| 2774 | 685 | TEST_EQ_P (job, NULL); | 724 | TEST_EQ_P (job, NULL); |
| 2775 | 686 | 725 | ||
| 2776 | @@ -699,7 +738,7 @@ | |||
| 2777 | 699 | 738 | ||
| 2778 | 700 | pos = 0; | 739 | pos = 0; |
| 2779 | 701 | lineno = 1; | 740 | lineno = 1; |
| 2781 | 702 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 741 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2782 | 703 | 742 | ||
| 2783 | 704 | TEST_EQ_P (job, NULL); | 743 | TEST_EQ_P (job, NULL); |
| 2784 | 705 | 744 | ||
| 2785 | @@ -718,7 +757,7 @@ | |||
| 2786 | 718 | 757 | ||
| 2787 | 719 | pos = 0; | 758 | pos = 0; |
| 2788 | 720 | lineno = 1; | 759 | lineno = 1; |
| 2790 | 721 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 760 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2791 | 722 | 761 | ||
| 2792 | 723 | TEST_EQ_P (job, NULL); | 762 | TEST_EQ_P (job, NULL); |
| 2793 | 724 | 763 | ||
| 2794 | @@ -737,7 +776,7 @@ | |||
| 2795 | 737 | 776 | ||
| 2796 | 738 | pos = 0; | 777 | pos = 0; |
| 2797 | 739 | lineno = 1; | 778 | lineno = 1; |
| 2799 | 740 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 779 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2800 | 741 | 780 | ||
| 2801 | 742 | TEST_EQ_P (job, NULL); | 781 | TEST_EQ_P (job, NULL); |
| 2802 | 743 | 782 | ||
| 2803 | @@ -768,7 +807,7 @@ | |||
| 2804 | 768 | TEST_ALLOC_FAIL { | 807 | TEST_ALLOC_FAIL { |
| 2805 | 769 | pos = 0; | 808 | pos = 0; |
| 2806 | 770 | lineno = 1; | 809 | lineno = 1; |
| 2808 | 771 | job = parse_job (NULL, "test", buf, strlen (buf), | 810 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2809 | 772 | &pos, &lineno); | 811 | &pos, &lineno); |
| 2810 | 773 | 812 | ||
| 2811 | 774 | if (test_alloc_failed) { | 813 | if (test_alloc_failed) { |
| 2812 | @@ -805,7 +844,7 @@ | |||
| 2813 | 805 | TEST_ALLOC_FAIL { | 844 | TEST_ALLOC_FAIL { |
| 2814 | 806 | pos = 0; | 845 | pos = 0; |
| 2815 | 807 | lineno = 1; | 846 | lineno = 1; |
| 2817 | 808 | job = parse_job (NULL, "test", buf, strlen (buf), | 847 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2818 | 809 | &pos, &lineno); | 848 | &pos, &lineno); |
| 2819 | 810 | 849 | ||
| 2820 | 811 | if (test_alloc_failed) { | 850 | if (test_alloc_failed) { |
| 2821 | @@ -845,7 +884,7 @@ | |||
| 2822 | 845 | TEST_ALLOC_FAIL { | 884 | TEST_ALLOC_FAIL { |
| 2823 | 846 | pos = 0; | 885 | pos = 0; |
| 2824 | 847 | lineno = 1; | 886 | lineno = 1; |
| 2826 | 848 | job = parse_job (NULL, "test", buf, strlen (buf), | 887 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2827 | 849 | &pos, &lineno); | 888 | &pos, &lineno); |
| 2828 | 850 | 889 | ||
| 2829 | 851 | if (test_alloc_failed) { | 890 | if (test_alloc_failed) { |
| 2830 | @@ -886,7 +925,7 @@ | |||
| 2831 | 886 | TEST_ALLOC_FAIL { | 925 | TEST_ALLOC_FAIL { |
| 2832 | 887 | pos = 0; | 926 | pos = 0; |
| 2833 | 888 | lineno = 1; | 927 | lineno = 1; |
| 2835 | 889 | job = parse_job (NULL, "test", buf, strlen (buf), | 928 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2836 | 890 | &pos, &lineno); | 929 | &pos, &lineno); |
| 2837 | 891 | 930 | ||
| 2838 | 892 | if (test_alloc_failed) { | 931 | if (test_alloc_failed) { |
| 2839 | @@ -925,7 +964,7 @@ | |||
| 2840 | 925 | TEST_ALLOC_FAIL { | 964 | TEST_ALLOC_FAIL { |
| 2841 | 926 | pos = 0; | 965 | pos = 0; |
| 2842 | 927 | lineno = 1; | 966 | lineno = 1; |
| 2844 | 928 | job = parse_job (NULL, "test", buf, strlen (buf), | 967 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2845 | 929 | &pos, &lineno); | 968 | &pos, &lineno); |
| 2846 | 930 | 969 | ||
| 2847 | 931 | if (test_alloc_failed) { | 970 | if (test_alloc_failed) { |
| 2848 | @@ -964,7 +1003,7 @@ | |||
| 2849 | 964 | TEST_ALLOC_FAIL { | 1003 | TEST_ALLOC_FAIL { |
| 2850 | 965 | pos = 0; | 1004 | pos = 0; |
| 2851 | 966 | lineno = 1; | 1005 | lineno = 1; |
| 2853 | 967 | job = parse_job (NULL, "test", buf, strlen (buf), | 1006 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2854 | 968 | &pos, &lineno); | 1007 | &pos, &lineno); |
| 2855 | 969 | 1008 | ||
| 2856 | 970 | if (test_alloc_failed) { | 1009 | if (test_alloc_failed) { |
| 2857 | @@ -1001,7 +1040,7 @@ | |||
| 2858 | 1001 | 1040 | ||
| 2859 | 1002 | pos = 0; | 1041 | pos = 0; |
| 2860 | 1003 | lineno = 1; | 1042 | lineno = 1; |
| 2862 | 1004 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1043 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2863 | 1005 | 1044 | ||
| 2864 | 1006 | TEST_EQ_P (job, NULL); | 1045 | TEST_EQ_P (job, NULL); |
| 2865 | 1007 | 1046 | ||
| 2866 | @@ -1020,7 +1059,7 @@ | |||
| 2867 | 1020 | 1059 | ||
| 2868 | 1021 | pos = 0; | 1060 | pos = 0; |
| 2869 | 1022 | lineno = 1; | 1061 | lineno = 1; |
| 2871 | 1023 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1062 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2872 | 1024 | 1063 | ||
| 2873 | 1025 | TEST_EQ_P (job, NULL); | 1064 | TEST_EQ_P (job, NULL); |
| 2874 | 1026 | 1065 | ||
| 2875 | @@ -1039,7 +1078,7 @@ | |||
| 2876 | 1039 | 1078 | ||
| 2877 | 1040 | pos = 0; | 1079 | pos = 0; |
| 2878 | 1041 | lineno = 1; | 1080 | lineno = 1; |
| 2880 | 1042 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1081 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2881 | 1043 | 1082 | ||
| 2882 | 1044 | TEST_EQ_P (job, NULL); | 1083 | TEST_EQ_P (job, NULL); |
| 2883 | 1045 | 1084 | ||
| 2884 | @@ -1058,7 +1097,7 @@ | |||
| 2885 | 1058 | 1097 | ||
| 2886 | 1059 | pos = 0; | 1098 | pos = 0; |
| 2887 | 1060 | lineno = 1; | 1099 | lineno = 1; |
| 2889 | 1061 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1100 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2890 | 1062 | 1101 | ||
| 2891 | 1063 | TEST_EQ_P (job, NULL); | 1102 | TEST_EQ_P (job, NULL); |
| 2892 | 1064 | 1103 | ||
| 2893 | @@ -1089,7 +1128,7 @@ | |||
| 2894 | 1089 | TEST_ALLOC_FAIL { | 1128 | TEST_ALLOC_FAIL { |
| 2895 | 1090 | pos = 0; | 1129 | pos = 0; |
| 2896 | 1091 | lineno = 1; | 1130 | lineno = 1; |
| 2898 | 1092 | job = parse_job (NULL, "test", buf, strlen (buf), | 1131 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2899 | 1093 | &pos, &lineno); | 1132 | &pos, &lineno); |
| 2900 | 1094 | 1133 | ||
| 2901 | 1095 | if (test_alloc_failed) { | 1134 | if (test_alloc_failed) { |
| 2902 | @@ -1126,7 +1165,7 @@ | |||
| 2903 | 1126 | TEST_ALLOC_FAIL { | 1165 | TEST_ALLOC_FAIL { |
| 2904 | 1127 | pos = 0; | 1166 | pos = 0; |
| 2905 | 1128 | lineno = 1; | 1167 | lineno = 1; |
| 2907 | 1129 | job = parse_job (NULL, "test", buf, strlen (buf), | 1168 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2908 | 1130 | &pos, &lineno); | 1169 | &pos, &lineno); |
| 2909 | 1131 | 1170 | ||
| 2910 | 1132 | if (test_alloc_failed) { | 1171 | if (test_alloc_failed) { |
| 2911 | @@ -1166,7 +1205,7 @@ | |||
| 2912 | 1166 | TEST_ALLOC_FAIL { | 1205 | TEST_ALLOC_FAIL { |
| 2913 | 1167 | pos = 0; | 1206 | pos = 0; |
| 2914 | 1168 | lineno = 1; | 1207 | lineno = 1; |
| 2916 | 1169 | job = parse_job (NULL, "test", buf, strlen (buf), | 1208 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2917 | 1170 | &pos, &lineno); | 1209 | &pos, &lineno); |
| 2918 | 1171 | 1210 | ||
| 2919 | 1172 | if (test_alloc_failed) { | 1211 | if (test_alloc_failed) { |
| 2920 | @@ -1207,7 +1246,7 @@ | |||
| 2921 | 1207 | TEST_ALLOC_FAIL { | 1246 | TEST_ALLOC_FAIL { |
| 2922 | 1208 | pos = 0; | 1247 | pos = 0; |
| 2923 | 1209 | lineno = 1; | 1248 | lineno = 1; |
| 2925 | 1210 | job = parse_job (NULL, "test", buf, strlen (buf), | 1249 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2926 | 1211 | &pos, &lineno); | 1250 | &pos, &lineno); |
| 2927 | 1212 | 1251 | ||
| 2928 | 1213 | if (test_alloc_failed) { | 1252 | if (test_alloc_failed) { |
| 2929 | @@ -1246,7 +1285,7 @@ | |||
| 2930 | 1246 | TEST_ALLOC_FAIL { | 1285 | TEST_ALLOC_FAIL { |
| 2931 | 1247 | pos = 0; | 1286 | pos = 0; |
| 2932 | 1248 | lineno = 1; | 1287 | lineno = 1; |
| 2934 | 1249 | job = parse_job (NULL, "test", buf, strlen (buf), | 1288 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2935 | 1250 | &pos, &lineno); | 1289 | &pos, &lineno); |
| 2936 | 1251 | 1290 | ||
| 2937 | 1252 | if (test_alloc_failed) { | 1291 | if (test_alloc_failed) { |
| 2938 | @@ -1285,7 +1324,7 @@ | |||
| 2939 | 1285 | TEST_ALLOC_FAIL { | 1324 | TEST_ALLOC_FAIL { |
| 2940 | 1286 | pos = 0; | 1325 | pos = 0; |
| 2941 | 1287 | lineno = 1; | 1326 | lineno = 1; |
| 2943 | 1288 | job = parse_job (NULL, "test", buf, strlen (buf), | 1327 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2944 | 1289 | &pos, &lineno); | 1328 | &pos, &lineno); |
| 2945 | 1290 | 1329 | ||
| 2946 | 1291 | if (test_alloc_failed) { | 1330 | if (test_alloc_failed) { |
| 2947 | @@ -1322,7 +1361,7 @@ | |||
| 2948 | 1322 | 1361 | ||
| 2949 | 1323 | pos = 0; | 1362 | pos = 0; |
| 2950 | 1324 | lineno = 1; | 1363 | lineno = 1; |
| 2952 | 1325 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1364 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2953 | 1326 | 1365 | ||
| 2954 | 1327 | TEST_EQ_P (job, NULL); | 1366 | TEST_EQ_P (job, NULL); |
| 2955 | 1328 | 1367 | ||
| 2956 | @@ -1341,7 +1380,7 @@ | |||
| 2957 | 1341 | 1380 | ||
| 2958 | 1342 | pos = 0; | 1381 | pos = 0; |
| 2959 | 1343 | lineno = 1; | 1382 | lineno = 1; |
| 2961 | 1344 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1383 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2962 | 1345 | 1384 | ||
| 2963 | 1346 | TEST_EQ_P (job, NULL); | 1385 | TEST_EQ_P (job, NULL); |
| 2964 | 1347 | 1386 | ||
| 2965 | @@ -1360,7 +1399,7 @@ | |||
| 2966 | 1360 | 1399 | ||
| 2967 | 1361 | pos = 0; | 1400 | pos = 0; |
| 2968 | 1362 | lineno = 1; | 1401 | lineno = 1; |
| 2970 | 1363 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1402 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2971 | 1364 | 1403 | ||
| 2972 | 1365 | TEST_EQ_P (job, NULL); | 1404 | TEST_EQ_P (job, NULL); |
| 2973 | 1366 | 1405 | ||
| 2974 | @@ -1379,7 +1418,7 @@ | |||
| 2975 | 1379 | 1418 | ||
| 2976 | 1380 | pos = 0; | 1419 | pos = 0; |
| 2977 | 1381 | lineno = 1; | 1420 | lineno = 1; |
| 2979 | 1382 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1421 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 2980 | 1383 | 1422 | ||
| 2981 | 1384 | TEST_EQ_P (job, NULL); | 1423 | TEST_EQ_P (job, NULL); |
| 2982 | 1385 | 1424 | ||
| 2983 | @@ -1410,7 +1449,7 @@ | |||
| 2984 | 1410 | TEST_ALLOC_FAIL { | 1449 | TEST_ALLOC_FAIL { |
| 2985 | 1411 | pos = 0; | 1450 | pos = 0; |
| 2986 | 1412 | lineno = 1; | 1451 | lineno = 1; |
| 2988 | 1413 | job = parse_job (NULL, "test", buf, strlen (buf), | 1452 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2989 | 1414 | &pos, &lineno); | 1453 | &pos, &lineno); |
| 2990 | 1415 | 1454 | ||
| 2991 | 1416 | if (test_alloc_failed) { | 1455 | if (test_alloc_failed) { |
| 2992 | @@ -1447,7 +1486,7 @@ | |||
| 2993 | 1447 | TEST_ALLOC_FAIL { | 1486 | TEST_ALLOC_FAIL { |
| 2994 | 1448 | pos = 0; | 1487 | pos = 0; |
| 2995 | 1449 | lineno = 1; | 1488 | lineno = 1; |
| 2997 | 1450 | job = parse_job (NULL, "test", buf, strlen (buf), | 1489 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 2998 | 1451 | &pos, &lineno); | 1490 | &pos, &lineno); |
| 2999 | 1452 | 1491 | ||
| 3000 | 1453 | if (test_alloc_failed) { | 1492 | if (test_alloc_failed) { |
| 3001 | @@ -1487,7 +1526,7 @@ | |||
| 3002 | 1487 | TEST_ALLOC_FAIL { | 1526 | TEST_ALLOC_FAIL { |
| 3003 | 1488 | pos = 0; | 1527 | pos = 0; |
| 3004 | 1489 | lineno = 1; | 1528 | lineno = 1; |
| 3006 | 1490 | job = parse_job (NULL, "test", buf, strlen (buf), | 1529 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3007 | 1491 | &pos, &lineno); | 1530 | &pos, &lineno); |
| 3008 | 1492 | 1531 | ||
| 3009 | 1493 | if (test_alloc_failed) { | 1532 | if (test_alloc_failed) { |
| 3010 | @@ -1528,7 +1567,7 @@ | |||
| 3011 | 1528 | TEST_ALLOC_FAIL { | 1567 | TEST_ALLOC_FAIL { |
| 3012 | 1529 | pos = 0; | 1568 | pos = 0; |
| 3013 | 1530 | lineno = 1; | 1569 | lineno = 1; |
| 3015 | 1531 | job = parse_job (NULL, "test", buf, strlen (buf), | 1570 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3016 | 1532 | &pos, &lineno); | 1571 | &pos, &lineno); |
| 3017 | 1533 | 1572 | ||
| 3018 | 1534 | if (test_alloc_failed) { | 1573 | if (test_alloc_failed) { |
| 3019 | @@ -1567,7 +1606,7 @@ | |||
| 3020 | 1567 | TEST_ALLOC_FAIL { | 1606 | TEST_ALLOC_FAIL { |
| 3021 | 1568 | pos = 0; | 1607 | pos = 0; |
| 3022 | 1569 | lineno = 1; | 1608 | lineno = 1; |
| 3024 | 1570 | job = parse_job (NULL, "test", buf, strlen (buf), | 1609 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3025 | 1571 | &pos, &lineno); | 1610 | &pos, &lineno); |
| 3026 | 1572 | 1611 | ||
| 3027 | 1573 | if (test_alloc_failed) { | 1612 | if (test_alloc_failed) { |
| 3028 | @@ -1606,7 +1645,7 @@ | |||
| 3029 | 1606 | TEST_ALLOC_FAIL { | 1645 | TEST_ALLOC_FAIL { |
| 3030 | 1607 | pos = 0; | 1646 | pos = 0; |
| 3031 | 1608 | lineno = 1; | 1647 | lineno = 1; |
| 3033 | 1609 | job = parse_job (NULL, "test", buf, strlen (buf), | 1648 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3034 | 1610 | &pos, &lineno); | 1649 | &pos, &lineno); |
| 3035 | 1611 | 1650 | ||
| 3036 | 1612 | if (test_alloc_failed) { | 1651 | if (test_alloc_failed) { |
| 3037 | @@ -1643,7 +1682,7 @@ | |||
| 3038 | 1643 | 1682 | ||
| 3039 | 1644 | pos = 0; | 1683 | pos = 0; |
| 3040 | 1645 | lineno = 1; | 1684 | lineno = 1; |
| 3042 | 1646 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1685 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3043 | 1647 | 1686 | ||
| 3044 | 1648 | TEST_EQ_P (job, NULL); | 1687 | TEST_EQ_P (job, NULL); |
| 3045 | 1649 | 1688 | ||
| 3046 | @@ -1662,7 +1701,7 @@ | |||
| 3047 | 1662 | 1701 | ||
| 3048 | 1663 | pos = 0; | 1702 | pos = 0; |
| 3049 | 1664 | lineno = 1; | 1703 | lineno = 1; |
| 3051 | 1665 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1704 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3052 | 1666 | 1705 | ||
| 3053 | 1667 | TEST_EQ_P (job, NULL); | 1706 | TEST_EQ_P (job, NULL); |
| 3054 | 1668 | 1707 | ||
| 3055 | @@ -1681,7 +1720,7 @@ | |||
| 3056 | 1681 | 1720 | ||
| 3057 | 1682 | pos = 0; | 1721 | pos = 0; |
| 3058 | 1683 | lineno = 1; | 1722 | lineno = 1; |
| 3060 | 1684 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1723 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3061 | 1685 | 1724 | ||
| 3062 | 1686 | TEST_EQ_P (job, NULL); | 1725 | TEST_EQ_P (job, NULL); |
| 3063 | 1687 | 1726 | ||
| 3064 | @@ -1700,7 +1739,7 @@ | |||
| 3065 | 1700 | 1739 | ||
| 3066 | 1701 | pos = 0; | 1740 | pos = 0; |
| 3067 | 1702 | lineno = 1; | 1741 | lineno = 1; |
| 3069 | 1703 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 1742 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3070 | 1704 | 1743 | ||
| 3071 | 1705 | TEST_EQ_P (job, NULL); | 1744 | TEST_EQ_P (job, NULL); |
| 3072 | 1706 | 1745 | ||
| 3073 | @@ -1731,7 +1770,7 @@ | |||
| 3074 | 1731 | TEST_ALLOC_FAIL { | 1770 | TEST_ALLOC_FAIL { |
| 3075 | 1732 | pos = 0; | 1771 | pos = 0; |
| 3076 | 1733 | lineno = 1; | 1772 | lineno = 1; |
| 3078 | 1734 | job = parse_job (NULL, "test", buf, strlen (buf), | 1773 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3079 | 1735 | &pos, &lineno); | 1774 | &pos, &lineno); |
| 3080 | 1736 | 1775 | ||
| 3081 | 1737 | if (test_alloc_failed) { | 1776 | if (test_alloc_failed) { |
| 3082 | @@ -1776,7 +1815,7 @@ | |||
| 3083 | 1776 | TEST_ALLOC_FAIL { | 1815 | TEST_ALLOC_FAIL { |
| 3084 | 1777 | pos = 0; | 1816 | pos = 0; |
| 3085 | 1778 | lineno = 1; | 1817 | lineno = 1; |
| 3087 | 1779 | job = parse_job (NULL, "test", buf, strlen (buf), | 1818 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3088 | 1780 | &pos, &lineno); | 1819 | &pos, &lineno); |
| 3089 | 1781 | 1820 | ||
| 3090 | 1782 | if (test_alloc_failed) { | 1821 | if (test_alloc_failed) { |
| 3091 | @@ -1828,7 +1867,7 @@ | |||
| 3092 | 1828 | TEST_ALLOC_FAIL { | 1867 | TEST_ALLOC_FAIL { |
| 3093 | 1829 | pos = 0; | 1868 | pos = 0; |
| 3094 | 1830 | lineno = 1; | 1869 | lineno = 1; |
| 3096 | 1831 | job = parse_job (NULL, "test", buf, strlen (buf), | 1870 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3097 | 1832 | &pos, &lineno); | 1871 | &pos, &lineno); |
| 3098 | 1833 | 1872 | ||
| 3099 | 1834 | if (test_alloc_failed) { | 1873 | if (test_alloc_failed) { |
| 3100 | @@ -1879,7 +1918,7 @@ | |||
| 3101 | 1879 | TEST_ALLOC_FAIL { | 1918 | TEST_ALLOC_FAIL { |
| 3102 | 1880 | pos = 0; | 1919 | pos = 0; |
| 3103 | 1881 | lineno = 1; | 1920 | lineno = 1; |
| 3105 | 1882 | job = parse_job (NULL, "test", buf, strlen (buf), | 1921 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3106 | 1883 | &pos, &lineno); | 1922 | &pos, &lineno); |
| 3107 | 1884 | 1923 | ||
| 3108 | 1885 | if (test_alloc_failed) { | 1924 | if (test_alloc_failed) { |
| 3109 | @@ -1942,7 +1981,7 @@ | |||
| 3110 | 1942 | TEST_ALLOC_FAIL { | 1981 | TEST_ALLOC_FAIL { |
| 3111 | 1943 | pos = 0; | 1982 | pos = 0; |
| 3112 | 1944 | lineno = 1; | 1983 | lineno = 1; |
| 3114 | 1945 | job = parse_job (NULL, "test", buf, strlen (buf), | 1984 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3115 | 1946 | &pos, &lineno); | 1985 | &pos, &lineno); |
| 3116 | 1947 | 1986 | ||
| 3117 | 1948 | if (test_alloc_failed) { | 1987 | if (test_alloc_failed) { |
| 3118 | @@ -2012,7 +2051,7 @@ | |||
| 3119 | 2012 | TEST_ALLOC_FAIL { | 2051 | TEST_ALLOC_FAIL { |
| 3120 | 2013 | pos = 0; | 2052 | pos = 0; |
| 3121 | 2014 | lineno = 1; | 2053 | lineno = 1; |
| 3123 | 2015 | job = parse_job (NULL, "test", buf, strlen (buf), | 2054 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3124 | 2016 | &pos, &lineno); | 2055 | &pos, &lineno); |
| 3125 | 2017 | 2056 | ||
| 3126 | 2018 | if (test_alloc_failed) { | 2057 | if (test_alloc_failed) { |
| 3127 | @@ -2090,7 +2129,7 @@ | |||
| 3128 | 2090 | TEST_ALLOC_FAIL { | 2129 | TEST_ALLOC_FAIL { |
| 3129 | 2091 | pos = 0; | 2130 | pos = 0; |
| 3130 | 2092 | lineno = 1; | 2131 | lineno = 1; |
| 3132 | 2093 | job = parse_job (NULL, "test", buf, strlen (buf), | 2132 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3133 | 2094 | &pos, &lineno); | 2133 | &pos, &lineno); |
| 3134 | 2095 | 2134 | ||
| 3135 | 2096 | if (test_alloc_failed) { | 2135 | if (test_alloc_failed) { |
| 3136 | @@ -2170,7 +2209,7 @@ | |||
| 3137 | 2170 | TEST_ALLOC_FAIL { | 2209 | TEST_ALLOC_FAIL { |
| 3138 | 2171 | pos = 0; | 2210 | pos = 0; |
| 3139 | 2172 | lineno = 1; | 2211 | lineno = 1; |
| 3141 | 2173 | job = parse_job (NULL, "test", buf, strlen (buf), | 2212 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3142 | 2174 | &pos, &lineno); | 2213 | &pos, &lineno); |
| 3143 | 2175 | 2214 | ||
| 3144 | 2176 | if (test_alloc_failed) { | 2215 | if (test_alloc_failed) { |
| 3145 | @@ -2249,7 +2288,7 @@ | |||
| 3146 | 2249 | TEST_ALLOC_FAIL { | 2288 | TEST_ALLOC_FAIL { |
| 3147 | 2250 | pos = 0; | 2289 | pos = 0; |
| 3148 | 2251 | lineno = 1; | 2290 | lineno = 1; |
| 3150 | 2252 | job = parse_job (NULL, "test", buf, strlen (buf), | 2291 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3151 | 2253 | &pos, &lineno); | 2292 | &pos, &lineno); |
| 3152 | 2254 | 2293 | ||
| 3153 | 2255 | if (test_alloc_failed) { | 2294 | if (test_alloc_failed) { |
| 3154 | @@ -2291,7 +2330,7 @@ | |||
| 3155 | 2291 | 2330 | ||
| 3156 | 2292 | pos = 0; | 2331 | pos = 0; |
| 3157 | 2293 | lineno = 1; | 2332 | lineno = 1; |
| 3159 | 2294 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2333 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3160 | 2295 | 2334 | ||
| 3161 | 2296 | TEST_EQ_P (job, NULL); | 2335 | TEST_EQ_P (job, NULL); |
| 3162 | 2297 | 2336 | ||
| 3163 | @@ -2310,7 +2349,7 @@ | |||
| 3164 | 2310 | 2349 | ||
| 3165 | 2311 | pos = 0; | 2350 | pos = 0; |
| 3166 | 2312 | lineno = 1; | 2351 | lineno = 1; |
| 3168 | 2313 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2352 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3169 | 2314 | 2353 | ||
| 3170 | 2315 | TEST_EQ_P (job, NULL); | 2354 | TEST_EQ_P (job, NULL); |
| 3171 | 2316 | 2355 | ||
| 3172 | @@ -2329,7 +2368,7 @@ | |||
| 3173 | 2329 | 2368 | ||
| 3174 | 2330 | pos = 0; | 2369 | pos = 0; |
| 3175 | 2331 | lineno = 1; | 2370 | lineno = 1; |
| 3177 | 2332 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2371 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3178 | 2333 | 2372 | ||
| 3179 | 2334 | TEST_EQ_P (job, NULL); | 2373 | TEST_EQ_P (job, NULL); |
| 3180 | 2335 | 2374 | ||
| 3181 | @@ -2348,7 +2387,7 @@ | |||
| 3182 | 2348 | 2387 | ||
| 3183 | 2349 | pos = 0; | 2388 | pos = 0; |
| 3184 | 2350 | lineno = 1; | 2389 | lineno = 1; |
| 3186 | 2351 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2390 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3187 | 2352 | 2391 | ||
| 3188 | 2353 | TEST_EQ_P (job, NULL); | 2392 | TEST_EQ_P (job, NULL); |
| 3189 | 2354 | 2393 | ||
| 3190 | @@ -2367,7 +2406,7 @@ | |||
| 3191 | 2367 | 2406 | ||
| 3192 | 2368 | pos = 0; | 2407 | pos = 0; |
| 3193 | 2369 | lineno = 1; | 2408 | lineno = 1; |
| 3195 | 2370 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2409 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3196 | 2371 | 2410 | ||
| 3197 | 2372 | TEST_EQ_P (job, NULL); | 2411 | TEST_EQ_P (job, NULL); |
| 3198 | 2373 | 2412 | ||
| 3199 | @@ -2384,7 +2423,7 @@ | |||
| 3200 | 2384 | 2423 | ||
| 3201 | 2385 | pos = 0; | 2424 | pos = 0; |
| 3202 | 2386 | lineno = 1; | 2425 | lineno = 1; |
| 3204 | 2387 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2426 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3205 | 2388 | 2427 | ||
| 3206 | 2389 | TEST_EQ_P (job, NULL); | 2428 | TEST_EQ_P (job, NULL); |
| 3207 | 2390 | 2429 | ||
| 3208 | @@ -2403,7 +2442,7 @@ | |||
| 3209 | 2403 | 2442 | ||
| 3210 | 2404 | pos = 0; | 2443 | pos = 0; |
| 3211 | 2405 | lineno = 1; | 2444 | lineno = 1; |
| 3213 | 2406 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2445 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3214 | 2407 | 2446 | ||
| 3215 | 2408 | TEST_EQ_P (job, NULL); | 2447 | TEST_EQ_P (job, NULL); |
| 3216 | 2409 | 2448 | ||
| 3217 | @@ -2422,7 +2461,7 @@ | |||
| 3218 | 2422 | 2461 | ||
| 3219 | 2423 | pos = 0; | 2462 | pos = 0; |
| 3220 | 2424 | lineno = 1; | 2463 | lineno = 1; |
| 3222 | 2425 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2464 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3223 | 2426 | 2465 | ||
| 3224 | 2427 | TEST_EQ_P (job, NULL); | 2466 | TEST_EQ_P (job, NULL); |
| 3225 | 2428 | 2467 | ||
| 3226 | @@ -2441,7 +2480,7 @@ | |||
| 3227 | 2441 | 2480 | ||
| 3228 | 2442 | pos = 0; | 2481 | pos = 0; |
| 3229 | 2443 | lineno = 1; | 2482 | lineno = 1; |
| 3231 | 2444 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2483 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3232 | 2445 | 2484 | ||
| 3233 | 2446 | TEST_EQ_P (job, NULL); | 2485 | TEST_EQ_P (job, NULL); |
| 3234 | 2447 | 2486 | ||
| 3235 | @@ -2460,7 +2499,7 @@ | |||
| 3236 | 2460 | 2499 | ||
| 3237 | 2461 | pos = 0; | 2500 | pos = 0; |
| 3238 | 2462 | lineno = 1; | 2501 | lineno = 1; |
| 3240 | 2463 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2502 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3241 | 2464 | 2503 | ||
| 3242 | 2465 | TEST_EQ_P (job, NULL); | 2504 | TEST_EQ_P (job, NULL); |
| 3243 | 2466 | 2505 | ||
| 3244 | @@ -2479,7 +2518,7 @@ | |||
| 3245 | 2479 | 2518 | ||
| 3246 | 2480 | pos = 0; | 2519 | pos = 0; |
| 3247 | 2481 | lineno = 1; | 2520 | lineno = 1; |
| 3249 | 2482 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2521 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3250 | 2483 | 2522 | ||
| 3251 | 2484 | TEST_EQ_P (job, NULL); | 2523 | TEST_EQ_P (job, NULL); |
| 3252 | 2485 | 2524 | ||
| 3253 | @@ -2498,7 +2537,7 @@ | |||
| 3254 | 2498 | 2537 | ||
| 3255 | 2499 | pos = 0; | 2538 | pos = 0; |
| 3256 | 2500 | lineno = 1; | 2539 | lineno = 1; |
| 3258 | 2501 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2540 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3259 | 2502 | 2541 | ||
| 3260 | 2503 | TEST_EQ_P (job, NULL); | 2542 | TEST_EQ_P (job, NULL); |
| 3261 | 2504 | 2543 | ||
| 3262 | @@ -2517,7 +2556,7 @@ | |||
| 3263 | 2517 | 2556 | ||
| 3264 | 2518 | pos = 0; | 2557 | pos = 0; |
| 3265 | 2519 | lineno = 1; | 2558 | lineno = 1; |
| 3267 | 2520 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 2559 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3268 | 2521 | 2560 | ||
| 3269 | 2522 | TEST_EQ_P (job, NULL); | 2561 | TEST_EQ_P (job, NULL); |
| 3270 | 2523 | 2562 | ||
| 3271 | @@ -2551,7 +2590,7 @@ | |||
| 3272 | 2551 | TEST_ALLOC_FAIL { | 2590 | TEST_ALLOC_FAIL { |
| 3273 | 2552 | pos = 0; | 2591 | pos = 0; |
| 3274 | 2553 | lineno = 1; | 2592 | lineno = 1; |
| 3276 | 2554 | job = parse_job (NULL, "test", buf, strlen (buf), | 2593 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3277 | 2555 | &pos, &lineno); | 2594 | &pos, &lineno); |
| 3278 | 2556 | 2595 | ||
| 3279 | 2557 | if (test_alloc_failed) { | 2596 | if (test_alloc_failed) { |
| 3280 | @@ -2586,7 +2625,7 @@ | |||
| 3281 | 2586 | TEST_FEATURE ("manual stanza after start on"); | 2625 | TEST_FEATURE ("manual stanza after start on"); |
| 3282 | 2587 | strcpy (buf, "start on wibble\nmanual\n"); | 2626 | strcpy (buf, "start on wibble\nmanual\n"); |
| 3283 | 2588 | 2627 | ||
| 3285 | 2589 | job = parse_job (NULL, "test", buf, strlen (buf), | 2628 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3286 | 2590 | &pos, &lineno); | 2629 | &pos, &lineno); |
| 3287 | 2591 | 2630 | ||
| 3288 | 2592 | TEST_NE_P (job, NULL); | 2631 | TEST_NE_P (job, NULL); |
| 3289 | @@ -2616,7 +2655,7 @@ | |||
| 3290 | 2616 | TEST_ALLOC_FAIL { | 2655 | TEST_ALLOC_FAIL { |
| 3291 | 2617 | pos = 0; | 2656 | pos = 0; |
| 3292 | 2618 | lineno = 1; | 2657 | lineno = 1; |
| 3294 | 2619 | job = parse_job (NULL, "test", buf, strlen (buf), | 2658 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3295 | 2620 | &pos, &lineno); | 2659 | &pos, &lineno); |
| 3296 | 2621 | 2660 | ||
| 3297 | 2622 | if (test_alloc_failed) { | 2661 | if (test_alloc_failed) { |
| 3298 | @@ -2661,7 +2700,7 @@ | |||
| 3299 | 2661 | TEST_ALLOC_FAIL { | 2700 | TEST_ALLOC_FAIL { |
| 3300 | 2662 | pos = 0; | 2701 | pos = 0; |
| 3301 | 2663 | lineno = 1; | 2702 | lineno = 1; |
| 3303 | 2664 | job = parse_job (NULL, "test", buf, strlen (buf), | 2703 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3304 | 2665 | &pos, &lineno); | 2704 | &pos, &lineno); |
| 3305 | 2666 | 2705 | ||
| 3306 | 2667 | if (test_alloc_failed) { | 2706 | if (test_alloc_failed) { |
| 3307 | @@ -2713,7 +2752,7 @@ | |||
| 3308 | 2713 | TEST_ALLOC_FAIL { | 2752 | TEST_ALLOC_FAIL { |
| 3309 | 2714 | pos = 0; | 2753 | pos = 0; |
| 3310 | 2715 | lineno = 1; | 2754 | lineno = 1; |
| 3312 | 2716 | job = parse_job (NULL, "test", buf, strlen (buf), | 2755 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3313 | 2717 | &pos, &lineno); | 2756 | &pos, &lineno); |
| 3314 | 2718 | 2757 | ||
| 3315 | 2719 | if (test_alloc_failed) { | 2758 | if (test_alloc_failed) { |
| 3316 | @@ -2764,7 +2803,7 @@ | |||
| 3317 | 2764 | TEST_ALLOC_FAIL { | 2803 | TEST_ALLOC_FAIL { |
| 3318 | 2765 | pos = 0; | 2804 | pos = 0; |
| 3319 | 2766 | lineno = 1; | 2805 | lineno = 1; |
| 3321 | 2767 | job = parse_job (NULL, "test", buf, strlen (buf), | 2806 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3322 | 2768 | &pos, &lineno); | 2807 | &pos, &lineno); |
| 3323 | 2769 | 2808 | ||
| 3324 | 2770 | if (test_alloc_failed) { | 2809 | if (test_alloc_failed) { |
| 3325 | @@ -2827,7 +2866,7 @@ | |||
| 3326 | 2827 | TEST_ALLOC_FAIL { | 2866 | TEST_ALLOC_FAIL { |
| 3327 | 2828 | pos = 0; | 2867 | pos = 0; |
| 3328 | 2829 | lineno = 1; | 2868 | lineno = 1; |
| 3330 | 2830 | job = parse_job (NULL, "test", buf, strlen (buf), | 2869 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3331 | 2831 | &pos, &lineno); | 2870 | &pos, &lineno); |
| 3332 | 2832 | 2871 | ||
| 3333 | 2833 | if (test_alloc_failed) { | 2872 | if (test_alloc_failed) { |
| 3334 | @@ -2897,7 +2936,7 @@ | |||
| 3335 | 2897 | TEST_ALLOC_FAIL { | 2936 | TEST_ALLOC_FAIL { |
| 3336 | 2898 | pos = 0; | 2937 | pos = 0; |
| 3337 | 2899 | lineno = 1; | 2938 | lineno = 1; |
| 3339 | 2900 | job = parse_job (NULL, "test", buf, strlen (buf), | 2939 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3340 | 2901 | &pos, &lineno); | 2940 | &pos, &lineno); |
| 3341 | 2902 | 2941 | ||
| 3342 | 2903 | if (test_alloc_failed) { | 2942 | if (test_alloc_failed) { |
| 3343 | @@ -2975,7 +3014,7 @@ | |||
| 3344 | 2975 | TEST_ALLOC_FAIL { | 3014 | TEST_ALLOC_FAIL { |
| 3345 | 2976 | pos = 0; | 3015 | pos = 0; |
| 3346 | 2977 | lineno = 1; | 3016 | lineno = 1; |
| 3348 | 2978 | job = parse_job (NULL, "test", buf, strlen (buf), | 3017 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3349 | 2979 | &pos, &lineno); | 3018 | &pos, &lineno); |
| 3350 | 2980 | 3019 | ||
| 3351 | 2981 | if (test_alloc_failed) { | 3020 | if (test_alloc_failed) { |
| 3352 | @@ -3055,7 +3094,7 @@ | |||
| 3353 | 3055 | TEST_ALLOC_FAIL { | 3094 | TEST_ALLOC_FAIL { |
| 3354 | 3056 | pos = 0; | 3095 | pos = 0; |
| 3355 | 3057 | lineno = 1; | 3096 | lineno = 1; |
| 3357 | 3058 | job = parse_job (NULL, "test", buf, strlen (buf), | 3097 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3358 | 3059 | &pos, &lineno); | 3098 | &pos, &lineno); |
| 3359 | 3060 | 3099 | ||
| 3360 | 3061 | if (test_alloc_failed) { | 3100 | if (test_alloc_failed) { |
| 3361 | @@ -3134,7 +3173,7 @@ | |||
| 3362 | 3134 | TEST_ALLOC_FAIL { | 3173 | TEST_ALLOC_FAIL { |
| 3363 | 3135 | pos = 0; | 3174 | pos = 0; |
| 3364 | 3136 | lineno = 1; | 3175 | lineno = 1; |
| 3366 | 3137 | job = parse_job (NULL, "test", buf, strlen (buf), | 3176 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3367 | 3138 | &pos, &lineno); | 3177 | &pos, &lineno); |
| 3368 | 3139 | 3178 | ||
| 3369 | 3140 | if (test_alloc_failed) { | 3179 | if (test_alloc_failed) { |
| 3370 | @@ -3176,7 +3215,7 @@ | |||
| 3371 | 3176 | 3215 | ||
| 3372 | 3177 | pos = 0; | 3216 | pos = 0; |
| 3373 | 3178 | lineno = 1; | 3217 | lineno = 1; |
| 3375 | 3179 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3218 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3376 | 3180 | 3219 | ||
| 3377 | 3181 | TEST_EQ_P (job, NULL); | 3220 | TEST_EQ_P (job, NULL); |
| 3378 | 3182 | 3221 | ||
| 3379 | @@ -3195,7 +3234,7 @@ | |||
| 3380 | 3195 | 3234 | ||
| 3381 | 3196 | pos = 0; | 3235 | pos = 0; |
| 3382 | 3197 | lineno = 1; | 3236 | lineno = 1; |
| 3384 | 3198 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3237 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3385 | 3199 | 3238 | ||
| 3386 | 3200 | TEST_EQ_P (job, NULL); | 3239 | TEST_EQ_P (job, NULL); |
| 3387 | 3201 | 3240 | ||
| 3388 | @@ -3214,7 +3253,7 @@ | |||
| 3389 | 3214 | 3253 | ||
| 3390 | 3215 | pos = 0; | 3254 | pos = 0; |
| 3391 | 3216 | lineno = 1; | 3255 | lineno = 1; |
| 3393 | 3217 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3256 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3394 | 3218 | 3257 | ||
| 3395 | 3219 | TEST_EQ_P (job, NULL); | 3258 | TEST_EQ_P (job, NULL); |
| 3396 | 3220 | 3259 | ||
| 3397 | @@ -3233,7 +3272,7 @@ | |||
| 3398 | 3233 | 3272 | ||
| 3399 | 3234 | pos = 0; | 3273 | pos = 0; |
| 3400 | 3235 | lineno = 1; | 3274 | lineno = 1; |
| 3402 | 3236 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3275 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3403 | 3237 | 3276 | ||
| 3404 | 3238 | TEST_EQ_P (job, NULL); | 3277 | TEST_EQ_P (job, NULL); |
| 3405 | 3239 | 3278 | ||
| 3406 | @@ -3252,7 +3291,7 @@ | |||
| 3407 | 3252 | 3291 | ||
| 3408 | 3253 | pos = 0; | 3292 | pos = 0; |
| 3409 | 3254 | lineno = 1; | 3293 | lineno = 1; |
| 3411 | 3255 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3294 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3412 | 3256 | 3295 | ||
| 3413 | 3257 | TEST_EQ_P (job, NULL); | 3296 | TEST_EQ_P (job, NULL); |
| 3414 | 3258 | 3297 | ||
| 3415 | @@ -3269,7 +3308,7 @@ | |||
| 3416 | 3269 | 3308 | ||
| 3417 | 3270 | pos = 0; | 3309 | pos = 0; |
| 3418 | 3271 | lineno = 1; | 3310 | lineno = 1; |
| 3420 | 3272 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3311 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3421 | 3273 | 3312 | ||
| 3422 | 3274 | TEST_EQ_P (job, NULL); | 3313 | TEST_EQ_P (job, NULL); |
| 3423 | 3275 | 3314 | ||
| 3424 | @@ -3288,7 +3327,7 @@ | |||
| 3425 | 3288 | 3327 | ||
| 3426 | 3289 | pos = 0; | 3328 | pos = 0; |
| 3427 | 3290 | lineno = 1; | 3329 | lineno = 1; |
| 3429 | 3291 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3330 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3430 | 3292 | 3331 | ||
| 3431 | 3293 | TEST_EQ_P (job, NULL); | 3332 | TEST_EQ_P (job, NULL); |
| 3432 | 3294 | 3333 | ||
| 3433 | @@ -3307,7 +3346,7 @@ | |||
| 3434 | 3307 | 3346 | ||
| 3435 | 3308 | pos = 0; | 3347 | pos = 0; |
| 3436 | 3309 | lineno = 1; | 3348 | lineno = 1; |
| 3438 | 3310 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3349 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3439 | 3311 | 3350 | ||
| 3440 | 3312 | TEST_EQ_P (job, NULL); | 3351 | TEST_EQ_P (job, NULL); |
| 3441 | 3313 | 3352 | ||
| 3442 | @@ -3326,7 +3365,7 @@ | |||
| 3443 | 3326 | 3365 | ||
| 3444 | 3327 | pos = 0; | 3366 | pos = 0; |
| 3445 | 3328 | lineno = 1; | 3367 | lineno = 1; |
| 3447 | 3329 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3368 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3448 | 3330 | 3369 | ||
| 3449 | 3331 | TEST_EQ_P (job, NULL); | 3370 | TEST_EQ_P (job, NULL); |
| 3450 | 3332 | 3371 | ||
| 3451 | @@ -3345,7 +3384,7 @@ | |||
| 3452 | 3345 | 3384 | ||
| 3453 | 3346 | pos = 0; | 3385 | pos = 0; |
| 3454 | 3347 | lineno = 1; | 3386 | lineno = 1; |
| 3456 | 3348 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3387 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3457 | 3349 | 3388 | ||
| 3458 | 3350 | TEST_EQ_P (job, NULL); | 3389 | TEST_EQ_P (job, NULL); |
| 3459 | 3351 | 3390 | ||
| 3460 | @@ -3364,7 +3403,7 @@ | |||
| 3461 | 3364 | 3403 | ||
| 3462 | 3365 | pos = 0; | 3404 | pos = 0; |
| 3463 | 3366 | lineno = 1; | 3405 | lineno = 1; |
| 3465 | 3367 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3406 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3466 | 3368 | 3407 | ||
| 3467 | 3369 | TEST_EQ_P (job, NULL); | 3408 | TEST_EQ_P (job, NULL); |
| 3468 | 3370 | 3409 | ||
| 3469 | @@ -3383,7 +3422,7 @@ | |||
| 3470 | 3383 | 3422 | ||
| 3471 | 3384 | pos = 0; | 3423 | pos = 0; |
| 3472 | 3385 | lineno = 1; | 3424 | lineno = 1; |
| 3474 | 3386 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3425 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3475 | 3387 | 3426 | ||
| 3476 | 3388 | TEST_EQ_P (job, NULL); | 3427 | TEST_EQ_P (job, NULL); |
| 3477 | 3389 | 3428 | ||
| 3478 | @@ -3402,7 +3441,7 @@ | |||
| 3479 | 3402 | 3441 | ||
| 3480 | 3403 | pos = 0; | 3442 | pos = 0; |
| 3481 | 3404 | lineno = 1; | 3443 | lineno = 1; |
| 3483 | 3405 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3444 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3484 | 3406 | 3445 | ||
| 3485 | 3407 | TEST_EQ_P (job, NULL); | 3446 | TEST_EQ_P (job, NULL); |
| 3486 | 3408 | 3447 | ||
| 3487 | @@ -3432,7 +3471,7 @@ | |||
| 3488 | 3432 | TEST_ALLOC_FAIL { | 3471 | TEST_ALLOC_FAIL { |
| 3489 | 3433 | pos = 0; | 3472 | pos = 0; |
| 3490 | 3434 | lineno = 1; | 3473 | lineno = 1; |
| 3492 | 3435 | job = parse_job (NULL, "test", buf, strlen (buf), | 3474 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3493 | 3436 | &pos, &lineno); | 3475 | &pos, &lineno); |
| 3494 | 3437 | 3476 | ||
| 3495 | 3438 | if (test_alloc_failed) { | 3477 | if (test_alloc_failed) { |
| 3496 | @@ -3465,7 +3504,7 @@ | |||
| 3497 | 3465 | TEST_ALLOC_FAIL { | 3504 | TEST_ALLOC_FAIL { |
| 3498 | 3466 | pos = 0; | 3505 | pos = 0; |
| 3499 | 3467 | lineno = 1; | 3506 | lineno = 1; |
| 3501 | 3468 | job = parse_job (NULL, "test", buf, strlen (buf), | 3507 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3502 | 3469 | &pos, &lineno); | 3508 | &pos, &lineno); |
| 3503 | 3470 | 3509 | ||
| 3504 | 3471 | if (test_alloc_failed) { | 3510 | if (test_alloc_failed) { |
| 3505 | @@ -3498,7 +3537,7 @@ | |||
| 3506 | 3498 | 3537 | ||
| 3507 | 3499 | pos = 0; | 3538 | pos = 0; |
| 3508 | 3500 | lineno = 1; | 3539 | lineno = 1; |
| 3510 | 3501 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3540 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3511 | 3502 | 3541 | ||
| 3512 | 3503 | TEST_EQ_P (job, NULL); | 3542 | TEST_EQ_P (job, NULL); |
| 3513 | 3504 | 3543 | ||
| 3514 | @@ -3517,7 +3556,7 @@ | |||
| 3515 | 3517 | 3556 | ||
| 3516 | 3518 | pos = 0; | 3557 | pos = 0; |
| 3517 | 3519 | lineno = 1; | 3558 | lineno = 1; |
| 3519 | 3520 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3559 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3520 | 3521 | 3560 | ||
| 3521 | 3522 | TEST_EQ_P (job, NULL); | 3561 | TEST_EQ_P (job, NULL); |
| 3522 | 3523 | 3562 | ||
| 3523 | @@ -3547,7 +3586,7 @@ | |||
| 3524 | 3547 | TEST_ALLOC_FAIL { | 3586 | TEST_ALLOC_FAIL { |
| 3525 | 3548 | pos = 0; | 3587 | pos = 0; |
| 3526 | 3549 | lineno = 1; | 3588 | lineno = 1; |
| 3528 | 3550 | job = parse_job (NULL, "test", buf, strlen (buf), | 3589 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3529 | 3551 | &pos, &lineno); | 3590 | &pos, &lineno); |
| 3530 | 3552 | 3591 | ||
| 3531 | 3553 | if (test_alloc_failed) { | 3592 | if (test_alloc_failed) { |
| 3532 | @@ -3580,7 +3619,7 @@ | |||
| 3533 | 3580 | TEST_ALLOC_FAIL { | 3619 | TEST_ALLOC_FAIL { |
| 3534 | 3581 | pos = 0; | 3620 | pos = 0; |
| 3535 | 3582 | lineno = 1; | 3621 | lineno = 1; |
| 3537 | 3583 | job = parse_job (NULL, "test", buf, strlen (buf), | 3622 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3538 | 3584 | &pos, &lineno); | 3623 | &pos, &lineno); |
| 3539 | 3585 | 3624 | ||
| 3540 | 3586 | if (test_alloc_failed) { | 3625 | if (test_alloc_failed) { |
| 3541 | @@ -3613,7 +3652,7 @@ | |||
| 3542 | 3613 | 3652 | ||
| 3543 | 3614 | pos = 0; | 3653 | pos = 0; |
| 3544 | 3615 | lineno = 1; | 3654 | lineno = 1; |
| 3546 | 3616 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3655 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3547 | 3617 | 3656 | ||
| 3548 | 3618 | TEST_EQ_P (job, NULL); | 3657 | TEST_EQ_P (job, NULL); |
| 3549 | 3619 | 3658 | ||
| 3550 | @@ -3632,7 +3671,7 @@ | |||
| 3551 | 3632 | 3671 | ||
| 3552 | 3633 | pos = 0; | 3672 | pos = 0; |
| 3553 | 3634 | lineno = 1; | 3673 | lineno = 1; |
| 3555 | 3635 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3674 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3556 | 3636 | 3675 | ||
| 3557 | 3637 | TEST_EQ_P (job, NULL); | 3676 | TEST_EQ_P (job, NULL); |
| 3558 | 3638 | 3677 | ||
| 3559 | @@ -3662,7 +3701,7 @@ | |||
| 3560 | 3662 | TEST_ALLOC_FAIL { | 3701 | TEST_ALLOC_FAIL { |
| 3561 | 3663 | pos = 0; | 3702 | pos = 0; |
| 3562 | 3664 | lineno = 1; | 3703 | lineno = 1; |
| 3564 | 3665 | job = parse_job (NULL, "test", buf, strlen (buf), | 3704 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3565 | 3666 | &pos, &lineno); | 3705 | &pos, &lineno); |
| 3566 | 3667 | 3706 | ||
| 3567 | 3668 | if (test_alloc_failed) { | 3707 | if (test_alloc_failed) { |
| 3568 | @@ -3695,7 +3734,7 @@ | |||
| 3569 | 3695 | TEST_ALLOC_FAIL { | 3734 | TEST_ALLOC_FAIL { |
| 3570 | 3696 | pos = 0; | 3735 | pos = 0; |
| 3571 | 3697 | lineno = 1; | 3736 | lineno = 1; |
| 3573 | 3698 | job = parse_job (NULL, "test", buf, strlen (buf), | 3737 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3574 | 3699 | &pos, &lineno); | 3738 | &pos, &lineno); |
| 3575 | 3700 | 3739 | ||
| 3576 | 3701 | if (test_alloc_failed) { | 3740 | if (test_alloc_failed) { |
| 3577 | @@ -3728,7 +3767,7 @@ | |||
| 3578 | 3728 | 3767 | ||
| 3579 | 3729 | pos = 0; | 3768 | pos = 0; |
| 3580 | 3730 | lineno = 1; | 3769 | lineno = 1; |
| 3582 | 3731 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3770 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3583 | 3732 | 3771 | ||
| 3584 | 3733 | TEST_EQ_P (job, NULL); | 3772 | TEST_EQ_P (job, NULL); |
| 3585 | 3734 | 3773 | ||
| 3586 | @@ -3747,7 +3786,7 @@ | |||
| 3587 | 3747 | 3786 | ||
| 3588 | 3748 | pos = 0; | 3787 | pos = 0; |
| 3589 | 3749 | lineno = 1; | 3788 | lineno = 1; |
| 3591 | 3750 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3789 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3592 | 3751 | 3790 | ||
| 3593 | 3752 | TEST_EQ_P (job, NULL); | 3791 | TEST_EQ_P (job, NULL); |
| 3594 | 3753 | 3792 | ||
| 3595 | @@ -3777,7 +3816,7 @@ | |||
| 3596 | 3777 | TEST_ALLOC_FAIL { | 3816 | TEST_ALLOC_FAIL { |
| 3597 | 3778 | pos = 0; | 3817 | pos = 0; |
| 3598 | 3779 | lineno = 1; | 3818 | lineno = 1; |
| 3600 | 3780 | job = parse_job (NULL, "test", buf, strlen (buf), | 3819 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3601 | 3781 | &pos, &lineno); | 3820 | &pos, &lineno); |
| 3602 | 3782 | 3821 | ||
| 3603 | 3783 | if (test_alloc_failed) { | 3822 | if (test_alloc_failed) { |
| 3604 | @@ -3814,7 +3853,7 @@ | |||
| 3605 | 3814 | TEST_ALLOC_FAIL { | 3853 | TEST_ALLOC_FAIL { |
| 3606 | 3815 | pos = 0; | 3854 | pos = 0; |
| 3607 | 3816 | lineno = 1; | 3855 | lineno = 1; |
| 3609 | 3817 | job = parse_job (NULL, "test", buf, strlen (buf), | 3856 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3610 | 3818 | &pos, &lineno); | 3857 | &pos, &lineno); |
| 3611 | 3819 | 3858 | ||
| 3612 | 3820 | if (test_alloc_failed) { | 3859 | if (test_alloc_failed) { |
| 3613 | @@ -3857,7 +3896,7 @@ | |||
| 3614 | 3857 | TEST_ALLOC_FAIL { | 3896 | TEST_ALLOC_FAIL { |
| 3615 | 3858 | pos = 0; | 3897 | pos = 0; |
| 3616 | 3859 | lineno = 1; | 3898 | lineno = 1; |
| 3618 | 3860 | job = parse_job (NULL, "test", buf, strlen (buf), | 3899 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3619 | 3861 | &pos, &lineno); | 3900 | &pos, &lineno); |
| 3620 | 3862 | 3901 | ||
| 3621 | 3863 | if (test_alloc_failed) { | 3902 | if (test_alloc_failed) { |
| 3622 | @@ -3899,7 +3938,7 @@ | |||
| 3623 | 3899 | 3938 | ||
| 3624 | 3900 | pos = 0; | 3939 | pos = 0; |
| 3625 | 3901 | lineno = 1; | 3940 | lineno = 1; |
| 3627 | 3902 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 3941 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3628 | 3903 | 3942 | ||
| 3629 | 3904 | TEST_EQ_P (job, NULL); | 3943 | TEST_EQ_P (job, NULL); |
| 3630 | 3905 | 3944 | ||
| 3631 | @@ -3929,7 +3968,7 @@ | |||
| 3632 | 3929 | TEST_ALLOC_FAIL { | 3968 | TEST_ALLOC_FAIL { |
| 3633 | 3930 | pos = 0; | 3969 | pos = 0; |
| 3634 | 3931 | lineno = 1; | 3970 | lineno = 1; |
| 3636 | 3932 | job = parse_job (NULL, "test", buf, strlen (buf), | 3971 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3637 | 3933 | &pos, &lineno); | 3972 | &pos, &lineno); |
| 3638 | 3934 | 3973 | ||
| 3639 | 3935 | if (test_alloc_failed) { | 3974 | if (test_alloc_failed) { |
| 3640 | @@ -3962,7 +4001,7 @@ | |||
| 3641 | 3962 | TEST_ALLOC_FAIL { | 4001 | TEST_ALLOC_FAIL { |
| 3642 | 3963 | pos = 0; | 4002 | pos = 0; |
| 3643 | 3964 | lineno = 1; | 4003 | lineno = 1; |
| 3645 | 3965 | job = parse_job (NULL, "test", buf, strlen (buf), | 4004 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3646 | 3966 | &pos, &lineno); | 4005 | &pos, &lineno); |
| 3647 | 3967 | 4006 | ||
| 3648 | 3968 | if (test_alloc_failed) { | 4007 | if (test_alloc_failed) { |
| 3649 | @@ -3995,7 +4034,7 @@ | |||
| 3650 | 3995 | TEST_ALLOC_FAIL { | 4034 | TEST_ALLOC_FAIL { |
| 3651 | 3996 | pos = 0; | 4035 | pos = 0; |
| 3652 | 3997 | lineno = 1; | 4036 | lineno = 1; |
| 3654 | 3998 | job = parse_job (NULL, "test", buf, strlen (buf), | 4037 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3655 | 3999 | &pos, &lineno); | 4038 | &pos, &lineno); |
| 3656 | 4000 | 4039 | ||
| 3657 | 4001 | if (test_alloc_failed) { | 4040 | if (test_alloc_failed) { |
| 3658 | @@ -4028,7 +4067,7 @@ | |||
| 3659 | 4028 | TEST_ALLOC_FAIL { | 4067 | TEST_ALLOC_FAIL { |
| 3660 | 4029 | pos = 0; | 4068 | pos = 0; |
| 3661 | 4030 | lineno = 1; | 4069 | lineno = 1; |
| 3663 | 4031 | job = parse_job (NULL, "test", buf, strlen (buf), | 4070 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3664 | 4032 | &pos, &lineno); | 4071 | &pos, &lineno); |
| 3665 | 4033 | 4072 | ||
| 3666 | 4034 | if (test_alloc_failed) { | 4073 | if (test_alloc_failed) { |
| 3667 | @@ -4061,7 +4100,7 @@ | |||
| 3668 | 4061 | TEST_ALLOC_FAIL { | 4100 | TEST_ALLOC_FAIL { |
| 3669 | 4062 | pos = 0; | 4101 | pos = 0; |
| 3670 | 4063 | lineno = 1; | 4102 | lineno = 1; |
| 3672 | 4064 | job = parse_job (NULL, "test", buf, strlen (buf), | 4103 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3673 | 4065 | &pos, &lineno); | 4104 | &pos, &lineno); |
| 3674 | 4066 | 4105 | ||
| 3675 | 4067 | if (test_alloc_failed) { | 4106 | if (test_alloc_failed) { |
| 3676 | @@ -4093,7 +4132,7 @@ | |||
| 3677 | 4093 | 4132 | ||
| 3678 | 4094 | pos = 0; | 4133 | pos = 0; |
| 3679 | 4095 | lineno = 1; | 4134 | lineno = 1; |
| 3681 | 4096 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4135 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3682 | 4097 | 4136 | ||
| 3683 | 4098 | TEST_EQ_P (job, NULL); | 4137 | TEST_EQ_P (job, NULL); |
| 3684 | 4099 | 4138 | ||
| 3685 | @@ -4112,7 +4151,7 @@ | |||
| 3686 | 4112 | 4151 | ||
| 3687 | 4113 | pos = 0; | 4152 | pos = 0; |
| 3688 | 4114 | lineno = 1; | 4153 | lineno = 1; |
| 3690 | 4115 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4154 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3691 | 4116 | 4155 | ||
| 3692 | 4117 | TEST_EQ_P (job, NULL); | 4156 | TEST_EQ_P (job, NULL); |
| 3693 | 4118 | 4157 | ||
| 3694 | @@ -4131,7 +4170,7 @@ | |||
| 3695 | 4131 | 4170 | ||
| 3696 | 4132 | pos = 0; | 4171 | pos = 0; |
| 3697 | 4133 | lineno = 1; | 4172 | lineno = 1; |
| 3699 | 4134 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4173 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3700 | 4135 | 4174 | ||
| 3701 | 4136 | TEST_EQ_P (job, NULL); | 4175 | TEST_EQ_P (job, NULL); |
| 3702 | 4137 | 4176 | ||
| 3703 | @@ -4159,7 +4198,7 @@ | |||
| 3704 | 4159 | TEST_ALLOC_FAIL { | 4198 | TEST_ALLOC_FAIL { |
| 3705 | 4160 | pos = 0; | 4199 | pos = 0; |
| 3706 | 4161 | lineno = 1; | 4200 | lineno = 1; |
| 3708 | 4162 | job = parse_job (NULL, "test", buf, strlen (buf), | 4201 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3709 | 4163 | &pos, &lineno); | 4202 | &pos, &lineno); |
| 3710 | 4164 | 4203 | ||
| 3711 | 4165 | if (test_alloc_failed) { | 4204 | if (test_alloc_failed) { |
| 3712 | @@ -4193,7 +4232,7 @@ | |||
| 3713 | 4193 | TEST_ALLOC_FAIL { | 4232 | TEST_ALLOC_FAIL { |
| 3714 | 4194 | pos = 0; | 4233 | pos = 0; |
| 3715 | 4195 | lineno = 1; | 4234 | lineno = 1; |
| 3717 | 4196 | job = parse_job (NULL, "test", buf, strlen (buf), | 4235 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3718 | 4197 | &pos, &lineno); | 4236 | &pos, &lineno); |
| 3719 | 4198 | 4237 | ||
| 3720 | 4199 | if (test_alloc_failed) { | 4238 | if (test_alloc_failed) { |
| 3721 | @@ -4226,7 +4265,7 @@ | |||
| 3722 | 4226 | TEST_ALLOC_FAIL { | 4265 | TEST_ALLOC_FAIL { |
| 3723 | 4227 | pos = 0; | 4266 | pos = 0; |
| 3724 | 4228 | lineno = 1; | 4267 | lineno = 1; |
| 3726 | 4229 | job = parse_job (NULL, "test", buf, strlen (buf), | 4268 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3727 | 4230 | &pos, &lineno); | 4269 | &pos, &lineno); |
| 3728 | 4231 | 4270 | ||
| 3729 | 4232 | if (test_alloc_failed) { | 4271 | if (test_alloc_failed) { |
| 3730 | @@ -4260,7 +4299,7 @@ | |||
| 3731 | 4260 | TEST_ALLOC_FAIL { | 4299 | TEST_ALLOC_FAIL { |
| 3732 | 4261 | pos = 0; | 4300 | pos = 0; |
| 3733 | 4262 | lineno = 1; | 4301 | lineno = 1; |
| 3735 | 4263 | job = parse_job (NULL, "test", buf, strlen (buf), | 4302 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3736 | 4264 | &pos, &lineno); | 4303 | &pos, &lineno); |
| 3737 | 4265 | 4304 | ||
| 3738 | 4266 | if (test_alloc_failed) { | 4305 | if (test_alloc_failed) { |
| 3739 | @@ -4293,7 +4332,7 @@ | |||
| 3740 | 4293 | TEST_ALLOC_FAIL { | 4332 | TEST_ALLOC_FAIL { |
| 3741 | 4294 | pos = 0; | 4333 | pos = 0; |
| 3742 | 4295 | lineno = 1; | 4334 | lineno = 1; |
| 3744 | 4296 | job = parse_job (NULL, "test", buf, strlen (buf), | 4335 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3745 | 4297 | &pos, &lineno); | 4336 | &pos, &lineno); |
| 3746 | 4298 | 4337 | ||
| 3747 | 4299 | if (test_alloc_failed) { | 4338 | if (test_alloc_failed) { |
| 3748 | @@ -4326,7 +4365,7 @@ | |||
| 3749 | 4326 | 4365 | ||
| 3750 | 4327 | pos = 0; | 4366 | pos = 0; |
| 3751 | 4328 | lineno = 1; | 4367 | lineno = 1; |
| 3753 | 4329 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4368 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3754 | 4330 | 4369 | ||
| 3755 | 4331 | TEST_EQ_P (job, NULL); | 4370 | TEST_EQ_P (job, NULL); |
| 3756 | 4332 | 4371 | ||
| 3757 | @@ -4345,7 +4384,7 @@ | |||
| 3758 | 4345 | 4384 | ||
| 3759 | 4346 | pos = 0; | 4385 | pos = 0; |
| 3760 | 4347 | lineno = 1; | 4386 | lineno = 1; |
| 3762 | 4348 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4387 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3763 | 4349 | 4388 | ||
| 3764 | 4350 | TEST_EQ_P (job, NULL); | 4389 | TEST_EQ_P (job, NULL); |
| 3765 | 4351 | 4390 | ||
| 3766 | @@ -4364,7 +4403,7 @@ | |||
| 3767 | 4364 | 4403 | ||
| 3768 | 4365 | pos = 0; | 4404 | pos = 0; |
| 3769 | 4366 | lineno = 1; | 4405 | lineno = 1; |
| 3771 | 4367 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4406 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3772 | 4368 | 4407 | ||
| 3773 | 4369 | TEST_EQ_P (job, NULL); | 4408 | TEST_EQ_P (job, NULL); |
| 3774 | 4370 | 4409 | ||
| 3775 | @@ -4383,7 +4422,7 @@ | |||
| 3776 | 4383 | 4422 | ||
| 3777 | 4384 | pos = 0; | 4423 | pos = 0; |
| 3778 | 4385 | lineno = 1; | 4424 | lineno = 1; |
| 3780 | 4386 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4425 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3781 | 4387 | 4426 | ||
| 3782 | 4388 | TEST_EQ_P (job, NULL); | 4427 | TEST_EQ_P (job, NULL); |
| 3783 | 4389 | 4428 | ||
| 3784 | @@ -4402,7 +4441,7 @@ | |||
| 3785 | 4402 | 4441 | ||
| 3786 | 4403 | pos = 0; | 4442 | pos = 0; |
| 3787 | 4404 | lineno = 1; | 4443 | lineno = 1; |
| 3789 | 4405 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4444 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3790 | 4406 | 4445 | ||
| 3791 | 4407 | TEST_EQ_P (job, NULL); | 4446 | TEST_EQ_P (job, NULL); |
| 3792 | 4408 | 4447 | ||
| 3793 | @@ -4421,7 +4460,7 @@ | |||
| 3794 | 4421 | 4460 | ||
| 3795 | 4422 | pos = 0; | 4461 | pos = 0; |
| 3796 | 4423 | lineno = 1; | 4462 | lineno = 1; |
| 3798 | 4424 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4463 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3799 | 4425 | 4464 | ||
| 3800 | 4426 | TEST_EQ_P (job, NULL); | 4465 | TEST_EQ_P (job, NULL); |
| 3801 | 4427 | 4466 | ||
| 3802 | @@ -4440,7 +4479,7 @@ | |||
| 3803 | 4440 | 4479 | ||
| 3804 | 4441 | pos = 0; | 4480 | pos = 0; |
| 3805 | 4442 | lineno = 1; | 4481 | lineno = 1; |
| 3807 | 4443 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4482 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3808 | 4444 | 4483 | ||
| 3809 | 4445 | TEST_EQ_P (job, NULL); | 4484 | TEST_EQ_P (job, NULL); |
| 3810 | 4446 | 4485 | ||
| 3811 | @@ -4459,7 +4498,7 @@ | |||
| 3812 | 4459 | 4498 | ||
| 3813 | 4460 | pos = 0; | 4499 | pos = 0; |
| 3814 | 4461 | lineno = 1; | 4500 | lineno = 1; |
| 3816 | 4462 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4501 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3817 | 4463 | 4502 | ||
| 3818 | 4464 | TEST_EQ_P (job, NULL); | 4503 | TEST_EQ_P (job, NULL); |
| 3819 | 4465 | 4504 | ||
| 3820 | @@ -4478,7 +4517,7 @@ | |||
| 3821 | 4478 | 4517 | ||
| 3822 | 4479 | pos = 0; | 4518 | pos = 0; |
| 3823 | 4480 | lineno = 1; | 4519 | lineno = 1; |
| 3825 | 4481 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4520 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3826 | 4482 | 4521 | ||
| 3827 | 4483 | TEST_EQ_P (job, NULL); | 4522 | TEST_EQ_P (job, NULL); |
| 3828 | 4484 | 4523 | ||
| 3829 | @@ -4497,7 +4536,7 @@ | |||
| 3830 | 4497 | 4536 | ||
| 3831 | 4498 | pos = 0; | 4537 | pos = 0; |
| 3832 | 4499 | lineno = 1; | 4538 | lineno = 1; |
| 3834 | 4500 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4539 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3835 | 4501 | 4540 | ||
| 3836 | 4502 | TEST_EQ_P (job, NULL); | 4541 | TEST_EQ_P (job, NULL); |
| 3837 | 4503 | 4542 | ||
| 3838 | @@ -4516,7 +4555,7 @@ | |||
| 3839 | 4516 | 4555 | ||
| 3840 | 4517 | pos = 0; | 4556 | pos = 0; |
| 3841 | 4518 | lineno = 1; | 4557 | lineno = 1; |
| 3843 | 4519 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4558 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3844 | 4520 | 4559 | ||
| 3845 | 4521 | TEST_EQ_P (job, NULL); | 4560 | TEST_EQ_P (job, NULL); |
| 3846 | 4522 | 4561 | ||
| 3847 | @@ -4535,7 +4574,7 @@ | |||
| 3848 | 4535 | 4574 | ||
| 3849 | 4536 | pos = 0; | 4575 | pos = 0; |
| 3850 | 4537 | lineno = 1; | 4576 | lineno = 1; |
| 3852 | 4538 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4577 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3853 | 4539 | 4578 | ||
| 3854 | 4540 | TEST_EQ_P (job, NULL); | 4579 | TEST_EQ_P (job, NULL); |
| 3855 | 4541 | 4580 | ||
| 3856 | @@ -4565,7 +4604,7 @@ | |||
| 3857 | 4565 | TEST_ALLOC_FAIL { | 4604 | TEST_ALLOC_FAIL { |
| 3858 | 4566 | pos = 0; | 4605 | pos = 0; |
| 3859 | 4567 | lineno = 1; | 4606 | lineno = 1; |
| 3861 | 4568 | job = parse_job (NULL, "test", buf, strlen (buf), | 4607 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3862 | 4569 | &pos, &lineno); | 4608 | &pos, &lineno); |
| 3863 | 4570 | 4609 | ||
| 3864 | 4571 | if (test_alloc_failed) { | 4610 | if (test_alloc_failed) { |
| 3865 | @@ -4597,7 +4636,7 @@ | |||
| 3866 | 4597 | TEST_ALLOC_FAIL { | 4636 | TEST_ALLOC_FAIL { |
| 3867 | 4598 | pos = 0; | 4637 | pos = 0; |
| 3868 | 4599 | lineno = 1; | 4638 | lineno = 1; |
| 3870 | 4600 | job = parse_job (NULL, "test", buf, strlen (buf), | 4639 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3871 | 4601 | &pos, &lineno); | 4640 | &pos, &lineno); |
| 3872 | 4602 | 4641 | ||
| 3873 | 4603 | if (test_alloc_failed) { | 4642 | if (test_alloc_failed) { |
| 3874 | @@ -4629,7 +4668,7 @@ | |||
| 3875 | 4629 | 4668 | ||
| 3876 | 4630 | pos = 0; | 4669 | pos = 0; |
| 3877 | 4631 | lineno = 1; | 4670 | lineno = 1; |
| 3879 | 4632 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4671 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3880 | 4633 | 4672 | ||
| 3881 | 4634 | TEST_EQ_P (job, NULL); | 4673 | TEST_EQ_P (job, NULL); |
| 3882 | 4635 | 4674 | ||
| 3883 | @@ -4659,7 +4698,7 @@ | |||
| 3884 | 4659 | TEST_ALLOC_FAIL { | 4698 | TEST_ALLOC_FAIL { |
| 3885 | 4660 | pos = 0; | 4699 | pos = 0; |
| 3886 | 4661 | lineno = 1; | 4700 | lineno = 1; |
| 3888 | 4662 | job = parse_job (NULL, "test", buf, strlen (buf), | 4701 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3889 | 4663 | &pos, &lineno); | 4702 | &pos, &lineno); |
| 3890 | 4664 | 4703 | ||
| 3891 | 4665 | if (test_alloc_failed) { | 4704 | if (test_alloc_failed) { |
| 3892 | @@ -4693,7 +4732,7 @@ | |||
| 3893 | 4693 | TEST_ALLOC_FAIL { | 4732 | TEST_ALLOC_FAIL { |
| 3894 | 4694 | pos = 0; | 4733 | pos = 0; |
| 3895 | 4695 | lineno = 1; | 4734 | lineno = 1; |
| 3897 | 4696 | job = parse_job (NULL, "test", buf, strlen (buf), | 4735 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3898 | 4697 | &pos, &lineno); | 4736 | &pos, &lineno); |
| 3899 | 4698 | 4737 | ||
| 3900 | 4699 | if (test_alloc_failed) { | 4738 | if (test_alloc_failed) { |
| 3901 | @@ -4726,7 +4765,7 @@ | |||
| 3902 | 4726 | 4765 | ||
| 3903 | 4727 | pos = 0; | 4766 | pos = 0; |
| 3904 | 4728 | lineno = 1; | 4767 | lineno = 1; |
| 3906 | 4729 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4768 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3907 | 4730 | 4769 | ||
| 3908 | 4731 | TEST_EQ_P (job, NULL); | 4770 | TEST_EQ_P (job, NULL); |
| 3909 | 4732 | 4771 | ||
| 3910 | @@ -4745,7 +4784,7 @@ | |||
| 3911 | 4745 | 4784 | ||
| 3912 | 4746 | pos = 0; | 4785 | pos = 0; |
| 3913 | 4747 | lineno = 1; | 4786 | lineno = 1; |
| 3915 | 4748 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4787 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3916 | 4749 | 4788 | ||
| 3917 | 4750 | TEST_EQ_P (job, NULL); | 4789 | TEST_EQ_P (job, NULL); |
| 3918 | 4751 | 4790 | ||
| 3919 | @@ -4775,7 +4814,7 @@ | |||
| 3920 | 4775 | TEST_ALLOC_FAIL { | 4814 | TEST_ALLOC_FAIL { |
| 3921 | 4776 | pos = 0; | 4815 | pos = 0; |
| 3922 | 4777 | lineno = 1; | 4816 | lineno = 1; |
| 3924 | 4778 | job = parse_job (NULL, "test", buf, strlen (buf), | 4817 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3925 | 4779 | &pos, &lineno); | 4818 | &pos, &lineno); |
| 3926 | 4780 | 4819 | ||
| 3927 | 4781 | if (test_alloc_failed) { | 4820 | if (test_alloc_failed) { |
| 3928 | @@ -4808,7 +4847,7 @@ | |||
| 3929 | 4808 | TEST_ALLOC_FAIL { | 4847 | TEST_ALLOC_FAIL { |
| 3930 | 4809 | pos = 0; | 4848 | pos = 0; |
| 3931 | 4810 | lineno = 1; | 4849 | lineno = 1; |
| 3933 | 4811 | job = parse_job (NULL, "test", buf, strlen (buf), | 4850 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 3934 | 4812 | &pos, &lineno); | 4851 | &pos, &lineno); |
| 3935 | 4813 | 4852 | ||
| 3936 | 4814 | if (test_alloc_failed) { | 4853 | if (test_alloc_failed) { |
| 3937 | @@ -4840,7 +4879,7 @@ | |||
| 3938 | 4840 | 4879 | ||
| 3939 | 4841 | pos = 0; | 4880 | pos = 0; |
| 3940 | 4842 | lineno = 1; | 4881 | lineno = 1; |
| 3942 | 4843 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4882 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3943 | 4844 | 4883 | ||
| 3944 | 4845 | TEST_EQ_P (job, NULL); | 4884 | TEST_EQ_P (job, NULL); |
| 3945 | 4846 | 4885 | ||
| 3946 | @@ -4859,7 +4898,7 @@ | |||
| 3947 | 4859 | 4898 | ||
| 3948 | 4860 | pos = 0; | 4899 | pos = 0; |
| 3949 | 4861 | lineno = 1; | 4900 | lineno = 1; |
| 3951 | 4862 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4901 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3952 | 4863 | 4902 | ||
| 3953 | 4864 | TEST_EQ_P (job, NULL); | 4903 | TEST_EQ_P (job, NULL); |
| 3954 | 4865 | 4904 | ||
| 3955 | @@ -4878,7 +4917,7 @@ | |||
| 3956 | 4878 | 4917 | ||
| 3957 | 4879 | pos = 0; | 4918 | pos = 0; |
| 3958 | 4880 | lineno = 1; | 4919 | lineno = 1; |
| 3960 | 4881 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4920 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3961 | 4882 | 4921 | ||
| 3962 | 4883 | TEST_EQ_P (job, NULL); | 4922 | TEST_EQ_P (job, NULL); |
| 3963 | 4884 | 4923 | ||
| 3964 | @@ -4897,7 +4936,7 @@ | |||
| 3965 | 4897 | 4936 | ||
| 3966 | 4898 | pos = 0; | 4937 | pos = 0; |
| 3967 | 4899 | lineno = 1; | 4938 | lineno = 1; |
| 3969 | 4900 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4939 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3970 | 4901 | 4940 | ||
| 3971 | 4902 | TEST_EQ_P (job, NULL); | 4941 | TEST_EQ_P (job, NULL); |
| 3972 | 4903 | 4942 | ||
| 3973 | @@ -4916,7 +4955,7 @@ | |||
| 3974 | 4916 | 4955 | ||
| 3975 | 4917 | pos = 0; | 4956 | pos = 0; |
| 3976 | 4918 | lineno = 1; | 4957 | lineno = 1; |
| 3978 | 4919 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4958 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3979 | 4920 | 4959 | ||
| 3980 | 4921 | TEST_EQ_P (job, NULL); | 4960 | TEST_EQ_P (job, NULL); |
| 3981 | 4922 | 4961 | ||
| 3982 | @@ -4935,7 +4974,7 @@ | |||
| 3983 | 4935 | 4974 | ||
| 3984 | 4936 | pos = 0; | 4975 | pos = 0; |
| 3985 | 4937 | lineno = 1; | 4976 | lineno = 1; |
| 3987 | 4938 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4977 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3988 | 4939 | 4978 | ||
| 3989 | 4940 | TEST_EQ_P (job, NULL); | 4979 | TEST_EQ_P (job, NULL); |
| 3990 | 4941 | 4980 | ||
| 3991 | @@ -4954,7 +4993,7 @@ | |||
| 3992 | 4954 | 4993 | ||
| 3993 | 4955 | pos = 0; | 4994 | pos = 0; |
| 3994 | 4956 | lineno = 1; | 4995 | lineno = 1; |
| 3996 | 4957 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 4996 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 3997 | 4958 | 4997 | ||
| 3998 | 4959 | TEST_EQ_P (job, NULL); | 4998 | TEST_EQ_P (job, NULL); |
| 3999 | 4960 | 4999 | ||
| 4000 | @@ -4974,7 +5013,7 @@ | |||
| 4001 | 4974 | 5013 | ||
| 4002 | 4975 | pos = 0; | 5014 | pos = 0; |
| 4003 | 4976 | lineno = 1; | 5015 | lineno = 1; |
| 4005 | 4977 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5016 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4006 | 4978 | 5017 | ||
| 4007 | 4979 | TEST_EQ_P (job, NULL); | 5018 | TEST_EQ_P (job, NULL); |
| 4008 | 4980 | 5019 | ||
| 4009 | @@ -5005,7 +5044,7 @@ | |||
| 4010 | 5005 | TEST_ALLOC_FAIL { | 5044 | TEST_ALLOC_FAIL { |
| 4011 | 5006 | pos = 0; | 5045 | pos = 0; |
| 4012 | 5007 | lineno = 1; | 5046 | lineno = 1; |
| 4014 | 5008 | job = parse_job (NULL, "test", buf, strlen (buf), | 5047 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4015 | 5009 | &pos, &lineno); | 5048 | &pos, &lineno); |
| 4016 | 5010 | 5049 | ||
| 4017 | 5011 | if (test_alloc_failed) { | 5050 | if (test_alloc_failed) { |
| 4018 | @@ -5044,7 +5083,7 @@ | |||
| 4019 | 5044 | TEST_ALLOC_FAIL { | 5083 | TEST_ALLOC_FAIL { |
| 4020 | 5045 | pos = 0; | 5084 | pos = 0; |
| 4021 | 5046 | lineno = 1; | 5085 | lineno = 1; |
| 4023 | 5047 | job = parse_job (NULL, "test", buf, strlen (buf), | 5086 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4024 | 5048 | &pos, &lineno); | 5087 | &pos, &lineno); |
| 4025 | 5049 | 5088 | ||
| 4026 | 5050 | if (test_alloc_failed) { | 5089 | if (test_alloc_failed) { |
| 4027 | @@ -5083,7 +5122,7 @@ | |||
| 4028 | 5083 | TEST_ALLOC_FAIL { | 5122 | TEST_ALLOC_FAIL { |
| 4029 | 5084 | pos = 0; | 5123 | pos = 0; |
| 4030 | 5085 | lineno = 1; | 5124 | lineno = 1; |
| 4032 | 5086 | job = parse_job (NULL, "test", buf, strlen (buf), | 5125 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4033 | 5087 | &pos, &lineno); | 5126 | &pos, &lineno); |
| 4034 | 5088 | 5127 | ||
| 4035 | 5089 | if (test_alloc_failed) { | 5128 | if (test_alloc_failed) { |
| 4036 | @@ -5127,7 +5166,7 @@ | |||
| 4037 | 5127 | TEST_ALLOC_FAIL { | 5166 | TEST_ALLOC_FAIL { |
| 4038 | 5128 | pos = 0; | 5167 | pos = 0; |
| 4039 | 5129 | lineno = 1; | 5168 | lineno = 1; |
| 4041 | 5130 | job = parse_job (NULL, "test", buf, strlen (buf), | 5169 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4042 | 5131 | &pos, &lineno); | 5170 | &pos, &lineno); |
| 4043 | 5132 | 5171 | ||
| 4044 | 5133 | if (test_alloc_failed) { | 5172 | if (test_alloc_failed) { |
| 4045 | @@ -5168,7 +5207,7 @@ | |||
| 4046 | 5168 | 5207 | ||
| 4047 | 5169 | pos = 0; | 5208 | pos = 0; |
| 4048 | 5170 | lineno = 1; | 5209 | lineno = 1; |
| 4050 | 5171 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5210 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4051 | 5172 | 5211 | ||
| 4052 | 5173 | TEST_EQ_P (job, NULL); | 5212 | TEST_EQ_P (job, NULL); |
| 4053 | 5174 | 5213 | ||
| 4054 | @@ -5187,7 +5226,7 @@ | |||
| 4055 | 5187 | 5226 | ||
| 4056 | 5188 | pos = 0; | 5227 | pos = 0; |
| 4057 | 5189 | lineno = 1; | 5228 | lineno = 1; |
| 4059 | 5190 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5229 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4060 | 5191 | 5230 | ||
| 4061 | 5192 | TEST_EQ_P (job, NULL); | 5231 | TEST_EQ_P (job, NULL); |
| 4062 | 5193 | 5232 | ||
| 4063 | @@ -5206,7 +5245,7 @@ | |||
| 4064 | 5206 | 5245 | ||
| 4065 | 5207 | pos = 0; | 5246 | pos = 0; |
| 4066 | 5208 | lineno = 1; | 5247 | lineno = 1; |
| 4068 | 5209 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5248 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4069 | 5210 | 5249 | ||
| 4070 | 5211 | TEST_EQ_P (job, NULL); | 5250 | TEST_EQ_P (job, NULL); |
| 4071 | 5212 | 5251 | ||
| 4072 | @@ -5225,7 +5264,7 @@ | |||
| 4073 | 5225 | 5264 | ||
| 4074 | 5226 | pos = 0; | 5265 | pos = 0; |
| 4075 | 5227 | lineno = 1; | 5266 | lineno = 1; |
| 4077 | 5228 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5267 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4078 | 5229 | 5268 | ||
| 4079 | 5230 | TEST_EQ_P (job, NULL); | 5269 | TEST_EQ_P (job, NULL); |
| 4080 | 5231 | 5270 | ||
| 4081 | @@ -5244,7 +5283,7 @@ | |||
| 4082 | 5244 | 5283 | ||
| 4083 | 5245 | pos = 0; | 5284 | pos = 0; |
| 4084 | 5246 | lineno = 1; | 5285 | lineno = 1; |
| 4086 | 5247 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5286 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4087 | 5248 | 5287 | ||
| 4088 | 5249 | TEST_EQ_P (job, NULL); | 5288 | TEST_EQ_P (job, NULL); |
| 4089 | 5250 | 5289 | ||
| 4090 | @@ -5263,7 +5302,7 @@ | |||
| 4091 | 5263 | 5302 | ||
| 4092 | 5264 | pos = 0; | 5303 | pos = 0; |
| 4093 | 5265 | lineno = 1; | 5304 | lineno = 1; |
| 4095 | 5266 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5305 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4096 | 5267 | 5306 | ||
| 4097 | 5268 | TEST_EQ_P (job, NULL); | 5307 | TEST_EQ_P (job, NULL); |
| 4098 | 5269 | 5308 | ||
| 4099 | @@ -5293,7 +5332,7 @@ | |||
| 4100 | 5293 | TEST_ALLOC_FAIL { | 5332 | TEST_ALLOC_FAIL { |
| 4101 | 5294 | pos = 0; | 5333 | pos = 0; |
| 4102 | 5295 | lineno = 1; | 5334 | lineno = 1; |
| 4104 | 5296 | job = parse_job (NULL, "test", buf, strlen (buf), | 5335 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4105 | 5297 | &pos, &lineno); | 5336 | &pos, &lineno); |
| 4106 | 5298 | 5337 | ||
| 4107 | 5299 | if (test_alloc_failed) { | 5338 | if (test_alloc_failed) { |
| 4108 | @@ -5326,7 +5365,7 @@ | |||
| 4109 | 5326 | TEST_ALLOC_FAIL { | 5365 | TEST_ALLOC_FAIL { |
| 4110 | 5327 | pos = 0; | 5366 | pos = 0; |
| 4111 | 5328 | lineno = 1; | 5367 | lineno = 1; |
| 4113 | 5329 | job = parse_job (NULL, "test", buf, strlen (buf), | 5368 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4114 | 5330 | &pos, &lineno); | 5369 | &pos, &lineno); |
| 4115 | 5331 | 5370 | ||
| 4116 | 5332 | if (test_alloc_failed) { | 5371 | if (test_alloc_failed) { |
| 4117 | @@ -5359,7 +5398,7 @@ | |||
| 4118 | 5359 | TEST_ALLOC_FAIL { | 5398 | TEST_ALLOC_FAIL { |
| 4119 | 5360 | pos = 0; | 5399 | pos = 0; |
| 4120 | 5361 | lineno = 1; | 5400 | lineno = 1; |
| 4122 | 5362 | job = parse_job (NULL, "test", buf, strlen (buf), | 5401 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4123 | 5363 | &pos, &lineno); | 5402 | &pos, &lineno); |
| 4124 | 5364 | 5403 | ||
| 4125 | 5365 | if (test_alloc_failed) { | 5404 | if (test_alloc_failed) { |
| 4126 | @@ -5392,7 +5431,7 @@ | |||
| 4127 | 5392 | TEST_ALLOC_FAIL { | 5431 | TEST_ALLOC_FAIL { |
| 4128 | 5393 | pos = 0; | 5432 | pos = 0; |
| 4129 | 5394 | lineno = 1; | 5433 | lineno = 1; |
| 4131 | 5395 | job = parse_job (NULL, "test", buf, strlen (buf), | 5434 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4132 | 5396 | &pos, &lineno); | 5435 | &pos, &lineno); |
| 4133 | 5397 | 5436 | ||
| 4134 | 5398 | if (test_alloc_failed) { | 5437 | if (test_alloc_failed) { |
| 4135 | @@ -5423,7 +5462,7 @@ | |||
| 4136 | 5423 | 5462 | ||
| 4137 | 5424 | pos = 0; | 5463 | pos = 0; |
| 4138 | 5425 | lineno = 1; | 5464 | lineno = 1; |
| 4140 | 5426 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5465 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4141 | 5427 | 5466 | ||
| 4142 | 5428 | TEST_EQ_P (job, NULL); | 5467 | TEST_EQ_P (job, NULL); |
| 4143 | 5429 | 5468 | ||
| 4144 | @@ -5442,7 +5481,7 @@ | |||
| 4145 | 5442 | 5481 | ||
| 4146 | 5443 | pos = 0; | 5482 | pos = 0; |
| 4147 | 5444 | lineno = 1; | 5483 | lineno = 1; |
| 4149 | 5445 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5484 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4150 | 5446 | 5485 | ||
| 4151 | 5447 | TEST_EQ_P (job, NULL); | 5486 | TEST_EQ_P (job, NULL); |
| 4152 | 5448 | 5487 | ||
| 4153 | @@ -5460,7 +5499,7 @@ | |||
| 4154 | 5460 | 5499 | ||
| 4155 | 5461 | pos = 0; | 5500 | pos = 0; |
| 4156 | 5462 | lineno = 1; | 5501 | lineno = 1; |
| 4158 | 5463 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5502 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4159 | 5464 | 5503 | ||
| 4160 | 5465 | TEST_EQ_P (job, NULL); | 5504 | TEST_EQ_P (job, NULL); |
| 4161 | 5466 | 5505 | ||
| 4162 | @@ -5490,7 +5529,7 @@ | |||
| 4163 | 5490 | TEST_ALLOC_FAIL { | 5529 | TEST_ALLOC_FAIL { |
| 4164 | 5491 | pos = 0; | 5530 | pos = 0; |
| 4165 | 5492 | lineno = 1; | 5531 | lineno = 1; |
| 4167 | 5493 | job = parse_job (NULL, "test", buf, strlen (buf), | 5532 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4168 | 5494 | &pos, &lineno); | 5533 | &pos, &lineno); |
| 4169 | 5495 | 5534 | ||
| 4170 | 5496 | if (test_alloc_failed) { | 5535 | if (test_alloc_failed) { |
| 4171 | @@ -5528,7 +5567,7 @@ | |||
| 4172 | 5528 | TEST_ALLOC_FAIL { | 5567 | TEST_ALLOC_FAIL { |
| 4173 | 5529 | pos = 0; | 5568 | pos = 0; |
| 4174 | 5530 | lineno = 1; | 5569 | lineno = 1; |
| 4176 | 5531 | job = parse_job (NULL, "test", buf, strlen (buf), | 5570 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4177 | 5532 | &pos, &lineno); | 5571 | &pos, &lineno); |
| 4178 | 5533 | 5572 | ||
| 4179 | 5534 | if (test_alloc_failed) { | 5573 | if (test_alloc_failed) { |
| 4180 | @@ -5565,7 +5604,7 @@ | |||
| 4181 | 5565 | 5604 | ||
| 4182 | 5566 | pos = 0; | 5605 | pos = 0; |
| 4183 | 5567 | lineno = 1; | 5606 | lineno = 1; |
| 4185 | 5568 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5607 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4186 | 5569 | 5608 | ||
| 4187 | 5570 | TEST_EQ_P (job, NULL); | 5609 | TEST_EQ_P (job, NULL); |
| 4188 | 5571 | 5610 | ||
| 4189 | @@ -5584,7 +5623,7 @@ | |||
| 4190 | 5584 | 5623 | ||
| 4191 | 5585 | pos = 0; | 5624 | pos = 0; |
| 4192 | 5586 | lineno = 1; | 5625 | lineno = 1; |
| 4194 | 5587 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5626 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4195 | 5588 | 5627 | ||
| 4196 | 5589 | TEST_EQ_P (job, NULL); | 5628 | TEST_EQ_P (job, NULL); |
| 4197 | 5590 | 5629 | ||
| 4198 | @@ -5614,7 +5653,7 @@ | |||
| 4199 | 5614 | TEST_ALLOC_FAIL { | 5653 | TEST_ALLOC_FAIL { |
| 4200 | 5615 | pos = 0; | 5654 | pos = 0; |
| 4201 | 5616 | lineno = 1; | 5655 | lineno = 1; |
| 4203 | 5617 | job = parse_job (NULL, "test", buf, strlen (buf), | 5656 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4204 | 5618 | &pos, &lineno); | 5657 | &pos, &lineno); |
| 4205 | 5619 | 5658 | ||
| 4206 | 5620 | if (test_alloc_failed) { | 5659 | if (test_alloc_failed) { |
| 4207 | @@ -5651,7 +5690,7 @@ | |||
| 4208 | 5651 | TEST_ALLOC_FAIL { | 5690 | TEST_ALLOC_FAIL { |
| 4209 | 5652 | pos = 0; | 5691 | pos = 0; |
| 4210 | 5653 | lineno = 1; | 5692 | lineno = 1; |
| 4212 | 5654 | job = parse_job (NULL, "test", buf, strlen (buf), | 5693 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4213 | 5655 | &pos, &lineno); | 5694 | &pos, &lineno); |
| 4214 | 5656 | 5695 | ||
| 4215 | 5657 | if (test_alloc_failed) { | 5696 | if (test_alloc_failed) { |
| 4216 | @@ -5694,7 +5733,7 @@ | |||
| 4217 | 5694 | TEST_ALLOC_FAIL { | 5733 | TEST_ALLOC_FAIL { |
| 4218 | 5695 | pos = 0; | 5734 | pos = 0; |
| 4219 | 5696 | lineno = 1; | 5735 | lineno = 1; |
| 4221 | 5697 | job = parse_job (NULL, "test", buf, strlen (buf), | 5736 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4222 | 5698 | &pos, &lineno); | 5737 | &pos, &lineno); |
| 4223 | 5699 | 5738 | ||
| 4224 | 5700 | if (test_alloc_failed) { | 5739 | if (test_alloc_failed) { |
| 4225 | @@ -5736,7 +5775,7 @@ | |||
| 4226 | 5736 | 5775 | ||
| 4227 | 5737 | pos = 0; | 5776 | pos = 0; |
| 4228 | 5738 | lineno = 1; | 5777 | lineno = 1; |
| 4230 | 5739 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5778 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4231 | 5740 | 5779 | ||
| 4232 | 5741 | TEST_EQ_P (job, NULL); | 5780 | TEST_EQ_P (job, NULL); |
| 4233 | 5742 | 5781 | ||
| 4234 | @@ -5766,7 +5805,7 @@ | |||
| 4235 | 5766 | TEST_ALLOC_FAIL { | 5805 | TEST_ALLOC_FAIL { |
| 4236 | 5767 | pos = 0; | 5806 | pos = 0; |
| 4237 | 5768 | lineno = 1; | 5807 | lineno = 1; |
| 4239 | 5769 | job = parse_job (NULL, "test", buf, strlen (buf), | 5808 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4240 | 5770 | &pos, &lineno); | 5809 | &pos, &lineno); |
| 4241 | 5771 | 5810 | ||
| 4242 | 5772 | if (test_alloc_failed) { | 5811 | if (test_alloc_failed) { |
| 4243 | @@ -5799,7 +5838,7 @@ | |||
| 4244 | 5799 | TEST_ALLOC_FAIL { | 5838 | TEST_ALLOC_FAIL { |
| 4245 | 5800 | pos = 0; | 5839 | pos = 0; |
| 4246 | 5801 | lineno = 1; | 5840 | lineno = 1; |
| 4248 | 5802 | job = parse_job (NULL, "test", buf, strlen (buf), | 5841 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4249 | 5803 | &pos, &lineno); | 5842 | &pos, &lineno); |
| 4250 | 5804 | 5843 | ||
| 4251 | 5805 | if (test_alloc_failed) { | 5844 | if (test_alloc_failed) { |
| 4252 | @@ -5831,7 +5870,7 @@ | |||
| 4253 | 5831 | 5870 | ||
| 4254 | 5832 | pos = 0; | 5871 | pos = 0; |
| 4255 | 5833 | lineno = 1; | 5872 | lineno = 1; |
| 4257 | 5834 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5873 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4258 | 5835 | 5874 | ||
| 4259 | 5836 | TEST_EQ_P (job, NULL); | 5875 | TEST_EQ_P (job, NULL); |
| 4260 | 5837 | 5876 | ||
| 4261 | @@ -5850,7 +5889,7 @@ | |||
| 4262 | 5850 | 5889 | ||
| 4263 | 5851 | pos = 0; | 5890 | pos = 0; |
| 4264 | 5852 | lineno = 1; | 5891 | lineno = 1; |
| 4266 | 5853 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5892 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4267 | 5854 | 5893 | ||
| 4268 | 5855 | TEST_EQ_P (job, NULL); | 5894 | TEST_EQ_P (job, NULL); |
| 4269 | 5856 | 5895 | ||
| 4270 | @@ -5869,7 +5908,7 @@ | |||
| 4271 | 5869 | 5908 | ||
| 4272 | 5870 | pos = 0; | 5909 | pos = 0; |
| 4273 | 5871 | lineno = 1; | 5910 | lineno = 1; |
| 4275 | 5872 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5911 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4276 | 5873 | 5912 | ||
| 4277 | 5874 | TEST_EQ_P (job, NULL); | 5913 | TEST_EQ_P (job, NULL); |
| 4278 | 5875 | 5914 | ||
| 4279 | @@ -5888,7 +5927,7 @@ | |||
| 4280 | 5888 | 5927 | ||
| 4281 | 5889 | pos = 0; | 5928 | pos = 0; |
| 4282 | 5890 | lineno = 1; | 5929 | lineno = 1; |
| 4284 | 5891 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5930 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4285 | 5892 | 5931 | ||
| 4286 | 5893 | TEST_EQ_P (job, NULL); | 5932 | TEST_EQ_P (job, NULL); |
| 4287 | 5894 | 5933 | ||
| 4288 | @@ -5907,7 +5946,7 @@ | |||
| 4289 | 5907 | 5946 | ||
| 4290 | 5908 | pos = 0; | 5947 | pos = 0; |
| 4291 | 5909 | lineno = 1; | 5948 | lineno = 1; |
| 4293 | 5910 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5949 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4294 | 5911 | 5950 | ||
| 4295 | 5912 | TEST_EQ_P (job, NULL); | 5951 | TEST_EQ_P (job, NULL); |
| 4296 | 5913 | 5952 | ||
| 4297 | @@ -5927,7 +5966,7 @@ | |||
| 4298 | 5927 | 5966 | ||
| 4299 | 5928 | pos = 0; | 5967 | pos = 0; |
| 4300 | 5929 | lineno = 1; | 5968 | lineno = 1; |
| 4302 | 5930 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 5969 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4303 | 5931 | 5970 | ||
| 4304 | 5932 | TEST_EQ_P (job, NULL); | 5971 | TEST_EQ_P (job, NULL); |
| 4305 | 5933 | 5972 | ||
| 4306 | @@ -5957,7 +5996,7 @@ | |||
| 4307 | 5957 | TEST_ALLOC_FAIL { | 5996 | TEST_ALLOC_FAIL { |
| 4308 | 5958 | pos = 0; | 5997 | pos = 0; |
| 4309 | 5959 | lineno = 1; | 5998 | lineno = 1; |
| 4311 | 5960 | job = parse_job (NULL, "test", buf, strlen (buf), | 5999 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4312 | 5961 | &pos, &lineno); | 6000 | &pos, &lineno); |
| 4313 | 5962 | 6001 | ||
| 4314 | 5963 | if (test_alloc_failed) { | 6002 | if (test_alloc_failed) { |
| 4315 | @@ -5990,7 +6029,7 @@ | |||
| 4316 | 5990 | TEST_ALLOC_FAIL { | 6029 | TEST_ALLOC_FAIL { |
| 4317 | 5991 | pos = 0; | 6030 | pos = 0; |
| 4318 | 5992 | lineno = 1; | 6031 | lineno = 1; |
| 4320 | 5993 | job = parse_job (NULL, "test", buf, strlen (buf), | 6032 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4321 | 5994 | &pos, &lineno); | 6033 | &pos, &lineno); |
| 4322 | 5995 | 6034 | ||
| 4323 | 5996 | if (test_alloc_failed) { | 6035 | if (test_alloc_failed) { |
| 4324 | @@ -6023,7 +6062,7 @@ | |||
| 4325 | 6023 | TEST_ALLOC_FAIL { | 6062 | TEST_ALLOC_FAIL { |
| 4326 | 6024 | pos = 0; | 6063 | pos = 0; |
| 4327 | 6025 | lineno = 1; | 6064 | lineno = 1; |
| 4329 | 6026 | job = parse_job (NULL, "test", buf, strlen (buf), | 6065 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4330 | 6027 | &pos, &lineno); | 6066 | &pos, &lineno); |
| 4331 | 6028 | 6067 | ||
| 4332 | 6029 | if (test_alloc_failed) { | 6068 | if (test_alloc_failed) { |
| 4333 | @@ -6055,7 +6094,7 @@ | |||
| 4334 | 6055 | 6094 | ||
| 4335 | 6056 | pos = 0; | 6095 | pos = 0; |
| 4336 | 6057 | lineno = 1; | 6096 | lineno = 1; |
| 4338 | 6058 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6097 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4339 | 6059 | 6098 | ||
| 4340 | 6060 | TEST_EQ_P (job, NULL); | 6099 | TEST_EQ_P (job, NULL); |
| 4341 | 6061 | 6100 | ||
| 4342 | @@ -6074,7 +6113,7 @@ | |||
| 4343 | 6074 | 6113 | ||
| 4344 | 6075 | pos = 0; | 6114 | pos = 0; |
| 4345 | 6076 | lineno = 1; | 6115 | lineno = 1; |
| 4347 | 6077 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6116 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4348 | 6078 | 6117 | ||
| 4349 | 6079 | TEST_EQ_P (job, NULL); | 6118 | TEST_EQ_P (job, NULL); |
| 4350 | 6080 | 6119 | ||
| 4351 | @@ -6093,7 +6132,7 @@ | |||
| 4352 | 6093 | 6132 | ||
| 4353 | 6094 | pos = 0; | 6133 | pos = 0; |
| 4354 | 6095 | lineno = 1; | 6134 | lineno = 1; |
| 4356 | 6096 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6135 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4357 | 6097 | 6136 | ||
| 4358 | 6098 | TEST_EQ_P (job, NULL); | 6137 | TEST_EQ_P (job, NULL); |
| 4359 | 6099 | 6138 | ||
| 4360 | @@ -6112,7 +6151,7 @@ | |||
| 4361 | 6112 | 6151 | ||
| 4362 | 6113 | pos = 0; | 6152 | pos = 0; |
| 4363 | 6114 | lineno = 1; | 6153 | lineno = 1; |
| 4365 | 6115 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6154 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4366 | 6116 | 6155 | ||
| 4367 | 6117 | TEST_EQ_P (job, NULL); | 6156 | TEST_EQ_P (job, NULL); |
| 4368 | 6118 | 6157 | ||
| 4369 | @@ -6131,7 +6170,7 @@ | |||
| 4370 | 6131 | 6170 | ||
| 4371 | 6132 | pos = 0; | 6171 | pos = 0; |
| 4372 | 6133 | lineno = 1; | 6172 | lineno = 1; |
| 4374 | 6134 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6173 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4375 | 6135 | 6174 | ||
| 4376 | 6136 | TEST_EQ_P (job, NULL); | 6175 | TEST_EQ_P (job, NULL); |
| 4377 | 6137 | 6176 | ||
| 4378 | @@ -6150,7 +6189,7 @@ | |||
| 4379 | 6150 | 6189 | ||
| 4380 | 6151 | pos = 0; | 6190 | pos = 0; |
| 4381 | 6152 | lineno = 1; | 6191 | lineno = 1; |
| 4383 | 6153 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6192 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4384 | 6154 | 6193 | ||
| 4385 | 6155 | TEST_EQ_P (job, NULL); | 6194 | TEST_EQ_P (job, NULL); |
| 4386 | 6156 | 6195 | ||
| 4387 | @@ -6180,7 +6219,7 @@ | |||
| 4388 | 6180 | TEST_ALLOC_FAIL { | 6219 | TEST_ALLOC_FAIL { |
| 4389 | 6181 | pos = 0; | 6220 | pos = 0; |
| 4390 | 6182 | lineno = 1; | 6221 | lineno = 1; |
| 4392 | 6183 | job = parse_job (NULL, "test", buf, strlen (buf), | 6222 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4393 | 6184 | &pos, &lineno); | 6223 | &pos, &lineno); |
| 4394 | 6185 | 6224 | ||
| 4395 | 6186 | if (test_alloc_failed) { | 6225 | if (test_alloc_failed) { |
| 4396 | @@ -6213,7 +6252,7 @@ | |||
| 4397 | 6213 | TEST_ALLOC_FAIL { | 6252 | TEST_ALLOC_FAIL { |
| 4398 | 6214 | pos = 0; | 6253 | pos = 0; |
| 4399 | 6215 | lineno = 1; | 6254 | lineno = 1; |
| 4401 | 6216 | job = parse_job (NULL, "test", buf, strlen (buf), | 6255 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4402 | 6217 | &pos, &lineno); | 6256 | &pos, &lineno); |
| 4403 | 6218 | 6257 | ||
| 4404 | 6219 | if (test_alloc_failed) { | 6258 | if (test_alloc_failed) { |
| 4405 | @@ -6246,7 +6285,7 @@ | |||
| 4406 | 6246 | TEST_ALLOC_FAIL { | 6285 | TEST_ALLOC_FAIL { |
| 4407 | 6247 | pos = 0; | 6286 | pos = 0; |
| 4408 | 6248 | lineno = 1; | 6287 | lineno = 1; |
| 4410 | 6249 | job = parse_job (NULL, "test", buf, strlen (buf), | 6288 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4411 | 6250 | &pos, &lineno); | 6289 | &pos, &lineno); |
| 4412 | 6251 | 6290 | ||
| 4413 | 6252 | if (test_alloc_failed) { | 6291 | if (test_alloc_failed) { |
| 4414 | @@ -6279,7 +6318,7 @@ | |||
| 4415 | 6279 | TEST_ALLOC_FAIL { | 6318 | TEST_ALLOC_FAIL { |
| 4416 | 6280 | pos = 0; | 6319 | pos = 0; |
| 4417 | 6281 | lineno = 1; | 6320 | lineno = 1; |
| 4419 | 6282 | job = parse_job (NULL, "test", buf, strlen (buf), | 6321 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4420 | 6283 | &pos, &lineno); | 6322 | &pos, &lineno); |
| 4421 | 6284 | 6323 | ||
| 4422 | 6285 | if (test_alloc_failed) { | 6324 | if (test_alloc_failed) { |
| 4423 | @@ -6311,7 +6350,7 @@ | |||
| 4424 | 6311 | 6350 | ||
| 4425 | 6312 | pos = 0; | 6351 | pos = 0; |
| 4426 | 6313 | lineno = 1; | 6352 | lineno = 1; |
| 4428 | 6314 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6353 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4429 | 6315 | 6354 | ||
| 4430 | 6316 | TEST_EQ_P (job, NULL); | 6355 | TEST_EQ_P (job, NULL); |
| 4431 | 6317 | 6356 | ||
| 4432 | @@ -6330,7 +6369,7 @@ | |||
| 4433 | 6330 | 6369 | ||
| 4434 | 6331 | pos = 0; | 6370 | pos = 0; |
| 4435 | 6332 | lineno = 1; | 6371 | lineno = 1; |
| 4437 | 6333 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6372 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4438 | 6334 | 6373 | ||
| 4439 | 6335 | TEST_EQ_P (job, NULL); | 6374 | TEST_EQ_P (job, NULL); |
| 4440 | 6336 | 6375 | ||
| 4441 | @@ -6349,7 +6388,7 @@ | |||
| 4442 | 6349 | 6388 | ||
| 4443 | 6350 | pos = 0; | 6389 | pos = 0; |
| 4444 | 6351 | lineno = 1; | 6390 | lineno = 1; |
| 4446 | 6352 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6391 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4447 | 6353 | 6392 | ||
| 4448 | 6354 | TEST_EQ_P (job, NULL); | 6393 | TEST_EQ_P (job, NULL); |
| 4449 | 6355 | 6394 | ||
| 4450 | @@ -6368,7 +6407,7 @@ | |||
| 4451 | 6368 | 6407 | ||
| 4452 | 6369 | pos = 0; | 6408 | pos = 0; |
| 4453 | 6370 | lineno = 1; | 6409 | lineno = 1; |
| 4455 | 6371 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6410 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4456 | 6372 | 6411 | ||
| 4457 | 6373 | TEST_EQ_P (job, NULL); | 6412 | TEST_EQ_P (job, NULL); |
| 4458 | 6374 | 6413 | ||
| 4459 | @@ -6387,7 +6426,7 @@ | |||
| 4460 | 6387 | 6426 | ||
| 4461 | 6388 | pos = 0; | 6427 | pos = 0; |
| 4462 | 6389 | lineno = 1; | 6428 | lineno = 1; |
| 4464 | 6390 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6429 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4465 | 6391 | 6430 | ||
| 4466 | 6392 | TEST_EQ_P (job, NULL); | 6431 | TEST_EQ_P (job, NULL); |
| 4467 | 6393 | 6432 | ||
| 4468 | @@ -6406,7 +6445,7 @@ | |||
| 4469 | 6406 | 6445 | ||
| 4470 | 6407 | pos = 0; | 6446 | pos = 0; |
| 4471 | 6408 | lineno = 1; | 6447 | lineno = 1; |
| 4473 | 6409 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 6448 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4474 | 6410 | 6449 | ||
| 4475 | 6411 | TEST_EQ_P (job, NULL); | 6450 | TEST_EQ_P (job, NULL); |
| 4476 | 6412 | 6451 | ||
| 4477 | @@ -6435,7 +6474,7 @@ | |||
| 4478 | 6435 | TEST_ALLOC_FAIL { | 6474 | TEST_ALLOC_FAIL { |
| 4479 | 6436 | pos = 0; | 6475 | pos = 0; |
| 4480 | 6437 | lineno = 1; | 6476 | lineno = 1; |
| 4482 | 6438 | job = parse_job (NULL, "test", buf, strlen (buf), | 6477 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4483 | 6439 | &pos, &lineno); | 6478 | &pos, &lineno); |
| 4484 | 6440 | 6479 | ||
| 4485 | 6441 | if (test_alloc_failed) { | 6480 | if (test_alloc_failed) { |
| 4486 | @@ -6469,7 +6508,7 @@ | |||
| 4487 | 6469 | TEST_ALLOC_FAIL { | 6508 | TEST_ALLOC_FAIL { |
| 4488 | 6470 | pos = 0; | 6509 | pos = 0; |
| 4489 | 6471 | lineno = 1; | 6510 | lineno = 1; |
| 4491 | 6472 | job = parse_job (NULL, "test", buf, strlen (buf), | 6511 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4492 | 6473 | &pos, &lineno); | 6512 | &pos, &lineno); |
| 4493 | 6474 | 6513 | ||
| 4494 | 6475 | if (test_alloc_failed) { | 6514 | if (test_alloc_failed) { |
| 4495 | @@ -6503,7 +6542,7 @@ | |||
| 4496 | 6503 | TEST_ALLOC_FAIL { | 6542 | TEST_ALLOC_FAIL { |
| 4497 | 6504 | pos = 0; | 6543 | pos = 0; |
| 4498 | 6505 | lineno = 1; | 6544 | lineno = 1; |
| 4500 | 6506 | job = parse_job (NULL, "test", buf, strlen (buf), | 6545 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4501 | 6507 | &pos, &lineno); | 6546 | &pos, &lineno); |
| 4502 | 6508 | 6547 | ||
| 4503 | 6509 | if (test_alloc_failed) { | 6548 | if (test_alloc_failed) { |
| 4504 | @@ -6537,7 +6576,7 @@ | |||
| 4505 | 6537 | TEST_ALLOC_FAIL { | 6576 | TEST_ALLOC_FAIL { |
| 4506 | 6538 | pos = 0; | 6577 | pos = 0; |
| 4507 | 6539 | lineno = 1; | 6578 | lineno = 1; |
| 4509 | 6540 | job = parse_job (NULL, "test", buf, strlen (buf), | 6579 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4510 | 6541 | &pos, &lineno); | 6580 | &pos, &lineno); |
| 4511 | 6542 | 6581 | ||
| 4512 | 6543 | if (test_alloc_failed) { | 6582 | if (test_alloc_failed) { |
| 4513 | @@ -6571,7 +6610,7 @@ | |||
| 4514 | 6571 | TEST_ALLOC_FAIL { | 6610 | TEST_ALLOC_FAIL { |
| 4515 | 6572 | pos = 0; | 6611 | pos = 0; |
| 4516 | 6573 | lineno = 1; | 6612 | lineno = 1; |
| 4518 | 6574 | job = parse_job (NULL, "test", buf, strlen (buf), | 6613 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4519 | 6575 | &pos, &lineno); | 6614 | &pos, &lineno); |
| 4520 | 6576 | 6615 | ||
| 4521 | 6577 | if (test_alloc_failed) { | 6616 | if (test_alloc_failed) { |
| 4522 | @@ -6606,7 +6645,7 @@ | |||
| 4523 | 6606 | TEST_ALLOC_FAIL { | 6645 | TEST_ALLOC_FAIL { |
| 4524 | 6607 | pos = 0; | 6646 | pos = 0; |
| 4525 | 6608 | lineno = 1; | 6647 | lineno = 1; |
| 4527 | 6609 | job = parse_job (NULL, "test", buf, strlen (buf), | 6648 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4528 | 6610 | &pos, &lineno); | 6649 | &pos, &lineno); |
| 4529 | 6611 | 6650 | ||
| 4530 | 6612 | if (test_alloc_failed) { | 6651 | if (test_alloc_failed) { |
| 4531 | @@ -6641,7 +6680,7 @@ | |||
| 4532 | 6641 | TEST_ALLOC_FAIL { | 6680 | TEST_ALLOC_FAIL { |
| 4533 | 6642 | pos = 0; | 6681 | pos = 0; |
| 4534 | 6643 | lineno = 1; | 6682 | lineno = 1; |
| 4536 | 6644 | job = parse_job (NULL, "test", buf, strlen (buf), | 6683 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4537 | 6645 | &pos, &lineno); | 6684 | &pos, &lineno); |
| 4538 | 6646 | 6685 | ||
| 4539 | 6647 | if (test_alloc_failed) { | 6686 | if (test_alloc_failed) { |
| 4540 | @@ -6675,7 +6714,7 @@ | |||
| 4541 | 6675 | TEST_ALLOC_FAIL { | 6714 | TEST_ALLOC_FAIL { |
| 4542 | 6676 | pos = 0; | 6715 | pos = 0; |
| 4543 | 6677 | lineno = 1; | 6716 | lineno = 1; |
| 4545 | 6678 | job = parse_job (NULL, "test", buf, strlen (buf), | 6717 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4546 | 6679 | &pos, &lineno); | 6718 | &pos, &lineno); |
| 4547 | 6680 | 6719 | ||
| 4548 | 6681 | if (test_alloc_failed) { | 6720 | if (test_alloc_failed) { |
| 4549 | @@ -6710,7 +6749,7 @@ | |||
| 4550 | 6710 | TEST_ALLOC_FAIL { | 6749 | TEST_ALLOC_FAIL { |
| 4551 | 6711 | pos = 0; | 6750 | pos = 0; |
| 4552 | 6712 | lineno = 1; | 6751 | lineno = 1; |
| 4554 | 6713 | job = parse_job (NULL, "test", buf, strlen (buf), | 6752 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4555 | 6714 | &pos, &lineno); | 6753 | &pos, &lineno); |
| 4556 | 6715 | 6754 | ||
| 4557 | 6716 | if (test_alloc_failed) { | 6755 | if (test_alloc_failed) { |
| 4558 | @@ -6744,7 +6783,7 @@ | |||
| 4559 | 6744 | TEST_ALLOC_FAIL { | 6783 | TEST_ALLOC_FAIL { |
| 4560 | 6745 | pos = 0; | 6784 | pos = 0; |
| 4561 | 6746 | lineno = 1; | 6785 | lineno = 1; |
| 4563 | 6747 | job = parse_job (NULL, "test", buf, strlen (buf), | 6786 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4564 | 6748 | &pos, &lineno); | 6787 | &pos, &lineno); |
| 4565 | 6749 | 6788 | ||
| 4566 | 6750 | if (test_alloc_failed) { | 6789 | if (test_alloc_failed) { |
| 4567 | @@ -6778,7 +6817,7 @@ | |||
| 4568 | 6778 | TEST_ALLOC_FAIL { | 6817 | TEST_ALLOC_FAIL { |
| 4569 | 6779 | pos = 0; | 6818 | pos = 0; |
| 4570 | 6780 | lineno = 1; | 6819 | lineno = 1; |
| 4572 | 6781 | job = parse_job (NULL, "test", buf, strlen (buf), | 6820 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4573 | 6782 | &pos, &lineno); | 6821 | &pos, &lineno); |
| 4574 | 6783 | 6822 | ||
| 4575 | 6784 | if (test_alloc_failed) { | 6823 | if (test_alloc_failed) { |
| 4576 | @@ -6812,7 +6851,7 @@ | |||
| 4577 | 6812 | TEST_ALLOC_FAIL { | 6851 | TEST_ALLOC_FAIL { |
| 4578 | 6813 | pos = 0; | 6852 | pos = 0; |
| 4579 | 6814 | lineno = 1; | 6853 | lineno = 1; |
| 4581 | 6815 | job = parse_job (NULL, "test", buf, strlen (buf), | 6854 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4582 | 6816 | &pos, &lineno); | 6855 | &pos, &lineno); |
| 4583 | 6817 | 6856 | ||
| 4584 | 6818 | if (test_alloc_failed) { | 6857 | if (test_alloc_failed) { |
| 4585 | @@ -6847,7 +6886,7 @@ | |||
| 4586 | 6847 | TEST_ALLOC_FAIL { | 6886 | TEST_ALLOC_FAIL { |
| 4587 | 6848 | pos = 0; | 6887 | pos = 0; |
| 4588 | 6849 | lineno = 1; | 6888 | lineno = 1; |
| 4590 | 6850 | job = parse_job (NULL, "test", buf, strlen (buf), | 6889 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4591 | 6851 | &pos, &lineno); | 6890 | &pos, &lineno); |
| 4592 | 6852 | 6891 | ||
| 4593 | 6853 | if (test_alloc_failed) { | 6892 | if (test_alloc_failed) { |
| 4594 | @@ -6881,7 +6920,7 @@ | |||
| 4595 | 6881 | TEST_ALLOC_FAIL { | 6920 | TEST_ALLOC_FAIL { |
| 4596 | 6882 | pos = 0; | 6921 | pos = 0; |
| 4597 | 6883 | lineno = 1; | 6922 | lineno = 1; |
| 4599 | 6884 | job = parse_job (NULL, "test", buf, strlen (buf), | 6923 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4600 | 6885 | &pos, &lineno); | 6924 | &pos, &lineno); |
| 4601 | 6886 | 6925 | ||
| 4602 | 6887 | if (test_alloc_failed) { | 6926 | if (test_alloc_failed) { |
| 4603 | @@ -6917,7 +6956,7 @@ | |||
| 4604 | 6917 | TEST_ALLOC_FAIL { | 6956 | TEST_ALLOC_FAIL { |
| 4605 | 6918 | pos = 0; | 6957 | pos = 0; |
| 4606 | 6919 | lineno = 1; | 6958 | lineno = 1; |
| 4608 | 6920 | job = parse_job (NULL, "test", buf, strlen (buf), | 6959 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4609 | 6921 | &pos, &lineno); | 6960 | &pos, &lineno); |
| 4610 | 6922 | 6961 | ||
| 4611 | 6923 | if (test_alloc_failed) { | 6962 | if (test_alloc_failed) { |
| 4612 | @@ -6956,7 +6995,7 @@ | |||
| 4613 | 6956 | TEST_ALLOC_FAIL { | 6995 | TEST_ALLOC_FAIL { |
| 4614 | 6957 | pos = 0; | 6996 | pos = 0; |
| 4615 | 6958 | lineno = 1; | 6997 | lineno = 1; |
| 4617 | 6959 | job = parse_job (NULL, "test", buf, strlen (buf), | 6998 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4618 | 6960 | &pos, &lineno); | 6999 | &pos, &lineno); |
| 4619 | 6961 | 7000 | ||
| 4620 | 6962 | if (test_alloc_failed) { | 7001 | if (test_alloc_failed) { |
| 4621 | @@ -6991,7 +7030,7 @@ | |||
| 4622 | 6991 | TEST_ALLOC_FAIL { | 7030 | TEST_ALLOC_FAIL { |
| 4623 | 6992 | pos = 0; | 7031 | pos = 0; |
| 4624 | 6993 | lineno = 1; | 7032 | lineno = 1; |
| 4626 | 6994 | job = parse_job (NULL, "test", buf, strlen (buf), | 7033 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4627 | 6995 | &pos, &lineno); | 7034 | &pos, &lineno); |
| 4628 | 6996 | 7035 | ||
| 4629 | 6997 | if (test_alloc_failed) { | 7036 | if (test_alloc_failed) { |
| 4630 | @@ -7026,7 +7065,7 @@ | |||
| 4631 | 7026 | TEST_ALLOC_FAIL { | 7065 | TEST_ALLOC_FAIL { |
| 4632 | 7027 | pos = 0; | 7066 | pos = 0; |
| 4633 | 7028 | lineno = 1; | 7067 | lineno = 1; |
| 4635 | 7029 | job = parse_job (NULL, "test", buf, strlen (buf), | 7068 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4636 | 7030 | &pos, &lineno); | 7069 | &pos, &lineno); |
| 4637 | 7031 | 7070 | ||
| 4638 | 7032 | if (test_alloc_failed) { | 7071 | if (test_alloc_failed) { |
| 4639 | @@ -7060,7 +7099,7 @@ | |||
| 4640 | 7060 | 7099 | ||
| 4641 | 7061 | pos = 0; | 7100 | pos = 0; |
| 4642 | 7062 | lineno = 1; | 7101 | lineno = 1; |
| 4644 | 7063 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7102 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4645 | 7064 | 7103 | ||
| 4646 | 7065 | TEST_EQ_P (job, NULL); | 7104 | TEST_EQ_P (job, NULL); |
| 4647 | 7066 | 7105 | ||
| 4648 | @@ -7079,7 +7118,7 @@ | |||
| 4649 | 7079 | 7118 | ||
| 4650 | 7080 | pos = 0; | 7119 | pos = 0; |
| 4651 | 7081 | lineno = 1; | 7120 | lineno = 1; |
| 4653 | 7082 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7121 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4654 | 7083 | 7122 | ||
| 4655 | 7084 | TEST_EQ_P (job, NULL); | 7123 | TEST_EQ_P (job, NULL); |
| 4656 | 7085 | 7124 | ||
| 4657 | @@ -7098,7 +7137,7 @@ | |||
| 4658 | 7098 | 7137 | ||
| 4659 | 7099 | pos = 0; | 7138 | pos = 0; |
| 4660 | 7100 | lineno = 1; | 7139 | lineno = 1; |
| 4662 | 7101 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7140 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4663 | 7102 | 7141 | ||
| 4664 | 7103 | TEST_EQ_P (job, NULL); | 7142 | TEST_EQ_P (job, NULL); |
| 4665 | 7104 | 7143 | ||
| 4666 | @@ -7117,7 +7156,7 @@ | |||
| 4667 | 7117 | 7156 | ||
| 4668 | 7118 | pos = 0; | 7157 | pos = 0; |
| 4669 | 7119 | lineno = 1; | 7158 | lineno = 1; |
| 4671 | 7120 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7159 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4672 | 7121 | 7160 | ||
| 4673 | 7122 | TEST_EQ_P (job, NULL); | 7161 | TEST_EQ_P (job, NULL); |
| 4674 | 7123 | 7162 | ||
| 4675 | @@ -7136,7 +7175,7 @@ | |||
| 4676 | 7136 | 7175 | ||
| 4677 | 7137 | pos = 0; | 7176 | pos = 0; |
| 4678 | 7138 | lineno = 1; | 7177 | lineno = 1; |
| 4680 | 7139 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7178 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4681 | 7140 | 7179 | ||
| 4682 | 7141 | TEST_EQ_P (job, NULL); | 7180 | TEST_EQ_P (job, NULL); |
| 4683 | 7142 | 7181 | ||
| 4684 | @@ -7155,7 +7194,7 @@ | |||
| 4685 | 7155 | 7194 | ||
| 4686 | 7156 | pos = 0; | 7195 | pos = 0; |
| 4687 | 7157 | lineno = 1; | 7196 | lineno = 1; |
| 4689 | 7158 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7197 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4690 | 7159 | 7198 | ||
| 4691 | 7160 | TEST_EQ_P (job, NULL); | 7199 | TEST_EQ_P (job, NULL); |
| 4692 | 7161 | 7200 | ||
| 4693 | @@ -7174,7 +7213,7 @@ | |||
| 4694 | 7174 | 7213 | ||
| 4695 | 7175 | pos = 0; | 7214 | pos = 0; |
| 4696 | 7176 | lineno = 1; | 7215 | lineno = 1; |
| 4698 | 7177 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7216 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4699 | 7178 | 7217 | ||
| 4700 | 7179 | TEST_EQ_P (job, NULL); | 7218 | TEST_EQ_P (job, NULL); |
| 4701 | 7180 | 7219 | ||
| 4702 | @@ -7193,7 +7232,7 @@ | |||
| 4703 | 7193 | 7232 | ||
| 4704 | 7194 | pos = 0; | 7233 | pos = 0; |
| 4705 | 7195 | lineno = 1; | 7234 | lineno = 1; |
| 4707 | 7196 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7235 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4708 | 7197 | 7236 | ||
| 4709 | 7198 | TEST_EQ_P (job, NULL); | 7237 | TEST_EQ_P (job, NULL); |
| 4710 | 7199 | 7238 | ||
| 4711 | @@ -7212,7 +7251,7 @@ | |||
| 4712 | 7212 | 7251 | ||
| 4713 | 7213 | pos = 0; | 7252 | pos = 0; |
| 4714 | 7214 | lineno = 1; | 7253 | lineno = 1; |
| 4716 | 7215 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7254 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4717 | 7216 | 7255 | ||
| 4718 | 7217 | TEST_EQ_P (job, NULL); | 7256 | TEST_EQ_P (job, NULL); |
| 4719 | 7218 | 7257 | ||
| 4720 | @@ -7231,7 +7270,7 @@ | |||
| 4721 | 7231 | 7270 | ||
| 4722 | 7232 | pos = 0; | 7271 | pos = 0; |
| 4723 | 7233 | lineno = 1; | 7272 | lineno = 1; |
| 4725 | 7234 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7273 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4726 | 7235 | 7274 | ||
| 4727 | 7236 | TEST_EQ_P (job, NULL); | 7275 | TEST_EQ_P (job, NULL); |
| 4728 | 7237 | 7276 | ||
| 4729 | @@ -7250,7 +7289,7 @@ | |||
| 4730 | 7250 | 7289 | ||
| 4731 | 7251 | pos = 0; | 7290 | pos = 0; |
| 4732 | 7252 | lineno = 1; | 7291 | lineno = 1; |
| 4734 | 7253 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7292 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4735 | 7254 | 7293 | ||
| 4736 | 7255 | TEST_EQ_P (job, NULL); | 7294 | TEST_EQ_P (job, NULL); |
| 4737 | 7256 | 7295 | ||
| 4738 | @@ -7280,7 +7319,7 @@ | |||
| 4739 | 7280 | TEST_ALLOC_FAIL { | 7319 | TEST_ALLOC_FAIL { |
| 4740 | 7281 | pos = 0; | 7320 | pos = 0; |
| 4741 | 7282 | lineno = 1; | 7321 | lineno = 1; |
| 4743 | 7283 | job = parse_job (NULL, "test", buf, strlen (buf), | 7322 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4744 | 7284 | &pos, &lineno); | 7323 | &pos, &lineno); |
| 4745 | 7285 | 7324 | ||
| 4746 | 7286 | if (test_alloc_failed) { | 7325 | if (test_alloc_failed) { |
| 4747 | @@ -7314,7 +7353,7 @@ | |||
| 4748 | 7314 | TEST_ALLOC_FAIL { | 7353 | TEST_ALLOC_FAIL { |
| 4749 | 7315 | pos = 0; | 7354 | pos = 0; |
| 4750 | 7316 | lineno = 1; | 7355 | lineno = 1; |
| 4752 | 7317 | job = parse_job (NULL, "test", buf, strlen (buf), | 7356 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4753 | 7318 | &pos, &lineno); | 7357 | &pos, &lineno); |
| 4754 | 7319 | 7358 | ||
| 4755 | 7320 | if (test_alloc_failed) { | 7359 | if (test_alloc_failed) { |
| 4756 | @@ -7347,7 +7386,7 @@ | |||
| 4757 | 7347 | 7386 | ||
| 4758 | 7348 | pos = 0; | 7387 | pos = 0; |
| 4759 | 7349 | lineno = 1; | 7388 | lineno = 1; |
| 4761 | 7350 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7389 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4762 | 7351 | 7390 | ||
| 4763 | 7352 | TEST_EQ_P (job, NULL); | 7391 | TEST_EQ_P (job, NULL); |
| 4764 | 7353 | 7392 | ||
| 4765 | @@ -7366,7 +7405,7 @@ | |||
| 4766 | 7366 | 7405 | ||
| 4767 | 7367 | pos = 0; | 7406 | pos = 0; |
| 4768 | 7368 | lineno = 1; | 7407 | lineno = 1; |
| 4770 | 7369 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7408 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4771 | 7370 | 7409 | ||
| 4772 | 7371 | TEST_EQ_P (job, NULL); | 7410 | TEST_EQ_P (job, NULL); |
| 4773 | 7372 | 7411 | ||
| 4774 | @@ -7396,7 +7435,7 @@ | |||
| 4775 | 7396 | TEST_ALLOC_FAIL { | 7435 | TEST_ALLOC_FAIL { |
| 4776 | 7397 | pos = 0; | 7436 | pos = 0; |
| 4777 | 7398 | lineno = 1; | 7437 | lineno = 1; |
| 4779 | 7399 | job = parse_job (NULL, "test", buf, strlen (buf), | 7438 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4780 | 7400 | &pos, &lineno); | 7439 | &pos, &lineno); |
| 4781 | 7401 | 7440 | ||
| 4782 | 7402 | if (test_alloc_failed) { | 7441 | if (test_alloc_failed) { |
| 4783 | @@ -7430,7 +7469,7 @@ | |||
| 4784 | 7430 | TEST_ALLOC_FAIL { | 7469 | TEST_ALLOC_FAIL { |
| 4785 | 7431 | pos = 0; | 7470 | pos = 0; |
| 4786 | 7432 | lineno = 1; | 7471 | lineno = 1; |
| 4788 | 7433 | job = parse_job (NULL, "test", buf, strlen (buf), | 7472 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), |
| 4789 | 7434 | &pos, &lineno); | 7473 | &pos, &lineno); |
| 4790 | 7435 | 7474 | ||
| 4791 | 7436 | if (test_alloc_failed) { | 7475 | if (test_alloc_failed) { |
| 4792 | @@ -7463,7 +7502,7 @@ | |||
| 4793 | 7463 | 7502 | ||
| 4794 | 7464 | pos = 0; | 7503 | pos = 0; |
| 4795 | 7465 | lineno = 1; | 7504 | lineno = 1; |
| 4797 | 7466 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7505 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4798 | 7467 | 7506 | ||
| 4799 | 7468 | TEST_EQ_P (job, NULL); | 7507 | TEST_EQ_P (job, NULL); |
| 4800 | 7469 | 7508 | ||
| 4801 | @@ -7482,7 +7521,7 @@ | |||
| 4802 | 7482 | 7521 | ||
| 4803 | 7483 | pos = 0; | 7522 | pos = 0; |
| 4804 | 7484 | lineno = 1; | 7523 | lineno = 1; |
| 4806 | 7485 | job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno); | 7524 | job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno); |
| 4807 | 7486 | 7525 | ||
| 4808 | 7487 | TEST_EQ_P (job, NULL); | 7526 | TEST_EQ_P (job, NULL); |
| 4809 | 7488 | 7527 | ||
| 4810 | 7489 | 7528 | ||
| 4811 | === modified file 'util/man/initctl.8' | |||
| 4812 | --- util/man/initctl.8 2010-02-04 19:08:07 +0000 | |||
| 4813 | +++ util/man/initctl.8 2011-01-21 11:55:09 +0000 | |||
| 4814 | @@ -1,4 +1,4 @@ | |||
| 4816 | 1 | .TH initctl 8 2010-02-04 "Upstart" | 1 | .TH initctl 8 2011-01-12 "Upstart" |
| 4817 | 2 | .\" | 2 | .\" |
| 4818 | 3 | .SH NAME | 3 | .SH NAME |
| 4819 | 4 | initctl \- init daemon control tool | 4 | initctl \- init daemon control tool |
| 4820 | @@ -157,8 +157,8 @@ | |||
| 4821 | 157 | 157 | ||
| 4822 | 158 | Requests that an instance of the named | 158 | Requests that an instance of the named |
| 4823 | 159 | .I JOB | 159 | .I JOB |
| 4826 | 160 | be restarted, outputting the status of the job to standard output when the | 160 | be restarted (stopped and then started), outputting the status of the |
| 4827 | 161 | command completes. | 161 | job to standard output when the command completes. |
| 4828 | 162 | 162 | ||
| 4829 | 163 | See | 163 | See |
| 4830 | 164 | .B status | 164 | .B status |
| 4831 | @@ -249,10 +249,14 @@ | |||
| 4832 | 249 | .\" | 249 | .\" |
| 4833 | 250 | .TP | 250 | .TP |
| 4834 | 251 | .B list | 251 | .B list |
| 4835 | 252 | |||
| 4836 | 253 | Requests a list of the known jobs and instances, outputs the status of | 252 | Requests a list of the known jobs and instances, outputs the status of |
| 4837 | 254 | each to standard output. | 253 | each to standard output. |
| 4838 | 255 | 254 | ||
| 4839 | 255 | Note that this command enumerates as-yet-to-run jobs (in other words | ||
| 4840 | 256 | configuration files for which no job instances have yet been created) in | ||
| 4841 | 257 | the output with status "stop/waiting". In effect such entries denote | ||
| 4842 | 258 | configuration files which represent potential future jobs. | ||
| 4843 | 259 | |||
| 4844 | 256 | See | 260 | See |
| 4845 | 257 | .B status | 261 | .B status |
| 4846 | 258 | for a description of the output format and | 262 | for a description of the output format and |
This is a first-pass review only.
- There are a few minor manpage updates and typo fixes that aren't
directly related to this branch, could you separate those out (ask
Colin about bzr interactive :p) and submit separately.
- That init/main.c hack is horrible :-) What did __attribute__
((unused)) do to you to make you spurn it so? ;-)
- init/parse_conf.c - this assert seems unrelated to override
support? Can you commit it separately?
- init/parse_job.c - is:
if (!update)
nih_free (class);
return NULL;
better style? discuss
stanza_manual - I couldn't work out the reason for this change, the
previous code was clearer I think
- init/conf.c
extension defines should maybe go in paths.h?
toggle_conf_name by style needs to accept a parent as the first
argument and pass to nih_strndup
conf_reload - removed the ENOENT guard, why?
conf_source_* - seems to have tab damage? the indentation changes
(and even style change!) make this diff quite hard to review
Are there debug functions used anywhere? Or are they for gdb?
Scott
On Wed, Jan 12, 2011 at 4:28 AM, James Hunt <email address hidden> wrote:
> James Hunt has proposed merging lp:~jamesodhunt/upstart/override-support into lp:upstart.
>
> Requested reviews:
> Scott James Remnant (scott)
>
> For more details, see:
> https:/
>
> Implemented override feature on blueprint:
>
> https:/
>
> Details:
>
> * Generic
> - fixed typos.
> - addition of debug functions useful for gdb sessions (available
> only in DEBUG build).
> * init/conf.c:
> - (toggle_conf_name): New function which convert a conf file
> name to an override name and vice versa.
> - (conf_reload): Removed ENOENT check to ensure error thrown if
> conf files/dirs do not exist.
> - (conf_reload_path): Now takes an extra override_path parameter.
> - (is_conf_
> functions to determine type of given file path.
> - majority of remaining functions updated to handle override
> files.
> * init/man/init.5: Updated to document override file support.
> * init/man/init.8: Added reference to control-
> * init/parse_conf.c: Added assertion to remind us forcibly to add
> override-handling code for directories if we ever allow content in
> 'init.conf'.
> * init/parse_job.c (parse_job): Additional parameter 'update' to
> allow override files to replace existing Job details.
> * init/test_conf.c
> - test_override(): New function.
> - test_toggle_
> * init/test_
> - Updated for extra parse_job() parameter
> - added a test feature to test_parse_job() to exercise new
> parameter to parse_job().
> * util/man/initctl.8: Clarified what it means to restart a job.
>
> To test:
>
> make check
> --
> https:/
> You are requested to review the proposed merge of lp:~jamesodhunt/ups...