upstart

Merge lp://qastaging/~cjdahlin/upstart/n-ary-event-oper into lp://qastaging/~canonical-scott/upstart/trunk

n-ary-event-oper
Merge into trunk

Proposed by Casey Dahlin on 2009-08-11

Status:	Needs review
Proposed branch:	lp://qastaging/~cjdahlin/upstart/n-ary-event-oper
Merge into:	lp://qastaging/~canonical-scott/upstart/trunk
Diff against target:	None lines
To merge this branch:	bzr merge lp://qastaging/~cjdahlin/upstart/n-ary-event-oper
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Scott James Remnant (Canonical)		2009-08-11	Needs Fixing on 2009-08-12
Review via email: mp+9968@code.qastaging.launchpad.net

Revision history for this message

Casey Dahlin (cjdahlin) wrote on 2009-08-11:

This makes EventOperators N-ary rather than binary trees. It auto-optimizes them with a new event_operator_add_child helper that simply gifts all of the new child's children to the new parent rather than attaching it when the new parent and child are of the same type.

This makes it a bit easier to make qualitative statements about trees, particularly "this tree only contains OR operators," which should become useful as AND operators become deprecated in future state models.

Revision history for this message

Scott James Remnant (Canonical) (canonical-scott) wrote on 2009-08-11:

Hi Casey,

Could you send this in the form of a patch to the upstart-devel ML?

review: Abstain

Revision history for this message

Scott James Remnant (Canonical) (canonical-scott) on 2009-08-11:

review: Needs Fixing

Revision history for this message

Scott James Remnant (Canonical) (canonical-scott) wrote on 2009-08-12:

Review comments on ML
https://lists.ubuntu.com/archives/upstart-devel/2009-August/001046.html

review: Needs Fixing

Revision history for this message

Scott James Remnant (Canonical) (canonical-scott) wrote on 2009-08-12:

Download full text (21.7 KiB)

On Tue, 2009-08-11 at 17:33 -0400, Casey Dahlin wrote:

> This makes EventOperators N-ary rather than binary trees. It
> auto-optimizes them with a new event_operator_add_child helper that
> simply gifts all of the new child's children to the new parent rather
> than attaching it when the new parent and child are of the same type.
>
> This makes it a bit easier to make qualitative statements about trees,
> particularly "this tree only contains OR operators," which should become
> useful as AND operators become deprecated in future state models.
>
Thanks Casey.

Could you explain a little bit more about the rationale behind these
changes? Right now this just looks like a different way of constructing
the operator trees, and unless I'm mistaken, it's more expensive to
build them this way, they use more memory per node and they're more
difficult to iterate than the btrees we currently use.

Are you working on something else that requires this? Perhaps it'd help
to outline that work as well to the ML.

One thing I'd like to ask about - I don't have any plans to deprecate
AND operators; could you tell us a little bit about your plans in this
regard?

>
> === modified file 'ChangeLog'
> --- ChangeLog 2009-08-04 08:51:25 +0000
> +++ ChangeLog 2009-08-11 05:51:31 +0000
> @@ -1,3 +1,60 @@
> +2009-08-11 Casey Dahlin <email address hidden>
> +
> + * init/event_operator.h (EventOperatorType): Change types from AND/OR to
> + ANY/ALL
> +
> + (EventOperator): Get rid of node entry and add children list.
> +
> + * init/event_operator.c (event_operator_subtree_environment): New
> + version of event_operator_environment that assumes we are not at the
> + root of the tree.
> +
> + (event_operator_new): Initialize new children member instead of tree
> + node.
> +
> + (event_operator_copy): Use recursive call to correctly copy N-ary tree
> +
> + (event_operator_reset): Use recursive call to correctly reset N-ary tree
> +
> + (event_operator_events): Use recursive call to correctly get events from
> + N-ary tree.
> +
> + (event_operator_handle): Use recursive call to correctly handle N-ary
> + tree.
> +
> + (event_operator_update): Update based on all N children
> +
> + (event_operator_match): Don't assert based on now-defunct node
> +
> + (event_operator_add_child): New helper to add a child to a tree,
> + automatically collapsing it into its new parent if it is the same type.
> +
> + (event_operator_destroy): Destroy children list head correctly.
> +
> + (event_operator_environment): Use new event_operator_subtree_environment
> + to recursively collect environment variables.
> +
> + * init/parse_job.c (parse_on_operator): Change AND/OR to ANY/ALL. Change
> + tree adds to event_operator_add_child calls.
> +
> + (parse_on_collect): Change tree adds to event_operator_add_child calls
> +
> + * init/tests/test_event.c (test_pending_handle_jobs): Fix structural
> + assumptions about EventOperator.
> +
> + (test_finish): Change AND/OR to ANY/ALL
> +
> + * init/tests/test_event_operator.c (everywhere): Fix structural
> + assumptions about EventOperator.
> +
> + (test_operator_add_child): New test for this new helper.
> +
> + * init/tests/test_job_process.c (...

On Tue, 2009-08-11 at 17:33 -0400, Casey Dahlin wrote:

> This makes EventOperators N-ary rather than binary trees. It 
> auto-optimizes them with a new event_operator_add_child helper that 
> simply gifts all of the new child's children to the new parent rather 
> than attaching it when the new parent and child are of the same type.
> 
> This makes it a bit easier to make qualitative statements about trees, 
> particularly "this tree only contains OR operators," which should become 
> useful as AND operators become deprecated in future state models.
> 
Thanks Casey.

Could you explain a little bit more about the rationale behind these
changes?  Right now this just looks like a different way of constructing
the operator trees, and unless I'm mistaken, it's more expensive to
build them this way, they use more memory per node and they're more
difficult to iterate than the btrees we currently use.

Are you working on something else that requires this?  Perhaps it'd help
to outline that work as well to the ML.

One thing I'd like to ask about - I don't have any plans to deprecate
AND operators; could you tell us a little bit about your plans in this
regard?

> 
> === modified file 'ChangeLog'
> --- ChangeLog	2009-08-04 08:51:25 +0000
> +++ ChangeLog	2009-08-11 05:51:31 +0000
> @@ -1,3 +1,60 @@
> +2009-08-11  Casey Dahlin  <cdahlin@redhat.com>
> +
> +	* init/event_operator.h (EventOperatorType): Change types from AND/OR to
> +	ANY/ALL
> +
> +	(EventOperator): Get rid of node entry and add children list.
> +
> +	* init/event_operator.c (event_operator_subtree_environment): New
> +	version of event_operator_environment that assumes we are not at the
> +	root of the tree.
> +
> +	(event_operator_new): Initialize new children member instead of tree
> +	node.
> +
> +	(event_operator_copy): Use recursive call to correctly copy N-ary tree
> +
> +	(event_operator_reset): Use recursive call to correctly reset N-ary tree
> +
> +	(event_operator_events): Use recursive call to correctly get events from
> +	N-ary tree.
> +
> +	(event_operator_handle): Use recursive call to correctly handle N-ary
> +	tree.
> +
> +	(event_operator_update): Update based on all N children
> +
> +	(event_operator_match): Don't assert based on now-defunct node
> +
> +	(event_operator_add_child): New helper to add a child to a tree,
> +	automatically collapsing it into its new parent if it is the same type.
> +
> +	(event_operator_destroy): Destroy children list head correctly.
> +
> +	(event_operator_environment): Use new event_operator_subtree_environment
> +	to recursively collect environment variables.
> +
> +	* init/parse_job.c (parse_on_operator): Change AND/OR to ANY/ALL. Change
> +	tree adds to event_operator_add_child calls.
> +
> +	(parse_on_collect): Change tree adds to event_operator_add_child calls
> +
> +	* init/tests/test_event.c (test_pending_handle_jobs): Fix structural
> +	assumptions about EventOperator.
> +
> +	(test_finish): Change AND/OR to ANY/ALL
> +
> +	* init/tests/test_event_operator.c (everywhere): Fix structural
> +	assumptions about EventOperator.
> +
> +	(test_operator_add_child): New test for this new helper.
> +
> +	* init/tests/test_job_process.c (everywhere): Fix structural assumptions
> +	about EventOperator
> +
> +	* init/tests/test_parse_job.c (everywhere): Fix structural assumptions
> +	about EventOperator
> +
>   2009-08-04  Johan Kiviniemi  <johan@kiviniemi.name>
> 
>   	* conf/rc-sysinit.conf: Don't replace DEFAULT_RUNLEVEL with an
>

ChangeLog entries should be grouped together with a blank line only
between individual commits.

Avoid using the 80th column.

> === modified file 'init/event_operator.c'
> --- init/event_operator.c	2009-06-23 09:29:35 +0000
> +++ init/event_operator.c	2009-08-11 05:12:01 +0000
> @@ -43,6 +43,9 @@
>   #include "blocked.h"
>   #include "errors.h"
> 
> +static char** event_operator_subtree_environment
> +		(EventOperator *oper, char ***env, const void *parent,
> +		 size_t *len, const char *key, char **evlist);
> 
>   /**
>    * event_operator_new:

Should be "static char **", should be preceeded by a comment and have
extra blank lines around (see other source files for examples).  The
opening paren, and thus the arguments, should follow even if you have to
indent strangely.

> +	NIH_LIST_FOREACH (&old_oper->children, iter) {
> +		EventOperator *child = event_operator_copy (
> +				       oper, (EventOperator *)iter);
> +		if (! child) {
> +			nih_free (oper);
> +			return NULL;
> +		}
> +
> +		event_operator_add_child (oper, child);
>   	}

Don't use initialisers like this, it's much better style to do:

EventOperator *old_child = (EventOperator *)iter;
	EventOperator *child;

child = event_operator_copy (oper, old_child);
	if (! child) {
		nih_free (oper);
		return NULL;
	}

>   /**
> + * event_operator_add_child:
> + * @oper: oper to add child to,
> + * @child: child to add.
> + *
> + * Makes @child a child of @oper. If @child and @oper are the same 
> type, then
> + * @oper simply steals all of @child's children.
> + **/
> +void
> +event_operator_add_child (EventOperator *oper, EventOperator *child)
> +{
> +	nih_assert (oper != NULL);
> +	nih_assert (child != NULL);
> +	nih_assert (oper->type != EVENT_MATCH);
> +
> +	if (child->type != oper->type) {
> +		nih_ref (child, oper);
> +		nih_list_add (&oper->children, &child->entry);
> +		return;
> +	}
> +
> +	NIH_LIST_FOREACH_SAFE (&child->children, iter) {
> +		EventOperator *grandchild = (EventOperator *)iter;
> +
> +		nih_ref (grandchild, oper);
> +		nih_unref (grandchild, child);
> +		nih_list_add (&oper->children, &grandchild->entry);
> +	}
> +}

Doc string should mention that the child will be referenced by the new
parent.

This seems a bit strange in the adding-the-same-type case; it moves all
the chidren of the old node to the new node, but not the old node
itself?  What happens to the old node, it looks like it just gets left
in the tree?

Why doesn't this function no-op in the adding-the-same-type case, and
discard the new node instead?

> @@ -227,24 +249,17 @@
>   void
>   event_operator_update (EventOperator *oper)
>   {
> -	EventOperator *left, *right;
> -
>   	nih_assert (oper != NULL);
> -	nih_assert (oper->node.left != NULL);
> -	nih_assert (oper->node.right != NULL);
> -
> -	left = (EventOperator *)oper->node.left;
> -	right = (EventOperator *)oper->node.right;
> -
> -	switch (oper->type) {
> -	case EVENT_OR:
> -		oper->value = (left->value || right->value);
> -		break;
> -	case EVENT_AND:
> -		oper->value = (left->value && right->value);
> -		break;
> -	default:
> -		nih_assert_not_reached ();
> +	nih_assert (oper->type != EVENT_MATCH);
> +
> +	oper->value = (oper->type == EVENT_ALL) ? TRUE : FALSE;
> +
> +	NIH_LIST_FOREACH (&oper->children, iter) {
> +		EventOperator *child = (EventOperator *)iter;
> +		if (child->value != oper->value) {
> +			oper->value = child->value;
> +			return;
> +		}
>   	}
>   }
>

Should have a blank line between initialisers and checks.

Probably should have a comment explaining how this works, since it's a
bit "clever" :-)

> @@ -391,29 +404,30 @@
>   	 * before we update the node itself.  Simply iterate the tree and
>   	 * update the nodes.
>   	 */
> -	NIH_TREE_FOREACH_POST (&root->node, iter) {
> +	NIH_LIST_FOREACH (&root->children, iter) {
>   		EventOperator *oper = (EventOperator *)iter;
> 
> -		switch (oper->type) {
> -		case EVENT_OR:
> -		case EVENT_AND:
> -			event_operator_update (oper);
> -			break;
> -		case EVENT_MATCH:
> -			if ((! oper->value)
> -			    && event_operator_match (oper, event, env)) {
> -				oper->value = TRUE;
> -
> -				oper->event = event;
> -				event_block (oper->event);
> -
> -				ret = TRUE;
> -			}
> -			break;
> -		default:
> -			nih_assert_not_reached ();
> +		ret = ret || event_operator_handle (oper, event, env);
> +	}
> +
> +	switch (root->type) {
> +	case EVENT_ANY:
> +	case EVENT_ALL:
> +		event_operator_update (root);
> +		break;
> +	case EVENT_MATCH:
> +		if ((! root->value)
> +		    && event_operator_match (root, event, env)) {
> +			root->value = TRUE;
> +
> +			root->event = event;
> +			event_block (root->event);
> +
> +			ret = TRUE;
>   		}
> -
> +		break;
> +	default:
> +		nih_assert_not_reached ();
>   	}
> 
>   	return ret;

I generally dislike:

ret = ret || ...

forms, instead please be more specific.

Why the change to recursively calling event_operator_handle() where this
wasn't needed before?

Why moving everything from out of the loop acting on oper to inside the
loop acting on root?

You left the comment about this being a post-order traversal, but this
doesn't appear to be an any-kind-of-order traversal anymore?

> @@ -501,38 +515,9 @@
>   			return NULL;
>   	}
> 
> -	/* Iterate the operator tree, filtering out nodes with a non-TRUE
> -	 * value and their children.  The rationale for this is that this
> -	 * then matches only the events that had an active role in starting
> -	 * the job, not the ones that were also blocked, but the other half
> -	 * of their logic wasn't present.
> -	 */
> -	NIH_TREE_FOREACH_FULL (&root->node, iter,
> -			       (NihTreeFilter)event_operator_filter, NULL) {
> -		EventOperator *oper = (EventOperator *)iter;
> -
> -		if (oper->type != EVENT_MATCH)
> -			continue;
> -
> -		nih_assert (oper->event != NULL);
> -
> -		/* Add environment from the event */
> -		if (! environ_append (env, parent, len, TRUE, oper->event->env))
> -			return NULL;
> -
> -		/* Append the name of the event to the string we're building */
> -		if (evlist) {
> -			if (evlist[strlen (evlist) - 1] != '=') {
> -				if (! nih_strcat_sprintf (&evlist, NULL, " %s",
> -							  oper->event->name))
> -					return NULL;
> -			} else {
> -				if (! nih_strcat (&evlist, NULL,
> -						  oper->event->name))
> -					return NULL;
> -			}
> -		}
> -	}
> +	if (! event_operator_subtree_environment (root, env, parent,
> +					          len, key, &evlist))
> +		return NULL;
> 
>   	/* Append the event list to the environment */
>   	if (evlist)
> @@ -543,6 +528,68 @@
>   }
> 
>   /**
> + * event_operator_subtree_environment:
> + * @root: operator tree to collect from,
> + * @env: NULL-terminated array of environment variables to add to,
> + * @parent: parent object for new array,
> + * @len: length of @env,
> + * @key: key of variable to contain event names,
> + * @evlist: string in which to accumulate the event list.
> + *
> + * Does the work of event_operator_environment for one subtree.
> + **/
> +
> +static char**
> +event_operator_subtree_environment (EventOperator   *oper,
> +				    char          ***env,
> +				    const void      *parent,
> +				    size_t          *len,
> +				    const char      *key,
> +				    char           **evlist)
> +{
> +	/* Filtering out nodes with a non-TRUE value and their children. The
> +	 * rationale for this is that this then matches only the events that had
> +	 * an active role in starting the job, not the ones that were also
> +	 * blocked, but the other half of their logic wasn't present.
> +	 */
> +	if (! oper->value)
> +		return *env;
> +
> +	if (oper->type != EVENT_MATCH) {
> +		NIH_LIST_FOREACH(&oper->children, iter) {
> +			EventOperator *child = (EventOperator *)iter;
> +			if (! event_operator_subtree_environment (child, env, parent,
> +							          len, key, evlist))
> +				return NULL;
> +		}
> +
> +		return *env;
> +	}
> +
> +	nih_assert (oper->event != NULL);
> +
> +	/* Add environment from the event */
> +	if (! environ_append (env, parent, len, TRUE, oper->event->env))
> +		return NULL;
> +
> +	/* Append the name of the event to the string we're building */
> +	if (*evlist) {
> +		if ((*evlist)[strlen (*evlist) - 1] != '=') {
> +			if (! nih_strcat_sprintf (evlist, NULL, " %s",
> +						  oper->event->name))
> +				return NULL;
> +		} else {
> +			if (! nih_strcat (evlist, NULL,
> +					  oper->event->name)) {
> +				return NULL;
> +			}
> +		}
> +	}
> +
> +	return *env;
> +}

Why the need to split this into two functions and call it recursively,
when it was one non-recursive function before?

> +
> +/**
>    * event_operator_events:
>    * @root: operator tree to collect from,
>    * @parent: parent object for blocked structures,
> @@ -564,31 +611,31 @@
>   		       const void    *parent,
>   		       NihList       *list)
>   {
> +	Blocked       *blocked;
> +
>   	nih_assert (root != NULL);
>   	nih_assert (list != NULL);
> 
> -	/* Iterate the operator tree, filtering out nodes with a non-TRUE
> -	 * value and their children.  The rationale for this is that this
> -	 * then matches only the events that had an active role in starting
> -	 * the job, not the ones that were also blocked, but the other half
> -	 * of their logic wasn't present.
> -	 */
> -	NIH_TREE_FOREACH_FULL (&root->node, iter,
> -			       (NihTreeFilter)event_operator_filter, NULL) {
> +	if (! root->value)
> +		return;
> +
> +	NIH_LIST_FOREACH (&root->children, iter) {
>   		EventOperator *oper = (EventOperator *)iter;
> -		Blocked       *blocked;
> -
> -		if (oper->type != EVENT_MATCH)
> -			continue;
> -
> -		nih_assert (oper->event != NULL);
> -
> -		blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT,
> -						 oper->event));
> -		nih_list_add (list, &blocked->entry);
> -
> -		event_block (blocked->event);
> +
> +		event_operator_events (oper, parent, list);
>   	}
> +
> +
> +	if (root->type != EVENT_MATCH)
> +		return;
> +
> +	nih_assert (root->event != NULL);
> +
> +	blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT,
> +					 root->event));
> +	nih_list_add (list, &blocked->entry);
> +
> +	event_block (blocked->event);
>   }
>

Again, this looks like it's gone from one non-recursive function into a
recursive one?

> 
> @@ -606,24 +653,26 @@
>   	nih_assert (root != NULL);
> 
>   	/* A post-order iteration means we visit children first, perfect! */
> -	NIH_TREE_FOREACH_POST (&root->node, iter) {
> +	NIH_LIST_FOREACH (&root->children, iter) {
>   		EventOperator *oper = (EventOperator *)iter;
> 
> -		switch (oper->type) {
> -		case EVENT_OR:
> -		case EVENT_AND:
> -			event_operator_update (oper);
> -			break;
> -		case EVENT_MATCH:
> -			oper->value = FALSE;
> -
> -			if (oper->event) {
> -				event_unblock (oper->event);
> -				oper->event = NULL;
> -			}
> -			break;
> -		default:
> -			nih_assert_not_reached ();
> +		event_operator_reset (oper);
> +	}
> +
> +	switch (root->type) {
> +	case EVENT_ANY:
> +	case EVENT_ALL:
> +		event_operator_update (root);
> +		break;
> +	case EVENT_MATCH:
> +		root->value = FALSE;
> +
> +		if (root->event) {
> +			event_unblock (root->event);
> +			root->event = NULL;
>   		}
> +		break;
> +	default:
> +		nih_assert_not_reached ();
>   	}
>   }
>

Again, you've switched from non-recursive code to recursive code?

> === modified file 'init/event_operator.h'
> --- init/event_operator.h	2009-06-23 09:29:35 +0000
> +++ init/event_operator.h	2009-08-11 05:12:01 +0000
> @@ -33,14 +33,15 @@
>    * the EventOperator structure.
>    **/
>   typedef enum event_operator_type {
> -	EVENT_OR,
> -	EVENT_AND,
> +	EVENT_ANY,
> +	EVENT_ALL,
>   	EVENT_MATCH
>   } EventOperatorType;
>

Why the rename of the operators?  The use of "any" here seems especially
confusing given the meaning penned in some of the design discussions,
lit.

while dbus-daemon

(while a dbus-daemon is running, with an instance created for each
running dbus daemon)

while any dbus-daemon

(while at least one dbus-daemon is running, only one instance)

> @@ -665,10 +665,8 @@
>   	if (! oper)
>   		nih_return_system_error (-1);
> 
> -	nih_ref (*root, oper);
> +	event_operator_add_child (oper, *root);
>   	nih_unref (*root, class);
> -
> -	nih_tree_add (&oper->node, &(*root)->node, NIH_TREE_LEFT);
>   	*root = NULL;
> 
>   	/* Push the new operator onto the stack */

The comment on event_operator_add_child would go a long way to helping
realise there's no leak here.

> @@ -938,11 +936,8 @@
>   		 * event matches.
>   		 */
>   		if ((oper->type != EVENT_MATCH) && (*root)) {
> -			nih_ref (*root, oper);
> +			event_operator_add_child (oper, *root);
>   			nih_unref (*root, class);
> -
> -			nih_tree_add (&oper->node, &(*root)->node,
> -				      NIH_TREE_RIGHT);
>   		} else if (oper->type != EVENT_MATCH) {
>   			nih_return_error (-1, PARSE_EXPECTED_EVENT,
>   					  _(PARSE_EXPECTED_EVENT_STR));
>

Likewise here.

> @@ -358,13 +357,18 @@
>   		TEST_EQ (oper->value, FALSE);
>   		TEST_EQ_P (oper->event, NULL);
> 
> -		oper = (EventOperator *)class->start_on->node.left;
> -		TEST_EQ (oper->value, TRUE);
> -		TEST_EQ_P (oper->event, event1);
> -
> -		oper = (EventOperator *)class->start_on->node.right;
> -		TEST_EQ (oper->value, FALSE);
> -		TEST_EQ_P (oper->event, NULL);
> +		NIH_LIST_FOREACH (&oper->children, iter) {
> +			EventOperator *child = (EventOperator *)iter;
> +
> +			any_true = any_true || child->value;
> +			all_true = all_true && child->value;
> +		}
> +
> +		TEST_EQ (any_true, TRUE);
> +		TEST_EQ (all_true, FALSE);
> +		
> +		any_true = FALSE;
> +		all_true = TRUE;
> 
>   		nih_free (class);
>   		nih_free (event1);

This any_true/all_true stuff is a bit "clever", and it seems to matter
whether one is set to TRUE first and the other FALSE.

General style:

TEST_TRUE (any_true);
  TEST_FALSE (all_true);

(snipped a couple of instances of this, but applies to all)

> @@ -518,8 +494,6 @@
> 
> 
>   	nih_free (oper1);
> -	nih_free (oper2);
> -	nih_free (oper3);
>   }
>

Why the loss of these?

> @@ -938,10 +912,6 @@
>   	event_operator_reset (oper1);
> 
>   	nih_free (oper1);
> -	nih_free (oper2);
> -	nih_free (oper3);
> -	nih_free (oper4);
> -	nih_free (oper5);
> 
>   	event_poll ();
>   }

Likewise.

> @@ -1274,15 +1244,73 @@
>   	TEST_EQ (event2->blockers, 0);
> 
>   	nih_free (oper1);
> -	nih_free (oper2);
> -	nih_free (oper3);
> -	nih_free (oper4);
> -	nih_free (oper5);
> 
>   	event_poll ();
>   }
>

And again?

> 
> +void
> +test_operator_add_child (void)
> +{
> +	EventOperator *oper1, *oper2, *oper3, *oper4, *oper5, *oper6, *oper7;
> +	int found_foo = 0;
> +	int found_bar = 0;
> +	int found_baz = 0;
> +	int found_bam = 0;
> +	int found_all = 0;
> +
> +	TEST_FUNCTION ("event_operator_add_child");
> +	oper1 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
> +	oper2 = event_operator_new (NULL, EVENT_ALL, NULL, NULL);
> +	oper3 = event_operator_new (NULL, EVENT_MATCH, "foo", NULL);
> +	oper4 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);
> +	oper5 = event_operator_new (NULL, EVENT_MATCH, "baz", NULL);
> +	oper6 = event_operator_new (NULL, EVENT_MATCH, "bam", NULL);
> +	oper7 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
> +
> +	event_operator_add_child (oper2, oper3);
> +	event_operator_add_child (oper2, oper4);
> +	event_operator_add_child (oper7, oper5);
> +	event_operator_add_child (oper7, oper6);
> +	event_operator_add_child (oper1, oper2);
> +	event_operator_add_child (oper1, oper7);
> +
> +	TEST_EQ (oper1->type, EVENT_ANY);
> +
> +	NIH_LIST_FOREACH (&oper1->children, iter) {
> +		EventOperator *child = (EventOperator *)iter;
> +
> +		if (child->type == EVENT_ALL) {
> +			found_all++;
> +			continue;
> +		}
> +
> +		TEST_EQ (child->type, EVENT_MATCH);
> +
> +		if (! strncmp (child->name, "foo", 4))
> +			found_foo++;
> +
> +		if (! strncmp (child->name, "bar", 4))
> +			found_bar++;
> +
> +		if (! strncmp (child->name, "baz", 4))
> +			found_baz++;
> +
> +		if (! strncmp (child->name, "bam", 4))
> +			found_bam++;
> +	}
> +
> +	// Not a truth test. 2 is also a failure.
> +	TEST_EQ (found_all, 1);
> +	TEST_EQ (found_foo, 0);
> +	TEST_EQ (found_bar, 0);
> +	TEST_EQ (found_baz, 1);
> +	TEST_EQ (found_bam, 1);
> +
> +	nih_free (oper1);
> +}

This test case could do with some cleaning up, it's not really very well
explained and I can't quite figure out what you're testing.

Use of TEST_FAILED should match the other uses of it.

Why strncmp() not strcmp() ?

Don't use //

> @@ -1901,31 +1896,26 @@
>   		TEST_ALLOC_PARENT (job->start_on, job);
> 
>   		oper = job->start_on;
> -		TEST_EQ (oper->type, EVENT_OR);
> -
> -		TEST_EQ_P (oper->node.parent, NULL);
> -		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
> -		TEST_ALLOC_PARENT (oper->node.left, oper);
> -		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
> -		TEST_ALLOC_PARENT (oper->node.right, oper);
> -
> -		oper = (EventOperator *)job->start_on->node.left;
> -		TEST_EQ (oper->type, EVENT_MATCH);
> -		TEST_EQ_STR (oper->name, "wibble");
> -		TEST_EQ_P (oper->env, NULL);
> -
> -		TEST_EQ_P (oper->node.parent, &job->start_on->node);
> -		TEST_EQ_P (oper->node.left, NULL);
> -		TEST_EQ_P (oper->node.right, NULL);
> -
> -		oper = (EventOperator *)job->start_on->node.right;
> -		TEST_EQ (oper->type, EVENT_MATCH);
> -		TEST_EQ_STR (oper->name, "wobble");
> -		TEST_EQ_P (oper->env, NULL);
> -
> -		TEST_EQ_P (oper->node.parent, &job->start_on->node);
> -		TEST_EQ_P (oper->node.left, NULL);
> -		TEST_EQ_P (oper->node.right, NULL);
> +		TEST_EQ (oper->type, EVENT_ANY);
> +
> +		got_wibble = FALSE;
> +		got_wobble = FALSE;
> +		EventOperator *parent = oper;
> +		NIH_LIST_FOREACH (&oper->children, iter) {
> +			EventOperator *child = (EventOperator *)iter;
> +
> +			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
> +
> +			TEST_LIST_EMPTY (&child->children);
> +			TEST_EQ_P (child->env, NULL);
> +			TEST_EQ (child->type, EVENT_MATCH);
> +			if (!strncmp ("wibble", child->name, 7) && ! got_wibble)
> +				got_wibble = TRUE;
> +			else if (!strncmp ("wobble", child->name, 7) && ! got_wobble)
> +				got_wobble = TRUE;
> +			else
> +				TEST_FAILED ("Unexpected child");
> +		}
> 
>   		nih_free (job);
>   	}

List iteration should be separated by a gap.

Why are you using strncmp() here?

"if (! ...)" not "if (!...)"

"&& (! ...)" not "&& ! ..."

if/else without { } is punishable by death ;-)

TEST_FAILED should match the output of others

(A couple of instances of these)

Scott
-- 
Have you ever, ever felt like this?
Had strange things happen?  Are you going round the twist?

-- 
upstart-devel mailing list
upstart-devel@lists.ubuntu.com
Modify settings or unsubscribe at: https://lists.ubuntu.com/mailman/listinfo/upstart-devel

Revision history for this message

Casey Dahlin (cjdahlin) wrote on 2009-08-12:

Download full text (25.2 KiB)

-------- Original Message --------
Subject: Re: [PATCH] N-ary event operators
Date: Wed, 12 Aug 2009 10:06:39 -0400
From: Casey Dahlin <email address hidden>
To: Scott James Remnant <email address hidden>
CC: Upstart Dev List <email address hidden>

On 08/12/2009 06:12 AM, Scott James Remnant wrote:
> On Tue, 2009-08-11 at 17:33 -0400, Casey Dahlin wrote:
>
>> This makes EventOperators N-ary rather than binary trees. It
>> auto-optimizes them with a new event_operator_add_child helper that
>> simply gifts all of the new child's children to the new parent rather
>> than attaching it when the new parent and child are of the same type.
>>
>> This makes it a bit easier to make qualitative statements about trees,
>> particularly "this tree only contains OR operators," which should become
>> useful as AND operators become deprecated in future state models.
>>
> Thanks Casey.
>
> Could you explain a little bit more about the rationale behind these
> changes? Right now this just looks like a different way of constructing
> the operator trees, and unless I'm mistaken, it's more expensive to
> build them this way, they use more memory per node and they're more
> difficult to iterate than the btrees we currently use.
>

Building them might be a bit more expensive, but they do take up less memory by virtue of simply having fewer nodes.

> Are you working on something else that requires this? Perhaps it'd help
> to outline that work as well to the ML.
>

I am. I'll do that.

> One thing I'd like to ask about - I don't have any plans to deprecate
> AND operators; could you tell us a little bit about your plans in this
> regard?
>

When we switch from start on to on, I see no reason to keep them. We'll have much better ways to retain state (frankly I'd rather just allow multiple "on" stanzas and do away with operators altogether, in which case our commitment to compatibility with 0.6 is the only reason any of this code needs to be around).

>
>
>> === modified file 'ChangeLog'
>> --- ChangeLog 2009-08-04 08:51:25 +0000
>> +++ ChangeLog 2009-08-11 05:51:31 +0000
>> @@ -1,3 +1,60 @@
>> +2009-08-11 Casey Dahlin <email address hidden>
>> +
>> + * init/event_operator.h (EventOperatorType): Change types from AND/OR to
>> + ANY/ALL
>> +
>> + (EventOperator): Get rid of node entry and add children list.
>> +
>> + * init/event_operator.c (event_operator_subtree_environment): New
>> + version of event_operator_environment that assumes we are not at the
>> + root of the tree.
>> +
>> + (event_operator_new): Initialize new children member instead of tree
>> + node.
>> +
>> + (event_operator_copy): Use recursive call to correctly copy N-ary tree
>> +
>> + (event_operator_reset): Use recursive call to correctly reset N-ary tree
>> +
>> + (event_operator_events): Use recursive call to correctly get events from
>> + N-ary tree.
>> +
>> + (event_operator_handle): Use recursive call to correctly handle N-ary
>> + tree.
>> +
>> + (event_operator_update): Update based on all N children
>> +
>> + (event_operator_match): Don't assert based on now-defunct node
>> +
>> + (event_operator_add_child): New helper to add a child to a tree,
>> + automatically colla...

-------- Original Message --------
Subject: Re: [PATCH] N-ary event operators
Date: Wed, 12 Aug 2009 10:06:39 -0400
From: Casey Dahlin <cdahlin@redhat.com>
To: Scott James Remnant <scott@netsplit.com>
CC: Upstart Dev List <upstart-devel@lists.ubuntu.com>

On 08/12/2009 06:12 AM, Scott James Remnant wrote:
> On Tue, 2009-08-11 at 17:33 -0400, Casey Dahlin wrote:
> 
>> This makes EventOperators N-ary rather than binary trees. It 
>> auto-optimizes them with a new event_operator_add_child helper that 
>> simply gifts all of the new child's children to the new parent rather 
>> than attaching it when the new parent and child are of the same type.
>>
>> This makes it a bit easier to make qualitative statements about trees, 
>> particularly "this tree only contains OR operators," which should become 
>> useful as AND operators become deprecated in future state models.
>>
> Thanks Casey.
> 
> Could you explain a little bit more about the rationale behind these
> changes?  Right now this just looks like a different way of constructing
> the operator trees, and unless I'm mistaken, it's more expensive to
> build them this way, they use more memory per node and they're more
> difficult to iterate than the btrees we currently use.
>

Building them might be a bit more expensive, but they do take up less memory by virtue of simply having fewer nodes.

> Are you working on something else that requires this?  Perhaps it'd help
> to outline that work as well to the ML.
>

I am. I'll do that.

> One thing I'd like to ask about - I don't have any plans to deprecate
> AND operators; could you tell us a little bit about your plans in this
> regard?
>

> 
> 
>> === modified file 'ChangeLog'
>> --- ChangeLog	2009-08-04 08:51:25 +0000
>> +++ ChangeLog	2009-08-11 05:51:31 +0000
>> @@ -1,3 +1,60 @@
>> +2009-08-11  Casey Dahlin  <cdahlin@redhat.com>
>> +
>> +	* init/event_operator.h (EventOperatorType): Change types from AND/OR to
>> +	ANY/ALL
>> +
>> +	(EventOperator): Get rid of node entry and add children list.
>> +
>> +	* init/event_operator.c (event_operator_subtree_environment): New
>> +	version of event_operator_environment that assumes we are not at the
>> +	root of the tree.
>> +
>> +	(event_operator_new): Initialize new children member instead of tree
>> +	node.
>> +
>> +	(event_operator_copy): Use recursive call to correctly copy N-ary tree
>> +
>> +	(event_operator_reset): Use recursive call to correctly reset N-ary tree
>> +
>> +	(event_operator_events): Use recursive call to correctly get events from
>> +	N-ary tree.
>> +
>> +	(event_operator_handle): Use recursive call to correctly handle N-ary
>> +	tree.
>> +
>> +	(event_operator_update): Update based on all N children
>> +
>> +	(event_operator_match): Don't assert based on now-defunct node
>> +
>> +	(event_operator_add_child): New helper to add a child to a tree,
>> +	automatically collapsing it into its new parent if it is the same type.
>> +
>> +	(event_operator_destroy): Destroy children list head correctly.
>> +
>> +	(event_operator_environment): Use new event_operator_subtree_environment
>> +	to recursively collect environment variables.
>> +
>> +	* init/parse_job.c (parse_on_operator): Change AND/OR to ANY/ALL. Change
>> +	tree adds to event_operator_add_child calls.
>> +
>> +	(parse_on_collect): Change tree adds to event_operator_add_child calls
>> +
>> +	* init/tests/test_event.c (test_pending_handle_jobs): Fix structural
>> +	assumptions about EventOperator.
>> +
>> +	(test_finish): Change AND/OR to ANY/ALL
>> +
>> +	* init/tests/test_event_operator.c (everywhere): Fix structural
>> +	assumptions about EventOperator.
>> +
>> +	(test_operator_add_child): New test for this new helper.
>> +
>> +	* init/tests/test_job_process.c (everywhere): Fix structural assumptions
>> +	about EventOperator
>> +
>> +	* init/tests/test_parse_job.c (everywhere): Fix structural assumptions
>> +	about EventOperator
>> +
>>   2009-08-04  Johan Kiviniemi  <johan@kiviniemi.name>
>>
>>   	* conf/rc-sysinit.conf: Don't replace DEFAULT_RUNLEVEL with an
>>
> 
> ChangeLog entries should be grouped together with a blank line only
> between individual commits.
> 
> Avoid using the 80th column.
>

> 
>> === modified file 'init/event_operator.c'
>> --- init/event_operator.c	2009-06-23 09:29:35 +0000
>> +++ init/event_operator.c	2009-08-11 05:12:01 +0000
>> @@ -43,6 +43,9 @@
>>   #include "blocked.h"
>>   #include "errors.h"
>>
>> +static char** event_operator_subtree_environment
>> +		(EventOperator *oper, char ***env, const void *parent,
>> +		 size_t *len, const char *key, char **evlist);
>>
>>   /**
>>    * event_operator_new:
> 
> Should be "static char **", should be preceeded by a comment and have
> extra blank lines around (see other source files for examples).  The
> opening paren, and thus the arguments, should follow even if you have to
> indent strangely.
> 
> 
>> +	NIH_LIST_FOREACH (&old_oper->children, iter) {
>> +		EventOperator *child = event_operator_copy (
>> +				       oper, (EventOperator *)iter);
>> +		if (! child) {
>> +			nih_free (oper);
>> +			return NULL;
>> +		}
>> +
>> +		event_operator_add_child (oper, child);
>>   	}
> 
> Don't use initialisers like this, it's much better style to do:
> 
> 	EventOperator *old_child = (EventOperator *)iter;
> 	EventOperator *child;
> 
> 	child = event_operator_copy (oper, old_child);
> 	if (! child) {
> 		nih_free (oper);
> 		return NULL;
> 	}
> 
> 
>>   /**
>> + * event_operator_add_child:
>> + * @oper: oper to add child to,
>> + * @child: child to add.
>> + *
>> + * Makes @child a child of @oper. If @child and @oper are the same 
>> type, then
>> + * @oper simply steals all of @child's children.
>> + **/
>> +void
>> +event_operator_add_child (EventOperator *oper, EventOperator *child)
>> +{
>> +	nih_assert (oper != NULL);
>> +	nih_assert (child != NULL);
>> +	nih_assert (oper->type != EVENT_MATCH);
>> +
>> +	if (child->type != oper->type) {
>> +		nih_ref (child, oper);
>> +		nih_list_add (&oper->children, &child->entry);
>> +		return;
>> +	}
>> +
>> +	NIH_LIST_FOREACH_SAFE (&child->children, iter) {
>> +		EventOperator *grandchild = (EventOperator *)iter;
>> +
>> +		nih_ref (grandchild, oper);
>> +		nih_unref (grandchild, child);
>> +		nih_list_add (&oper->children, &grandchild->entry);
>> +	}
>> +}
> 
> Doc string should mention that the child will be referenced by the new
> parent.
> 
> This seems a bit strange in the adding-the-same-type case; it moves all
> the chidren of the old node to the new node, but not the old node
> itself?  What happens to the old node, it looks like it just gets left
> in the tree?
>

This operation is destructive. Not only should this function create a new reference, but the child should be freed if it does not.

> Why doesn't this function no-op in the adding-the-same-type case, and
> discard the new node instead?
>

There is no "new" node. Both of these nodes could have been around for awhile. You could do it the other way and give the parents nodes to the child, but then you'd have to make child a sibling of parent and free parent. And what if parent is pointed to elsewhere? You could say the same about child, but it makes much more sense to say "just don't do that" in the child's case.

> 
>> @@ -227,24 +249,17 @@
>>   void
>>   event_operator_update (EventOperator *oper)
>>   {
>> -	EventOperator *left, *right;
>> -
>>   	nih_assert (oper != NULL);
>> -	nih_assert (oper->node.left != NULL);
>> -	nih_assert (oper->node.right != NULL);
>> -
>> -	left = (EventOperator *)oper->node.left;
>> -	right = (EventOperator *)oper->node.right;
>> -
>> -	switch (oper->type) {
>> -	case EVENT_OR:
>> -		oper->value = (left->value || right->value);
>> -		break;
>> -	case EVENT_AND:
>> -		oper->value = (left->value && right->value);
>> -		break;
>> -	default:
>> -		nih_assert_not_reached ();
>> +	nih_assert (oper->type != EVENT_MATCH);
>> +
>> +	oper->value = (oper->type == EVENT_ALL) ? TRUE : FALSE;
>> +
>> +	NIH_LIST_FOREACH (&oper->children, iter) {
>> +		EventOperator *child = (EventOperator *)iter;
>> +		if (child->value != oper->value) {
>> +			oper->value = child->value;
>> +			return;
>> +		}
>>   	}
>>   }
>>
> 
> Should have a blank line between initialisers and checks.
> 
> Probably should have a comment explaining how this works, since it's a
> bit "clever" :-)
> 
>> @@ -391,29 +404,30 @@
>>   	 * before we update the node itself.  Simply iterate the tree and
>>   	 * update the nodes.
>>   	 */
>> -	NIH_TREE_FOREACH_POST (&root->node, iter) {
>> +	NIH_LIST_FOREACH (&root->children, iter) {
>>   		EventOperator *oper = (EventOperator *)iter;
>>
>> -		switch (oper->type) {
>> -		case EVENT_OR:
>> -		case EVENT_AND:
>> -			event_operator_update (oper);
>> -			break;
>> -		case EVENT_MATCH:
>> -			if ((! oper->value)
>> -			    && event_operator_match (oper, event, env)) {
>> -				oper->value = TRUE;
>> -
>> -				oper->event = event;
>> -				event_block (oper->event);
>> -
>> -				ret = TRUE;
>> -			}
>> -			break;
>> -		default:
>> -			nih_assert_not_reached ();
>> +		ret = ret || event_operator_handle (oper, event, env);
>> +	}
>> +
>> +	switch (root->type) {
>> +	case EVENT_ANY:
>> +	case EVENT_ALL:
>> +		event_operator_update (root);
>> +		break;
>> +	case EVENT_MATCH:
>> +		if ((! root->value)
>> +		    && event_operator_match (root, event, env)) {
>> +			root->value = TRUE;
>> +
>> +			root->event = event;
>> +			event_block (root->event);
>> +
>> +			ret = TRUE;
>>   		}
>> -
>> +		break;
>> +	default:
>> +		nih_assert_not_reached ();
>>   	}
>>
>>   	return ret;
> 
> I generally dislike:
> 
>   ret = ret || ...
> 
> forms, instead please be more specific.
>

Not sure what to make of that one...

> 
> Why the change to recursively calling event_operator_handle() where this
> wasn't needed before?
>

We'd have to add a parent pointer to get rid of the recursion again, and even then the algorithms are unpretty at best.

> Why moving everything from out of the loop acting on oper to inside the
> loop acting on root?
> 
> You left the comment about this being a post-order traversal, but this
> doesn't appear to be an any-kind-of-order traversal anymore?

The traversal consists both of the loop and the code immediately after it. We handle the children inside the loop and the parent after it. Hence "post-order."

> 
>> @@ -501,38 +515,9 @@
>>   			return NULL;
>>   	}
>>
>> -	/* Iterate the operator tree, filtering out nodes with a non-TRUE
>> -	 * value and their children.  The rationale for this is that this
>> -	 * then matches only the events that had an active role in starting
>> -	 * the job, not the ones that were also blocked, but the other half
>> -	 * of their logic wasn't present.
>> -	 */
>> -	NIH_TREE_FOREACH_FULL (&root->node, iter,
>> -			       (NihTreeFilter)event_operator_filter, NULL) {
>> -		EventOperator *oper = (EventOperator *)iter;
>> -
>> -		if (oper->type != EVENT_MATCH)
>> -			continue;
>> -
>> -		nih_assert (oper->event != NULL);
>> -
>> -		/* Add environment from the event */
>> -		if (! environ_append (env, parent, len, TRUE, oper->event->env))
>> -			return NULL;
>> -
>> -		/* Append the name of the event to the string we're building */
>> -		if (evlist) {
>> -			if (evlist[strlen (evlist) - 1] != '=') {
>> -				if (! nih_strcat_sprintf (&evlist, NULL, " %s",
>> -							  oper->event->name))
>> -					return NULL;
>> -			} else {
>> -				if (! nih_strcat (&evlist, NULL,
>> -						  oper->event->name))
>> -					return NULL;
>> -			}
>> -		}
>> -	}
>> +	if (! event_operator_subtree_environment (root, env, parent,
>> +					          len, key, &evlist))
>> +		return NULL;
>>
>>   	/* Append the event list to the environment */
>>   	if (evlist)
>> @@ -543,6 +528,68 @@
>>   }
>>
>>   /**
>> + * event_operator_subtree_environment:
>> + * @root: operator tree to collect from,
>> + * @env: NULL-terminated array of environment variables to add to,
>> + * @parent: parent object for new array,
>> + * @len: length of @env,
>> + * @key: key of variable to contain event names,
>> + * @evlist: string in which to accumulate the event list.
>> + *
>> + * Does the work of event_operator_environment for one subtree.
>> + **/
>> +
>> +static char**
>> +event_operator_subtree_environment (EventOperator   *oper,
>> +				    char          ***env,
>> +				    const void      *parent,
>> +				    size_t          *len,
>> +				    const char      *key,
>> +				    char           **evlist)
>> +{
>> +	/* Filtering out nodes with a non-TRUE value and their children. The
>> +	 * rationale for this is that this then matches only the events that had
>> +	 * an active role in starting the job, not the ones that were also
>> +	 * blocked, but the other half of their logic wasn't present.
>> +	 */
>> +	if (! oper->value)
>> +		return *env;
>> +
>> +	if (oper->type != EVENT_MATCH) {
>> +		NIH_LIST_FOREACH(&oper->children, iter) {
>> +			EventOperator *child = (EventOperator *)iter;
>> +			if (! event_operator_subtree_environment (child, env, parent,
>> +							          len, key, evlist))
>> +				return NULL;
>> +		}
>> +
>> +		return *env;
>> +	}
>> +
>> +	nih_assert (oper->event != NULL);
>> +
>> +	/* Add environment from the event */
>> +	if (! environ_append (env, parent, len, TRUE, oper->event->env))
>> +		return NULL;
>> +
>> +	/* Append the name of the event to the string we're building */
>> +	if (*evlist) {
>> +		if ((*evlist)[strlen (*evlist) - 1] != '=') {
>> +			if (! nih_strcat_sprintf (evlist, NULL, " %s",
>> +						  oper->event->name))
>> +				return NULL;
>> +		} else {
>> +			if (! nih_strcat (evlist, NULL,
>> +					  oper->event->name)) {
>> +				return NULL;
>> +			}
>> +		}
>> +	}
>> +
>> +	return *env;
>> +}
> 
> Why the need to split this into two functions and call it recursively,
> when it was one non-recursive function before?
>

See above. I can make it non-recursive if this really is an issue.

>> +
>> +/**
>>    * event_operator_events:
>>    * @root: operator tree to collect from,
>>    * @parent: parent object for blocked structures,
>> @@ -564,31 +611,31 @@
>>   		       const void    *parent,
>>   		       NihList       *list)
>>   {
>> +	Blocked       *blocked;
>> +
>>   	nih_assert (root != NULL);
>>   	nih_assert (list != NULL);
>>
>> -	/* Iterate the operator tree, filtering out nodes with a non-TRUE
>> -	 * value and their children.  The rationale for this is that this
>> -	 * then matches only the events that had an active role in starting
>> -	 * the job, not the ones that were also blocked, but the other half
>> -	 * of their logic wasn't present.
>> -	 */
>> -	NIH_TREE_FOREACH_FULL (&root->node, iter,
>> -			       (NihTreeFilter)event_operator_filter, NULL) {
>> +	if (! root->value)
>> +		return;
>> +
>> +	NIH_LIST_FOREACH (&root->children, iter) {
>>   		EventOperator *oper = (EventOperator *)iter;
>> -		Blocked       *blocked;
>> -
>> -		if (oper->type != EVENT_MATCH)
>> -			continue;
>> -
>> -		nih_assert (oper->event != NULL);
>> -
>> -		blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT,
>> -						 oper->event));
>> -		nih_list_add (list, &blocked->entry);
>> -
>> -		event_block (blocked->event);
>> +
>> +		event_operator_events (oper, parent, list);
>>   	}
>> +
>> +
>> +	if (root->type != EVENT_MATCH)
>> +		return;
>> +
>> +	nih_assert (root->event != NULL);
>> +
>> +	blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT,
>> +					 root->event));
>> +	nih_list_add (list, &blocked->entry);
>> +
>> +	event_block (blocked->event);
>>   }
>>
> 
> Again, this looks like it's gone from one non-recursive function into a
> recursive one?
>

See above again.

>> @@ -606,24 +653,26 @@
>>   	nih_assert (root != NULL);
>>
>>   	/* A post-order iteration means we visit children first, perfect! */
>> -	NIH_TREE_FOREACH_POST (&root->node, iter) {
>> +	NIH_LIST_FOREACH (&root->children, iter) {
>>   		EventOperator *oper = (EventOperator *)iter;
>>
>> -		switch (oper->type) {
>> -		case EVENT_OR:
>> -		case EVENT_AND:
>> -			event_operator_update (oper);
>> -			break;
>> -		case EVENT_MATCH:
>> -			oper->value = FALSE;
>> -
>> -			if (oper->event) {
>> -				event_unblock (oper->event);
>> -				oper->event = NULL;
>> -			}
>> -			break;
>> -		default:
>> -			nih_assert_not_reached ();
>> +		event_operator_reset (oper);
>> +	}
>> +
>> +	switch (root->type) {
>> +	case EVENT_ANY:
>> +	case EVENT_ALL:
>> +		event_operator_update (root);
>> +		break;
>> +	case EVENT_MATCH:
>> +		root->value = FALSE;
>> +
>> +		if (root->event) {
>> +			event_unblock (root->event);
>> +			root->event = NULL;
>>   		}
>> +		break;
>> +	default:
>> +		nih_assert_not_reached ();
>>   	}
>>   }
>>
> 
> Again, you've switched from non-recursive code to recursive code?
>

And again.

>> === modified file 'init/event_operator.h'
>> --- init/event_operator.h	2009-06-23 09:29:35 +0000
>> +++ init/event_operator.h	2009-08-11 05:12:01 +0000
>> @@ -33,14 +33,15 @@
>>    * the EventOperator structure.
>>    **/
>>   typedef enum event_operator_type {
>> -	EVENT_OR,
>> -	EVENT_AND,
>> +	EVENT_ANY,
>> +	EVENT_ALL,
>>   	EVENT_MATCH
>>   } EventOperatorType;
>>
> 
> Why the rename of the operators?  The use of "any" here seems especially
> confusing given the meaning penned in some of the design discussions,
> lit.
> 
>    while dbus-daemon
> 
> (while a dbus-daemon is running, with an instance created for each
> running dbus daemon)
> 
>    while any dbus-daemon
> 
> (while at least one dbus-daemon is running, only one instance)
>

This seemed clearer to me at the time (Operator for "any of these must be true," operator for "all of these must be true"), but on second glance the code still makes sense without changing this.

> 
>> @@ -665,10 +665,8 @@
>>   	if (! oper)
>>   		nih_return_system_error (-1);
>>
>> -	nih_ref (*root, oper);
>> +	event_operator_add_child (oper, *root);
>>   	nih_unref (*root, class);
>> -
>> -	nih_tree_add (&oper->node, &(*root)->node, NIH_TREE_LEFT);
>>   	*root = NULL;
>>
>>   	/* Push the new operator onto the stack */
> 
> The comment on event_operator_add_child would go a long way to helping
> realise there's no leak here.
> 
>> @@ -938,11 +936,8 @@
>>   		 * event matches.
>>   		 */
>>   		if ((oper->type != EVENT_MATCH) && (*root)) {
>> -			nih_ref (*root, oper);
>> +			event_operator_add_child (oper, *root);
>>   			nih_unref (*root, class);
>> -
>> -			nih_tree_add (&oper->node, &(*root)->node,
>> -				      NIH_TREE_RIGHT);
>>   		} else if (oper->type != EVENT_MATCH) {
>>   			nih_return_error (-1, PARSE_EXPECTED_EVENT,
>>   					  _(PARSE_EXPECTED_EVENT_STR));
>>
> 
> Likewise here.
> 
>> @@ -358,13 +357,18 @@
>>   		TEST_EQ (oper->value, FALSE);
>>   		TEST_EQ_P (oper->event, NULL);
>>
>> -		oper = (EventOperator *)class->start_on->node.left;
>> -		TEST_EQ (oper->value, TRUE);
>> -		TEST_EQ_P (oper->event, event1);
>> -
>> -		oper = (EventOperator *)class->start_on->node.right;
>> -		TEST_EQ (oper->value, FALSE);
>> -		TEST_EQ_P (oper->event, NULL);
>> +		NIH_LIST_FOREACH (&oper->children, iter) {
>> +			EventOperator *child = (EventOperator *)iter;
>> +
>> +			any_true = any_true || child->value;
>> +			all_true = all_true && child->value;
>> +		}
>> +
>> +		TEST_EQ (any_true, TRUE);
>> +		TEST_EQ (all_true, FALSE);
>> +		
>> +		any_true = FALSE;
>> +		all_true = TRUE;
>>
>>   		nih_free (class);
>>   		nih_free (event1);
> 
> This any_true/all_true stuff is a bit "clever", and it seems to matter
> whether one is set to TRUE first and the other FALSE.
>

They have to be initialized. Any should always start out FALSE and all should always start out TRUE. Theres no reason to ever start with different values for them.

> General style:
> 
>   TEST_TRUE (any_true);
>   TEST_FALSE (all_true);
> 
> (snipped a couple of instances of this, but applies to all)
> 
> 
>> @@ -518,8 +494,6 @@
>>
>>
>>   	nih_free (oper1);
>> -	nih_free (oper2);
>> -	nih_free (oper3);
>>   }
>>
> 
> Why the loss of these?

oper1 now references oper2 and oper3 because event_operator_add_child creates these references automatically.

> 
> 
>> @@ -938,10 +912,6 @@
>>   	event_operator_reset (oper1);
>>
>>   	nih_free (oper1);
>> -	nih_free (oper2);
>> -	nih_free (oper3);
>> -	nih_free (oper4);
>> -	nih_free (oper5);
>>
>>   	event_poll ();
>>   }
> 
> Likewise.
>

Above.

>> @@ -1274,15 +1244,73 @@
>>   	TEST_EQ (event2->blockers, 0);
>>
>>   	nih_free (oper1);
>> -	nih_free (oper2);
>> -	nih_free (oper3);
>> -	nih_free (oper4);
>> -	nih_free (oper5);
>>
>>   	event_poll ();
>>   }
>>
> 
> And again?
>

Above.

>> +void
>> +test_operator_add_child (void)
>> +{
>> +	EventOperator *oper1, *oper2, *oper3, *oper4, *oper5, *oper6, *oper7;
>> +	int found_foo = 0;
>> +	int found_bar = 0;
>> +	int found_baz = 0;
>> +	int found_bam = 0;
>> +	int found_all = 0;
>> +
>> +	TEST_FUNCTION ("event_operator_add_child");
>> +	oper1 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
>> +	oper2 = event_operator_new (NULL, EVENT_ALL, NULL, NULL);
>> +	oper3 = event_operator_new (NULL, EVENT_MATCH, "foo", NULL);
>> +	oper4 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);
>> +	oper5 = event_operator_new (NULL, EVENT_MATCH, "baz", NULL);
>> +	oper6 = event_operator_new (NULL, EVENT_MATCH, "bam", NULL);
>> +	oper7 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
>> +
>> +	event_operator_add_child (oper2, oper3);
>> +	event_operator_add_child (oper2, oper4);
>> +	event_operator_add_child (oper7, oper5);
>> +	event_operator_add_child (oper7, oper6);
>> +	event_operator_add_child (oper1, oper2);
>> +	event_operator_add_child (oper1, oper7);
>> +
>> +	TEST_EQ (oper1->type, EVENT_ANY);
>> +
>> +	NIH_LIST_FOREACH (&oper1->children, iter) {
>> +		EventOperator *child = (EventOperator *)iter;
>> +
>> +		if (child->type == EVENT_ALL) {
>> +			found_all++;
>> +			continue;
>> +		}
>> +
>> +		TEST_EQ (child->type, EVENT_MATCH);
>> +
>> +		if (! strncmp (child->name, "foo", 4))
>> +			found_foo++;
>> +
>> +		if (! strncmp (child->name, "bar", 4))
>> +			found_bar++;
>> +
>> +		if (! strncmp (child->name, "baz", 4))
>> +			found_baz++;
>> +
>> +		if (! strncmp (child->name, "bam", 4))
>> +			found_bam++;
>> +	}
>> +
>> +	// Not a truth test. 2 is also a failure.
>> +	TEST_EQ (found_all, 1);
>> +	TEST_EQ (found_foo, 0);
>> +	TEST_EQ (found_bar, 0);
>> +	TEST_EQ (found_baz, 1);
>> +	TEST_EQ (found_bam, 1);
>> +
>> +	nih_free (oper1);
>> +}
> 
> This test case could do with some cleaning up, it's not really very well
> explained and I can't quite figure out what you're testing.
>

Its pretty straightforward. We construct a tree with various operators and confirm that the result has everything where it should. Most of the weirdness is in that unlike the previous tests which tested the left and right nodes explicitly, this test is designed to be flexible around the fact that

or
 / \
a   b

and

or
 / \
b   a

have effectively the same meaning. Just my way of helping the next crazy mofo not have to update a testcase when he makes event operators behave differently.

> Use of TEST_FAILED should match the other uses of it.
> 
> Why strncmp() not strcmp() ?
>

Grotesque sacrilige! Don't you know the non-'n' string functions eat kittens?!

> Don't use //
>

But I like it :(

> 
> 
>> @@ -1901,31 +1896,26 @@
>>   		TEST_ALLOC_PARENT (job->start_on, job);
>>
>>   		oper = job->start_on;
>> -		TEST_EQ (oper->type, EVENT_OR);
>> -
>> -		TEST_EQ_P (oper->node.parent, NULL);
>> -		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
>> -		TEST_ALLOC_PARENT (oper->node.left, oper);
>> -		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
>> -		TEST_ALLOC_PARENT (oper->node.right, oper);
>> -
>> -		oper = (EventOperator *)job->start_on->node.left;
>> -		TEST_EQ (oper->type, EVENT_MATCH);
>> -		TEST_EQ_STR (oper->name, "wibble");
>> -		TEST_EQ_P (oper->env, NULL);
>> -
>> -		TEST_EQ_P (oper->node.parent, &job->start_on->node);
>> -		TEST_EQ_P (oper->node.left, NULL);
>> -		TEST_EQ_P (oper->node.right, NULL);
>> -
>> -		oper = (EventOperator *)job->start_on->node.right;
>> -		TEST_EQ (oper->type, EVENT_MATCH);
>> -		TEST_EQ_STR (oper->name, "wobble");
>> -		TEST_EQ_P (oper->env, NULL);
>> -
>> -		TEST_EQ_P (oper->node.parent, &job->start_on->node);
>> -		TEST_EQ_P (oper->node.left, NULL);
>> -		TEST_EQ_P (oper->node.right, NULL);
>> +		TEST_EQ (oper->type, EVENT_ANY);
>> +
>> +		got_wibble = FALSE;
>> +		got_wobble = FALSE;
>> +		EventOperator *parent = oper;
>> +		NIH_LIST_FOREACH (&oper->children, iter) {
>> +			EventOperator *child = (EventOperator *)iter;
>> +
>> +			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
>> +
>> +			TEST_LIST_EMPTY (&child->children);
>> +			TEST_EQ_P (child->env, NULL);
>> +			TEST_EQ (child->type, EVENT_MATCH);
>> +			if (!strncmp ("wibble", child->name, 7) && ! got_wibble)
>> +				got_wibble = TRUE;
>> +			else if (!strncmp ("wobble", child->name, 7) && ! got_wobble)
>> +				got_wobble = TRUE;
>> +			else
>> +				TEST_FAILED ("Unexpected child");
>> +		}
>>
>>   		nih_free (job);
>>   	}
> 
> List iteration should be separated by a gap.
> 
> Why are you using strncmp() here?
>

Again, the kittens.

> "if (! ...)" not "if (!...)"
> 
> "&& (! ...)" not "&& ! ..."
> 
> if/else without { } is punishable by death ;-)
> 
> TEST_FAILED should match the output of others
> 
> 
> (A couple of instances of these)
> 
> 
> Scott
>

--CJD

-- 
upstart-devel mailing list
upstart-devel@lists.ubuntu.com
Modify settings or unsubscribe at: https://lists.ubuntu.com/mailman/listinfo/upstart-devel

lp://qastaging/~cjdahlin/upstart/n-ary-event-oper updated on 2009-08-13

1187. By Casey Dahlin on 2009-08-12: * ChangeLog: Format fix
1188. By Casey Dahlin on 2009-08-13: * ChangeLog: More format fixes
1189. By Casey Dahlin on 2009-08-13: * init/event_operator.c: Fix static prototypes, rename ALL/ANY to AND/OR again
(event_operator_copy): Style fix
(event_operator_add_child, event_operator_update): Improve docstring
* init/event_operator.h, init/parse_job.c: Rename ALL/ANY back to AND/OR
* init/tests/test_event.c: Style fixes
* init/tests/test_event_operator.c: Style fixes
* init/tests/test_parse_job.c: Style fixes

Revision history for this message

Casey Dahlin (cjdahlin) wrote on 2009-08-13:

Download full text (78.0 KiB)

This should address most of the issues. I might have missed some, and
theres a few I'll need clarified. Go ahead and look though. (Also note
that the ChangeLog update is no longer complete).

=== modified file 'ChangeLog'
--- ChangeLog 2009-08-04 08:51:25 +0000
+++ ChangeLog 2009-08-13 00:01:12 +0000
@@ -1,3 +1,42 @@
+2009-08-11 Casey Dahlin <email address hidden>
+
+ * init/event_operator.h (EventOperatorType): Change types from AND/OR
+ to ANY/ALL
+ (EventOperator): Get rid of node entry and add children list.
+ * init/event_operator.c (event_operator_subtree_environment): New
+ version of event_operator_environment that assumes we are not at the
+ root of the tree.
+ (event_operator_new): Initialize new children member instead of tree
+ node.
+ (event_operator_copy): Use recursive call to correctly copy N-ary tree
+ (event_operator_reset): Use recursive call to correctly reset N-ary
+ tree
+ (event_operator_events): Use recursive call to correctly get events
+ from N-ary tree.
+ (event_operator_handle): Use recursive call to correctly handle N-ary
+ tree.
+ (event_operator_update): Update based on all N children
+ (event_operator_match): Don't assert based on now-defunct node
+ (event_operator_add_child): New helper to add a child to a tree,
+ automatically collapsing it into its new parent if it is the same type.
+ (event_operator_destroy): Destroy children list head correctly.
+ (event_operator_environment): Use new
+ event_operator_subtree_environment to recursively collect environment
+ variables.
+ * init/parse_job.c (parse_on_operator): Change AND/OR to ANY/ALL.
+ Change tree adds to event_operator_add_child calls.
+ (parse_on_collect): Change tree adds to event_operator_add_child calls
+ * init/tests/test_event.c (test_pending_handle_jobs): Fix structural
+ assumptions about EventOperator.
+ (test_finish): Change AND/OR to ANY/ALL
+ * init/tests/test_event_operator.c (everywhere): Fix structural
+ assumptions about EventOperator.
+ (test_operator_add_child): New test for this new helper.
+ * init/tests/test_job_process.c (everywhere): Fix structural
+ assumptions about EventOperator
+ * init/tests/test_parse_job.c (everywhere): Fix structural assumptions
+ about EventOperator
+
2009-08-04 Johan Kiviniemi <email address hidden>

* conf/rc-sysinit.conf: Don't replace DEFAULT_RUNLEVEL with an

=== modified file 'init/event_operator.c'
--- init/event_operator.c 2009-06-23 09:29:35 +0000
+++ init/event_operator.c 2009-08-13 00:39:09 +0000
@@ -44,6 +44,11 @@
#include "errors.h"

+static char **event_operator_subtree_environment (EventOperator *oper,
+ char ***env, const void *parent, size_t *len, const char *key,
+ char **evlist);
+
+
  /**
   * event_operator_new:
   * @parent: parent object for new operator,
@@ -85,7 +90,8 @@ event_operator_new (const void *
   if (! oper)
    return NULL;

- nih_tree_init (&oper->node);
+ nih_list_init (&oper->entry);
+ nih_list_init (&oper->children);

   oper->type = type;
   oper->value = FALSE;
@@ -163,30 +169,54 @@ event_operator_copy (const void
    event_block (oper->event);
   }

- if (old_oper->node.left) {
- child = event_operator_copy (
- oper, (EventOperator *)old_op...

This should address most of the issues. I might have missed some, and 
theres a few I'll need clarified. Go ahead and look though. (Also note
that the ChangeLog update is no longer complete).

=== modified file 'ChangeLog'
--- ChangeLog	2009-08-04 08:51:25 +0000
+++ ChangeLog	2009-08-13 00:01:12 +0000
@@ -1,3 +1,42 @@
+2009-08-11  Casey Dahlin  <cdahlin@redhat.com>
+
+	* init/event_operator.h (EventOperatorType): Change types from AND/OR
+	to ANY/ALL
+	(EventOperator): Get rid of node entry and add children list.
+	* init/event_operator.c (event_operator_subtree_environment): New
+	version of event_operator_environment that assumes we are not at the
+	root of the tree.
+	(event_operator_new): Initialize new children member instead of tree
+	node.
+	(event_operator_copy): Use recursive call to correctly copy N-ary tree
+	(event_operator_reset): Use recursive call to correctly reset N-ary
+	tree
+	(event_operator_events): Use recursive call to correctly get events
+	from N-ary tree.
+	(event_operator_handle): Use recursive call to correctly handle N-ary
+	tree.
+	(event_operator_update): Update based on all N children
+	(event_operator_match): Don't assert based on now-defunct node
+	(event_operator_add_child): New helper to add a child to a tree,
+	automatically collapsing it into its new parent if it is the same type.
+	(event_operator_destroy): Destroy children list head correctly.
+	(event_operator_environment): Use new
+	event_operator_subtree_environment to recursively collect environment
+	variables.
+	* init/parse_job.c (parse_on_operator): Change AND/OR to ANY/ALL.
+	Change tree adds to event_operator_add_child calls.
+	(parse_on_collect): Change tree adds to event_operator_add_child calls
+	* init/tests/test_event.c (test_pending_handle_jobs): Fix structural
+	assumptions about EventOperator.
+	(test_finish): Change AND/OR to ANY/ALL
+	* init/tests/test_event_operator.c (everywhere): Fix structural
+	assumptions about EventOperator.
+	(test_operator_add_child): New test for this new helper.
+	* init/tests/test_job_process.c (everywhere): Fix structural
+	assumptions about EventOperator
+	* init/tests/test_parse_job.c (everywhere): Fix structural assumptions
+	about EventOperator
+
  2009-08-04  Johan Kiviniemi  <johan@kiviniemi.name>

* conf/rc-sysinit.conf: Don't replace DEFAULT_RUNLEVEL with an

=== modified file 'init/event_operator.c'
--- init/event_operator.c	2009-06-23 09:29:35 +0000
+++ init/event_operator.c	2009-08-13 00:39:09 +0000
@@ -44,6 +44,11 @@
  #include "errors.h"

+static char **event_operator_subtree_environment (EventOperator *oper,
+		char ***env, const void *parent, size_t *len, const char *key,
+		char **evlist);
+
+
  /**
   * event_operator_new:
   * @parent: parent object for new operator,
@@ -85,7 +90,8 @@ event_operator_new (const void         *
  	if (! oper)
  		return NULL;

-	nih_tree_init (&oper->node);
+	nih_list_init (&oper->entry);
+	nih_list_init (&oper->children);

oper->type = type;
  	oper->value = FALSE;
@@ -163,30 +169,54 @@ event_operator_copy (const void
  		event_block (oper->event);
  	}

-	if (old_oper->node.left) {
-		child = event_operator_copy (
-			oper, (EventOperator *)old_oper->node.left);
+	NIH_LIST_FOREACH (&old_oper->children, iter) {
+		EventOperator *old_child = (EventOperator *)iter;
+		EventOperator *child;
+
+		child = event_operator_copy (oper, old_child);
  		if (! child) {
  			nih_free (oper);
  			return NULL;
  		}

-		nih_tree_add (&oper->node, &child->node, NIH_TREE_LEFT);
+		event_operator_add_child (oper, child);
  	}

+	return oper;
+}

-	if (old_oper->node.right) {
-		child = event_operator_copy (
-			oper, (EventOperator *)old_oper->node.right);
-		if (! child) {
-			nih_free (oper);
-			return NULL;
-		}
+/**
+ * event_operator_add_child:
+ * @oper: oper to add child to,
+ * @child: child to add.
+ *
+ * Makes @child a child of @oper. If @child and @oper are the same 
type, then
+ * @oper simply steals all of @child's children.
+ *
+ * @child may be referenced by the new parent, and if it is not, it is 
in an
+ * undefined state at the end of the operation. Consequently all other
+ * references to child should be dropped after this call.
+ **/
+void
+event_operator_add_child (EventOperator *oper, EventOperator *child)
+{
+	nih_assert (oper != NULL);
+	nih_assert (child != NULL);
+	nih_assert (oper->type != EVENT_MATCH);

-		nih_tree_add (&oper->node, &child->node, NIH_TREE_RIGHT);
+	if (child->type != oper->type) {
+		nih_ref (child, oper);
+		nih_list_add (&oper->children, &child->entry);
+		return;
  	}

-	return oper;
+	NIH_LIST_FOREACH_SAFE (&child->children, iter) {
+		EventOperator *grandchild = (EventOperator *)iter;
+
+		nih_ref (grandchild, oper);
+		nih_unref (grandchild, child);
+		nih_list_add (&oper->children, &grandchild->entry);
+	}
  }

/**
@@ -209,7 +239,7 @@ event_operator_destroy (EventOperator *o
  	if (oper->event)
  		event_unblock (oper->event);

-	nih_tree_destroy (&oper->node);
+	nih_list_destroy (&oper->entry);

return 0;
  }
@@ -223,28 +253,29 @@ event_operator_destroy (EventOperator *o
   * when combined with the particular operation this represents.
   *
   * This may only be called if the type of @oper is EVENT_OR or EVENT_AND.
+ *
+ * If @oper is of type EVENT_OR the function will set its value to 
FALSE, then
+ * scan the children. If it finds one child with a value of TRUE it 
will set
+ * @oper's value to TRUE and return.
+ *
+ * For EVENT_AND the procedure is reversed. @oper is given a value of 
TRUE, and
+ * is changed to FALSE if one FALSE child is discovered.
   **/
  void
  event_operator_update (EventOperator *oper)
  {
-	EventOperator *left, *right;
-
  	nih_assert (oper != NULL);
-	nih_assert (oper->node.left != NULL);
-	nih_assert (oper->node.right != NULL);
+	nih_assert (oper->type != EVENT_MATCH);

-	left = (EventOperator *)oper->node.left;
-	right = (EventOperator *)oper->node.right;
+	oper->value = (oper->type == EVENT_AND) ? TRUE : FALSE;

-	switch (oper->type) {
-	case EVENT_OR:
-		oper->value = (left->value || right->value);
-		break;
-	case EVENT_AND:
-		oper->value = (left->value && right->value);
-		break;
-	default:
-		nih_assert_not_reached ();
+	NIH_LIST_FOREACH (&oper->children, iter) {
+		EventOperator *child = (EventOperator *)iter;
+
+		if (child->value != oper->value) {
+			oper->value = child->value;
+			return;
+		}
  	}
  }

@@ -280,8 +311,6 @@ event_operator_match (EventOperator *ope

nih_assert (oper != NULL);
  	nih_assert (oper->type == EVENT_MATCH);
-	nih_assert (oper->node.left == NULL);
-	nih_assert (oper->node.right == NULL);
  	nih_assert (event != NULL);

/* Names must match */
@@ -391,29 +420,30 @@ event_operator_handle (EventOperator *ro
  	 * before we update the node itself.  Simply iterate the tree and
  	 * update the nodes.
  	 */
-	NIH_TREE_FOREACH_POST (&root->node, iter) {
+	NIH_LIST_FOREACH (&root->children, iter) {
  		EventOperator *oper = (EventOperator *)iter;

-		switch (oper->type) {
-		case EVENT_OR:
-		case EVENT_AND:
-			event_operator_update (oper);
-			break;
-		case EVENT_MATCH:
-			if ((! oper->value)
-			    && event_operator_match (oper, event, env)) {
-				oper->value = TRUE;
+		ret = ret || event_operator_handle (oper, event, env);
+	}

-				oper->event = event;
-				event_block (oper->event);
+	switch (root->type) {
+	case EVENT_OR:
+	case EVENT_AND:
+		event_operator_update (root);
+		break;
+	case EVENT_MATCH:
+		if ((! root->value)
+		    && event_operator_match (root, event, env)) {
+			root->value = TRUE;

-				ret = TRUE;
-			}
-			break;
-		default:
-			nih_assert_not_reached ();
-		}
+			root->event = event;
+			event_block (root->event);

+			ret = TRUE;
+		}
+		break;
+	default:
+		nih_assert_not_reached ();
  	}

return ret;
@@ -501,44 +531,77 @@ event_operator_environment (EventOperato
  			return NULL;
  	}

-	/* Iterate the operator tree, filtering out nodes with a non-TRUE
-	 * value and their children.  The rationale for this is that this
-	 * then matches only the events that had an active role in starting
-	 * the job, not the ones that were also blocked, but the other half
-	 * of their logic wasn't present.
+	if (! event_operator_subtree_environment (root, env, parent,
+					          len, key, &evlist))
+		return NULL;
+
+	/* Append the event list to the environment */
+	if (evlist)
+		if (! environ_add (env, parent, len, TRUE, evlist))
+			return NULL;
+
+	return *env;
+}
+
+/**
+ * event_operator_subtree_environment:
+ * @root: operator tree to collect from,
+ * @env: NULL-terminated array of environment variables to add to,
+ * @parent: parent object for new array,
+ * @len: length of @env,
+ * @key: key of variable to contain event names,
+ * @evlist: string in which to accumulate the event list.
+ *
+ * Does the work of event_operator_environment for one subtree.
+ **/
+
+static char**
+event_operator_subtree_environment (EventOperator   *oper,
+				    char          ***env,
+				    const void      *parent,
+				    size_t          *len,
+				    const char      *key,
+				    char           **evlist)
+{
+	/* Filtering out nodes with a non-TRUE value and their children. The
+	 * rationale for this is that this then matches only the events that had
+	 * an active role in starting the job, not the ones that were also
+	 * blocked, but the other half of their logic wasn't present.
  	 */
-	NIH_TREE_FOREACH_FULL (&root->node, iter,
-			       (NihTreeFilter)event_operator_filter, NULL) {
-		EventOperator *oper = (EventOperator *)iter;
+	if (! oper->value)
+		return *env;

-		if (oper->type != EVENT_MATCH)
-			continue;
+	if (oper->type != EVENT_MATCH) {
+		NIH_LIST_FOREACH(&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+			if (! event_operator_subtree_environment (child, env, parent,
+							          len, key, evlist))
+				return NULL;
+		}

-		nih_assert (oper->event != NULL);
+		return *env;
+	}

-		/* Add environment from the event */
-		if (! environ_append (env, parent, len, TRUE, oper->event->env))
-			return NULL;
+	nih_assert (oper->event != NULL);
+
+	/* Add environment from the event */
+	if (! environ_append (env, parent, len, TRUE, oper->event->env))
+		return NULL;

-		/* Append the name of the event to the string we're building */
-		if (evlist) {
-			if (evlist[strlen (evlist) - 1] != '=') {
-				if (! nih_strcat_sprintf (&evlist, NULL, " %s",
-							  oper->event->name))
-					return NULL;
-			} else {
-				if (! nih_strcat (&evlist, NULL,
+	/* Append the name of the event to the string we're building */
+	if (*evlist) {
+		if ((*evlist)[strlen (*evlist) - 1] != '=') {
+			if (! nih_strcat_sprintf (evlist, NULL, " %s",
  						  oper->event->name))
-					return NULL;
+				return NULL;
+		} else {
+			if (! nih_strcat (evlist, NULL,
+					  oper->event->name)) {
+				return NULL;
  			}
  		}
  	}

-	/* Append the event list to the environment */
-	if (evlist)
-		if (! environ_add (env, parent, len, TRUE, evlist))
-			return NULL;
-
  	return *env;
  }

@@ -564,31 +627,31 @@ event_operator_events (EventOperator *ro
  		       const void    *parent,
  		       NihList       *list)
  {
+	Blocked       *blocked;
+
  	nih_assert (root != NULL);
  	nih_assert (list != NULL);

-		if (oper->type != EVENT_MATCH)
-			continue;
+		event_operator_events (oper, parent, list);
+	}

-		nih_assert (oper->event != NULL);

-		blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT,
-						 oper->event));
-		nih_list_add (list, &blocked->entry);
+	if (root->type != EVENT_MATCH)
+		return;

-		event_block (blocked->event);
-	}
+	nih_assert (root->event != NULL);
+
+	blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT,
+					 root->event));
+	nih_list_add (list, &blocked->entry);
+
+	event_block (blocked->event);
  }

@@ -606,24 +669,26 @@ event_operator_reset (EventOperator *roo
  	nih_assert (root != NULL);

/* A post-order iteration means we visit children first, perfect! */
-	NIH_TREE_FOREACH_POST (&root->node, iter) {
+	NIH_LIST_FOREACH (&root->children, iter) {
  		EventOperator *oper = (EventOperator *)iter;

-		switch (oper->type) {
-		case EVENT_OR:
-		case EVENT_AND:
-			event_operator_update (oper);
-			break;
-		case EVENT_MATCH:
-			oper->value = FALSE;
-
-			if (oper->event) {
-				event_unblock (oper->event);
-				oper->event = NULL;
-			}
-			break;
-		default:
-			nih_assert_not_reached ();
+		event_operator_reset (oper);
+	}
+
+	switch (root->type) {
+	case EVENT_OR:
+	case EVENT_AND:
+		event_operator_update (root);
+		break;
+	case EVENT_MATCH:
+		root->value = FALSE;
+
+		if (root->event) {
+			event_unblock (root->event);
+			root->event = NULL;
  		}
+		break;
+	default:
+		nih_assert_not_reached ();
  	}
  }

=== modified file 'init/event_operator.h'
--- init/event_operator.h	2009-06-23 09:29:35 +0000
+++ init/event_operator.h	2009-08-13 00:39:09 +0000
@@ -40,7 +40,8 @@ typedef enum event_operator_type {

/**
   * EventOperator:
- * @node: tree node,
+ * @entry: sibling list entry,
+ * @children: list of children,
   * @type: operator type,
   * @value: operator value,
   * @name: name of event to match (EVENT_MATCH only),
@@ -50,18 +51,19 @@ typedef enum event_operator_type {
   * This structure is used to build up an event expression tree; the leaf
   * nodes are all of EVENT_MATCH type which match a specific event, the 
other
   * nodes are built up of EVENT_OR and EVENT_AND operators that combine the
- * EventOperators to their left and right in interesting ways.
+ * EventOperators which are their children in interesting ways.
   *
   * @value indicates whether this operator is currently TRUE or FALSE.
   * For EVENT_MATCH operators, a TRUE @value means that @event is set to
   * the matched event; for EVENT_OR and EVENT_AND operators, @value is set
- * depending on the value of both immediate children.
+ * depending on the value of the immediate children.
   *
   * Once an event has been matched, the @event member is set and a 
reference
   * held until the structure is cleared.
   **/
  typedef struct event_operator {
-	NihTree             node;
+	NihList             entry;
+	NihList             children;
  	EventOperatorType   type;

int                 value;
@@ -84,6 +86,8 @@ EventOperator *event_operator_copy
  	__attribute__ ((warn_unused_result, malloc));

int            event_operator_destroy     (EventOperator *oper);
+void           event_operator_add_child   (EventOperator *oper,
+		                           EventOperator *child);

void           event_operator_update      (EventOperator *oper);
  int            event_operator_match       (EventOperator *oper, Event 
*event,

=== modified file 'init/parse_job.c'
--- init/parse_job.c	2009-07-09 11:01:53 +0000
+++ init/parse_job.c	2009-08-13 00:39:09 +0000
@@ -665,10 +665,8 @@ parse_on_operator (JobClass         *cla
  	if (! oper)
  		nih_return_system_error (-1);

-	nih_ref (*root, oper);
+	event_operator_add_child (oper, *root);
  	nih_unref (*root, class);
-
-	nih_tree_add (&oper->node, &(*root)->node, NIH_TREE_LEFT);
  	*root = NULL;

/* Push the new operator onto the stack */
@@ -938,11 +936,8 @@ parse_on_collect (JobClass       *class,
  		 * event matches.
  		 */
  		if ((oper->type != EVENT_MATCH) && (*root)) {
-			nih_ref (*root, oper);
+			event_operator_add_child (oper, *root);
  			nih_unref (*root, class);
-
-			nih_tree_add (&oper->node, &(*root)->node,
-				      NIH_TREE_RIGHT);
  		} else if (oper->type != EVENT_MATCH) {
  			nih_return_error (-1, PARSE_EXPECTED_EVENT,
  					  _(PARSE_EXPECTED_EVENT_STR));

=== modified file 'init/tests/test_event.c'
--- init/tests/test_event.c	2009-08-04 00:19:41 +0000
+++ init/tests/test_event.c	2009-08-13 00:49:35 +0000
@@ -76,7 +76,7 @@ test_new (void)
  		TEST_LIST_NOT_EMPTY (&event->entry);

TEST_EQ (event->progress, EVENT_PENDING);
-		TEST_EQ (event->failed, FALSE);
+		TEST_FALSE (event->failed);

TEST_EQ (event->blockers, 0);
  		TEST_LIST_EMPTY (&event->blocking);
@@ -275,6 +275,7 @@ test_pending_handle_jobs (void)
  	EventOperator  *oper;
  	Blocked        *blocked = NULL, *blocked1 = NULL, *blocked2 = NULL;
  	char          **env1 = NULL, **env2 = NULL;
+	int             any_true = FALSE, all_true = TRUE;

TEST_FUNCTION ("event_pending_handle_jobs");
  	program_name = "test";
@@ -308,7 +309,7 @@ test_pending_handle_jobs (void)
  		TEST_HASH_EMPTY (class->instances);

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

nih_free (class);
@@ -335,13 +336,11 @@ test_pending_handle_jobs (void)

oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wibble", NULL);
-			nih_tree_add (&class->start_on->node, &oper->node,
-				      NIH_TREE_LEFT);
+			event_operator_add_child (class->start_on, oper);

oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wobble", NULL);
-			nih_tree_add (&class->start_on->node, &oper->node,
-				      NIH_TREE_RIGHT);
+			event_operator_add_child (class->start_on, oper);

nih_hash_add (job_classes, &class->entry);
  		}
@@ -355,16 +354,21 @@ test_pending_handle_jobs (void)
  		TEST_HASH_EMPTY (class->instances);

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

-		oper = (EventOperator *)class->start_on->node.left;
-		TEST_EQ (oper->value, TRUE);
-		TEST_EQ_P (oper->event, event1);
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;

-		oper = (EventOperator *)class->start_on->node.right;
-		TEST_EQ (oper->value, FALSE);
-		TEST_EQ_P (oper->event, NULL);
+			any_true = any_true || child->value;
+			all_true = all_true && child->value;
+		}
+
+		TEST_TRUE (any_true);
+		TEST_FALSE (all_true);
+		
+		any_true = FALSE;
+		all_true = TRUE;

nih_free (class);
  		nih_free (event1);
@@ -399,13 +403,11 @@ test_pending_handle_jobs (void)

nih_hash_add (job_classes, &class->entry);
  		}
@@ -444,17 +446,21 @@ test_pending_handle_jobs (void)

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

-		oper = (EventOperator *)class->start_on->node.left;
-		TEST_EQ (oper->value, FALSE);
-		TEST_EQ_P (oper->event, NULL);
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;

+		TEST_FALSE (any_true);
+		TEST_FALSE (all_true);
+		
+		any_true = FALSE;
+		all_true = TRUE;

TEST_LIST_NOT_EMPTY (&job->blocking);

@@ -515,13 +521,11 @@ test_pending_handle_jobs (void)

nih_hash_add (job_classes, &class->entry);
  		}
@@ -570,15 +574,20 @@ test_pending_handle_jobs (void)

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);

-		oper = (EventOperator *)class->start_on->node.right;
-		TEST_EQ (oper->value, FALSE);
-		TEST_EQ_P (oper->event, NULL);
+			any_true = any_true || child->value;
+			all_true = all_true && child->value;
+		}
+
+		TEST_FALSE (any_true);
+		TEST_FALSE (all_true);
+		
+		any_true = FALSE;
+		all_true = TRUE;

TEST_LIST_NOT_EMPTY (&job->blocking);
@@ -641,13 +650,11 @@ test_pending_handle_jobs (void)

nih_hash_add (job_classes, &class->entry);

@@ -734,15 +741,20 @@ test_pending_handle_jobs (void)
  		TEST_EQ_P (job->start_env[8], NULL);

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);

-		oper = (EventOperator *)class->start_on->node.right;
-		TEST_EQ (oper->value, FALSE);
-		TEST_EQ_P (oper->event, NULL);
+			any_true = any_true || child->value;
+			all_true = all_true && child->value;
+		}
+
+		TEST_FALSE (any_true);
+		TEST_FALSE (all_true);
+		
+		any_true = FALSE;
+		all_true = TRUE;

TEST_FREE (blocked1);
  		TEST_FREE (blocked2);
@@ -809,13 +821,11 @@ test_pending_handle_jobs (void)

nih_hash_add (job_classes, &class->entry);

@@ -884,15 +894,20 @@ test_pending_handle_jobs (void)
  		TEST_EQ_P (job->start_env, env2);

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);

-		oper = (EventOperator *)class->start_on->node.right;
-		TEST_EQ (oper->value, FALSE);
-		TEST_EQ_P (oper->event, NULL);
+			any_true = any_true || child->value;
+			all_true = all_true && child->value;
+		}
+
+		TEST_FALSE (any_true);
+		TEST_FALSE (all_true);
+		
+		any_true = FALSE;
+		all_true = TRUE;

TEST_LIST_NOT_EMPTY (&job->blocking);
  		TEST_NOT_FREE (blocked1);
@@ -966,7 +981,7 @@ test_pending_handle_jobs (void)

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

@@ -1046,7 +1061,7 @@ test_pending_handle_jobs (void)
  		TEST_EQ (job->state, JOB_STOPPING);

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

TEST_FREE (event3);
@@ -1104,7 +1119,7 @@ test_pending_handle_jobs (void)
  		TEST_HASH_EMPTY (class->instances);

oper = class->start_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

TEST_FILE_EQ (output, ("test: Failed to obtain test instance: "
@@ -1152,11 +1167,11 @@ test_pending_handle_jobs (void)
  		job = (Job *)nih_hash_lookup (class->instances, "");

oper = job->stop_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

oper = class->stop_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

nih_free (class);
@@ -1216,7 +1231,7 @@ test_pending_handle_jobs (void)

oper = job->stop_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

@@ -1295,7 +1310,7 @@ test_pending_handle_jobs (void)

oper = job->stop_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

@@ -1400,7 +1415,7 @@ test_pending_handle_jobs (void)

oper = job->stop_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

@@ -1494,7 +1509,7 @@ test_pending_handle_jobs (void)
  		TEST_EQ_P (job->stop_env, env1);

oper = job->stop_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

TEST_NOT_FREE (event3);
@@ -1578,7 +1593,7 @@ test_pending_handle_jobs (void)

oper = job->stop_on;
-		TEST_EQ (oper->value, FALSE);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->event, NULL);

@@ -1708,13 +1723,11 @@ test_finished (void)

oper = event_operator_new (class, EVENT_MATCH,
  						   "test/failed", NULL);
-			nih_tree_add (&class->start_on->node, &oper->node,
-				      NIH_TREE_LEFT);
+			event_operator_add_child (class->start_on, oper);

oper = event_operator_new (class, EVENT_MATCH,
  						   "test/failed/failed", NULL);
-			nih_tree_add (&class->start_on->node, &oper->node,
-				      NIH_TREE_RIGHT);
+			event_operator_add_child (class->start_on, oper);

nih_hash_add (job_classes, &class->entry);
  		}

=== modified file 'init/tests/test_event_operator.c'
--- init/tests/test_event_operator.c	2009-08-04 00:20:04 +0000
+++ init/tests/test_event_operator.c	2009-08-13 00:49:35 +0000
@@ -53,10 +53,8 @@ test_operator_new (void)
  		}

TEST_ALLOC_SIZE (oper, sizeof (EventOperator));
-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-		TEST_EQ (oper->value, FALSE);
+		TEST_LIST_EMPTY (&oper->children);
+		TEST_FALSE (oper->value);
  		TEST_EQ_STR (oper->name, "test");
  		TEST_ALLOC_PARENT (oper->name, oper);

@@ -92,10 +90,8 @@ test_operator_new (void)
  		nih_discard (env);

@@ -119,10 +115,8 @@ test_operator_new (void)
  		}

TEST_ALLOC_SIZE (oper, sizeof (EventOperator));
-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-		TEST_EQ (oper->value, FALSE);
+		TEST_LIST_EMPTY (&oper->children);
+		TEST_FALSE (oper->value);
  		TEST_EQ_P (oper->name, NULL);
  		TEST_EQ_P (oper->env, NULL);
  		TEST_EQ_P (oper->event, NULL);
@@ -159,11 +153,9 @@ test_operator_copy (void)
  		}

@@ -279,11 +267,9 @@ test_operator_copy (void)
  		}

TEST_ALLOC_SIZE (copy, sizeof (EventOperator));
-		TEST_EQ_P (copy->node.parent, NULL);
-		TEST_EQ_P (copy->node.left, NULL);
-		TEST_EQ_P (copy->node.right, NULL);
+		TEST_LIST_EMPTY (&copy->children);
  		TEST_EQ (copy->type, EVENT_MATCH);
-		TEST_EQ (copy->value, TRUE);
+		TEST_TRUE (copy->value);
  		TEST_EQ_STR (copy->name, "test");
  		TEST_ALLOC_PARENT (copy->name, copy);
  		TEST_EQ_P (copy->env, NULL);
@@ -310,47 +296,39 @@ test_operator_copy (void)
  			oper1->value = TRUE;
  			oper1->event = event_new (oper1, "foo", NULL);
  			event_block (oper1->event);
-			nih_tree_add (&oper->node, &oper1->node,
-				      NIH_TREE_LEFT);
+			event_operator_add_child (oper, oper1);

oper2 = event_operator_new (NULL, EVENT_MATCH,
  						    "bar", NULL);
  			oper2->value = TRUE;
  			oper2->event = event_new (oper2, "foo", NULL);
  			event_block (oper2->event);
-			nih_tree_add (&oper->node, &oper2->node,
-				      NIH_TREE_RIGHT);
+			event_operator_add_child (oper, oper2);
  		}

copy = event_operator_copy (NULL, oper);

if (test_alloc_failed) {
  			TEST_EQ_P (copy, NULL);
-			nih_free (oper);
  			TEST_EQ (oper1->event->blockers, 1);
-			nih_free (oper1);
  			TEST_EQ (oper2->event->blockers, 1);
-			nih_free (oper2);
+			nih_free (oper);
  			continue;
  		}

TEST_ALLOC_SIZE (copy, sizeof (EventOperator));
-		TEST_EQ_P (copy->node.parent, NULL);
-		TEST_NE_P (copy->node.left, NULL);
-		TEST_NE_P (copy->node.right, NULL);
+		TEST_LIST_NOT_EMPTY (&copy->children);
  		TEST_EQ (copy->type, EVENT_OR);
-		TEST_EQ (copy->value, TRUE);
+		TEST_TRUE (copy->value);
  		TEST_EQ_P (copy->name, NULL);
  		TEST_EQ_P (copy->env, NULL);

-		copy1 = (EventOperator *)copy->node.left;
+		copy1 = (EventOperator *)copy->children.next;
  		TEST_ALLOC_SIZE (copy1, sizeof (EventOperator));
  		TEST_ALLOC_PARENT (copy1, copy);
-		TEST_EQ_P (copy1->node.parent, &copy->node);
-		TEST_EQ_P (copy1->node.left, NULL);
-		TEST_EQ_P (copy1->node.right, NULL);
+		TEST_LIST_EMPTY (&copy1->children);
  		TEST_EQ (copy1->type, EVENT_MATCH);
-		TEST_EQ (copy1->value, TRUE);
+		TEST_TRUE (copy1->value);
  		TEST_EQ_STR (copy1->name, "foo");
  		TEST_ALLOC_PARENT (copy1->name, copy1);
  		TEST_EQ_P (copy1->env, NULL);
@@ -360,14 +338,12 @@ test_operator_copy (void)

nih_free (copy1);

-		copy2 = (EventOperator *)copy->node.right;
+		copy2 = (EventOperator *)copy1->entry.next;
  		TEST_ALLOC_SIZE (copy2, sizeof (EventOperator));
  		TEST_ALLOC_PARENT (copy2, copy);
-		TEST_EQ_P (copy2->node.parent, &copy->node);
-		TEST_EQ_P (copy2->node.left, NULL);
-		TEST_EQ_P (copy2->node.right, NULL);
+		TEST_LIST_EMPTY (&copy1->children);
  		TEST_EQ (copy2->type, EVENT_MATCH);
-		TEST_EQ (copy2->value, TRUE);
+		TEST_TRUE (copy2->value);
  		TEST_EQ_STR (copy2->name, "bar");
  		TEST_ALLOC_PARENT (copy2->name, copy2);
  		TEST_EQ_P (copy2->env, NULL);
@@ -434,8 +410,8 @@ test_operator_update (void)
  	oper2 = event_operator_new (NULL, EVENT_MATCH, "foo", NULL);
  	oper3 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);

-	nih_tree_add (&oper1->node, &oper2->node, NIH_TREE_LEFT);
-	nih_tree_add (&oper1->node, &oper3->node, NIH_TREE_RIGHT);
+	event_operator_add_child (oper1, oper2);
+	event_operator_add_child (oper1, oper3);

/* Check that EVENT_OR is FALSE if both children are FALSE. */
@@ -444,7 +420,7 @@ test_operator_update (void)

event_operator_update (oper1);

-	TEST_EQ (oper1->value, FALSE);
+	TEST_FALSE (oper1->value);

/* Check that EVENT_OR is TRUE if only the left child is TRUE. */
@@ -454,7 +430,7 @@ test_operator_update (void)

event_operator_update (oper1);

-	TEST_EQ (oper1->value, TRUE);
+	TEST_TRUE (oper1->value);

/* Check that EVENT_OR is TRUE if only the right child is TRUE. */
@@ -464,7 +440,7 @@ test_operator_update (void)

event_operator_update (oper1);

-	TEST_EQ (oper1->value, TRUE);
+	TEST_TRUE (oper1->value);

/* Check that EVENT_OR is TRUE if both children are TRUE. */
@@ -474,7 +450,7 @@ test_operator_update (void)

event_operator_update (oper1);

-	TEST_EQ (oper1->value, TRUE);
+	TEST_TRUE (oper1->value);

/* Check that EVENT_AND is FALSE if both children are FALSE. */
@@ -484,7 +460,7 @@ test_operator_update (void)

event_operator_update (oper1);

-	TEST_EQ (oper1->value, FALSE);
+	TEST_FALSE (oper1->value);

/* Check that EVENT_AND is FALSE if only the left child is TRUE. */
@@ -494,7 +470,7 @@ test_operator_update (void)

event_operator_update (oper1);

-	TEST_EQ (oper1->value, FALSE);
+	TEST_FALSE (oper1->value);

/* Check that EVENT_AND is FALSE if only the right child is TRUE. */
@@ -504,7 +480,7 @@ test_operator_update (void)

event_operator_update (oper1);

-	TEST_EQ (oper1->value, FALSE);
+	TEST_FALSE (oper1->value);

/* Check that EVENT_AND is TRUE if both children are TRUE. */
@@ -514,12 +490,10 @@ test_operator_update (void)

event_operator_update (oper1);

-	TEST_EQ (oper1->value, TRUE);
+	TEST_TRUE (oper1->value);

nih_free (oper1);
-	nih_free (oper2);
-	nih_free (oper3);
  }

void
@@ -813,10 +787,10 @@ test_operator_handle (void)
  	oper5->env[0] = "BAR=$WIBBLE";
  	oper5->env[1] = NULL;

-	nih_tree_add (&oper1->node, &oper2->node, NIH_TREE_LEFT);
-	nih_tree_add (&oper2->node, &oper3->node, NIH_TREE_LEFT);
-	nih_tree_add (&oper2->node, &oper4->node, NIH_TREE_RIGHT);
-	nih_tree_add (&oper1->node, &oper5->node, NIH_TREE_RIGHT);
+	event_operator_add_child (oper1, oper2);
+	event_operator_add_child (oper2, oper3);
+	event_operator_add_child (oper2, oper4);
+	event_operator_add_child (oper1, oper5);

/* Check that a non-matching event doesn't touch the tree. */
@@ -824,14 +798,14 @@ test_operator_handle (void)
  	event = event_new (NULL, "frodo", NULL);
  	ret = event_operator_handle (oper1, event, NULL);

-	TEST_EQ (ret, FALSE);
-	TEST_EQ (oper1->value, FALSE);
-	TEST_EQ (oper2->value, FALSE);
-	TEST_EQ (oper3->value, FALSE);
+	TEST_FALSE (ret);
+	TEST_FALSE (oper1->value);
+	TEST_FALSE (oper2->value);
+	TEST_FALSE (oper3->value);
  	TEST_EQ_P (oper3->event, NULL);
-	TEST_EQ (oper4->value, FALSE);
+	TEST_FALSE (oper4->value);
  	TEST_EQ_P (oper4->event, NULL);
-	TEST_EQ (oper5->value, FALSE);
+	TEST_FALSE (oper5->value);
  	TEST_EQ_P (oper5->event, NULL);

TEST_EQ (event->blockers, 0);
@@ -846,14 +820,14 @@ test_operator_handle (void)
  	event = event_new (NULL, "foo", NULL);
  	ret = event_operator_handle (oper1, event, NULL);

-	TEST_EQ (ret, TRUE);
-	TEST_EQ (oper1->value, FALSE);
-	TEST_EQ (oper2->value, FALSE);
-	TEST_EQ (oper3->value, TRUE);
+	TEST_TRUE (ret);
+	TEST_FALSE (oper1->value);
+	TEST_FALSE (oper2->value);
+	TEST_TRUE (oper3->value);
  	TEST_EQ_P (oper3->event, event);
-	TEST_EQ (oper4->value, FALSE);
+	TEST_FALSE (oper4->value);
  	TEST_EQ_P (oper4->event, NULL);
-	TEST_EQ (oper5->value, FALSE);
+	TEST_FALSE (oper5->value);
  	TEST_EQ_P (oper5->event, NULL);

TEST_EQ (event->blockers, 1);
@@ -869,15 +843,15 @@ test_operator_handle (void)

ret = event_operator_handle (oper1, event, NULL);

-	TEST_EQ (ret, FALSE);
-	TEST_EQ (oper1->value, FALSE);
-	TEST_EQ (oper2->value, FALSE);
-	TEST_EQ (oper3->value, TRUE);
+	TEST_FALSE (ret);
+	TEST_FALSE (oper1->value);
+	TEST_FALSE (oper2->value);
+	TEST_TRUE (oper3->value);
  	TEST_NE_P (oper3->event, event);
  	TEST_NOT_FREE (oper3->event);
-	TEST_EQ (oper4->value, FALSE);
+	TEST_FALSE (oper4->value);
  	TEST_EQ_P (oper4->event, NULL);
-	TEST_EQ (oper5->value, FALSE);
+	TEST_FALSE (oper5->value);
  	TEST_EQ_P (oper5->event, NULL);

TEST_EQ (event->blockers, 0);
@@ -893,14 +867,14 @@ test_operator_handle (void)
  	event = event_new (NULL, "bar", NULL);
  	ret = event_operator_handle (oper1, event, NULL);

-	TEST_EQ (ret, TRUE);
-	TEST_EQ (oper1->value, TRUE);
-	TEST_EQ (oper2->value, TRUE);
-	TEST_EQ (oper3->value, TRUE);
+	TEST_TRUE (ret);
+	TEST_TRUE (oper1->value);
+	TEST_TRUE (oper2->value);
+	TEST_TRUE (oper3->value);
  	TEST_NE_P (oper3->event, NULL);
-	TEST_EQ (oper4->value, TRUE);
+	TEST_TRUE (oper4->value);
  	TEST_EQ_P (oper4->event, event);
-	TEST_EQ (oper5->value, FALSE);
+	TEST_FALSE (oper5->value);
  	TEST_EQ_P (oper5->event, NULL);

TEST_EQ (event->blockers, 1);
@@ -922,14 +896,14 @@ test_operator_handle (void)
  	env[1] = NULL;
  	ret = event_operator_handle (oper1, event, env);

-	TEST_EQ (ret, TRUE);
-	TEST_EQ (oper1->value, TRUE);
-	TEST_EQ (oper2->value, FALSE);
-	TEST_EQ (oper3->value, FALSE);
+	TEST_TRUE (ret);
+	TEST_TRUE (oper1->value);
+	TEST_FALSE (oper2->value);
+	TEST_FALSE (oper3->value);
  	TEST_EQ_P (oper4->event, NULL);
-	TEST_EQ (oper4->value, FALSE);
+	TEST_FALSE (oper4->value);
  	TEST_EQ_P (oper4->event, NULL);
-	TEST_EQ (oper5->value, TRUE);
+	TEST_TRUE (oper5->value);
  	TEST_EQ_P (oper5->event, event);

TEST_EQ (event->blockers, 1);
@@ -938,10 +912,6 @@ test_operator_handle (void)
  	event_operator_reset (oper1);

nih_free (oper1);
-	nih_free (oper2);
-	nih_free (oper3);
-	nih_free (oper4);
-	nih_free (oper5);

event_poll ();
  }
@@ -964,12 +934,12 @@ test_operator_environment (void)
  	oper5 = event_operator_new (root, EVENT_MATCH, "frodo", NULL);
  	oper6 = event_operator_new (root, EVENT_MATCH, "bilbo", NULL);

-	nih_tree_add (&root->node, &oper1->node, NIH_TREE_LEFT);
-	nih_tree_add (&root->node, &oper2->node, NIH_TREE_RIGHT);
-	nih_tree_add (&oper1->node, &oper3->node, NIH_TREE_LEFT);
-	nih_tree_add (&oper1->node, &oper4->node, NIH_TREE_RIGHT);
-	nih_tree_add (&oper2->node, &oper5->node, NIH_TREE_LEFT);
-	nih_tree_add (&oper2->node, &oper6->node, NIH_TREE_RIGHT);
+	event_operator_add_child (root, oper1);
+	event_operator_add_child (root, oper2);
+	event_operator_add_child (oper1, oper3);
+	event_operator_add_child (oper1, oper4);
+	event_operator_add_child (oper2, oper5);
+	event_operator_add_child (oper2, oper6);

root->value = TRUE;

@@ -1132,12 +1102,12 @@ test_operator_events (void)
  	oper5 = event_operator_new (root, EVENT_MATCH, "frodo", NULL);
  	oper6 = event_operator_new (root, EVENT_MATCH, "bilbo", NULL);

root->value = TRUE;

@@ -1238,10 +1208,10 @@ test_operator_reset (void)
  	oper4 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);
  	oper5 = event_operator_new (NULL, EVENT_MATCH, "baz", NULL);

event1 = event_new (NULL, "foo", NULL);
  	event2 = event_new (NULL, "bar", NULL);
@@ -1249,40 +1219,98 @@ test_operator_reset (void)
  	event_operator_handle (oper1, event1, NULL);
  	event_operator_handle (oper1, event2, NULL);

-	TEST_EQ (oper1->value, TRUE);
-	TEST_EQ (oper2->value, TRUE);
-	TEST_EQ (oper3->value, TRUE);
+	TEST_TRUE (oper1->value);
+	TEST_TRUE (oper2->value);
+	TEST_TRUE (oper3->value);
  	TEST_EQ_P (oper3->event, event1);
-	TEST_EQ (oper4->value, TRUE);
+	TEST_TRUE (oper4->value);
  	TEST_EQ (oper4->event, event2);
-	TEST_EQ (oper5->value, FALSE);
+	TEST_FALSE (oper5->value);

TEST_EQ (event1->blockers, 1);
  	TEST_EQ (event2->blockers, 1);

event_operator_reset (oper1);

-	TEST_EQ (oper1->value, FALSE);
-	TEST_EQ (oper2->value, FALSE);
-	TEST_EQ (oper3->value, FALSE);
+	TEST_FALSE (oper1->value);
+	TEST_FALSE (oper2->value);
+	TEST_FALSE (oper3->value);
  	TEST_EQ_P (oper3->event, NULL);
-	TEST_EQ (oper4->value, FALSE);
+	TEST_FALSE (oper4->value);
  	TEST_EQ (oper4->event, NULL);
-	TEST_EQ (oper5->value, FALSE);
+	TEST_FALSE (oper5->value);

TEST_EQ (event1->blockers, 0);
  	TEST_EQ (event2->blockers, 0);

nih_free (oper1);
-	nih_free (oper2);
-	nih_free (oper3);
-	nih_free (oper4);
-	nih_free (oper5);

event_poll ();
  }

+void
+test_operator_add_child (void)
+{
+	EventOperator *oper1, *oper2, *oper3, *oper4, *oper5, *oper6, *oper7;
+	int found_foo = 0;
+	int found_bar = 0;
+	int found_baz = 0;
+	int found_bam = 0;
+	int found_all = 0;
+
+	TEST_FUNCTION ("event_operator_add_child");
+	oper1 = event_operator_new (NULL, EVENT_OR, NULL, NULL);
+	oper2 = event_operator_new (NULL, EVENT_AND, NULL, NULL);
+	oper3 = event_operator_new (NULL, EVENT_MATCH, "foo", NULL);
+	oper4 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);
+	oper5 = event_operator_new (NULL, EVENT_MATCH, "baz", NULL);
+	oper6 = event_operator_new (NULL, EVENT_MATCH, "bam", NULL);
+	oper7 = event_operator_new (NULL, EVENT_OR, NULL, NULL);
+
+	event_operator_add_child (oper2, oper3);
+	event_operator_add_child (oper2, oper4);
+	event_operator_add_child (oper7, oper5);
+	event_operator_add_child (oper7, oper6);
+	event_operator_add_child (oper1, oper2);
+	event_operator_add_child (oper1, oper7);
+
+	TEST_EQ (oper1->type, EVENT_OR);
+
+	NIH_LIST_FOREACH (&oper1->children, iter) {
+		EventOperator *child = (EventOperator *)iter;
+
+		if (child->type == EVENT_AND) {
+			found_all++;
+			continue;
+		}
+
+		TEST_EQ (child->type, EVENT_MATCH);
+
+		if (! strncmp (child->name, "foo", 4))
+			found_foo++;
+
+		if (! strncmp (child->name, "bar", 4))
+			found_bar++;
+
+		if (! strncmp (child->name, "baz", 4))
+			found_baz++;
+
+		if (! strncmp (child->name, "bam", 4))
+			found_bam++;
+	}
+
+	/* Not a truth test. 2 is also a failure. */
+	TEST_EQ (found_all, 1);
+	TEST_EQ (found_foo, 0);
+	TEST_EQ (found_bar, 0);
+	TEST_EQ (found_baz, 1);
+	TEST_EQ (found_bam, 1);
+
+	nih_free (oper1);
+}
+
+
  int
  main (int   argc,
        char *argv[])
@@ -1296,6 +1324,7 @@ main (int   argc,
  	test_operator_environment ();
  	test_operator_events ();
  	test_operator_reset ();
+	test_operator_add_child ();

return 0;
  }

=== modified file 'init/tests/test_parse_job.c'
--- init/tests/test_parse_job.c	2009-07-09 11:01:53 +0000
+++ init/tests/test_parse_job.c	2009-08-13 00:49:35 +0000
@@ -87,14 +87,14 @@ test_parse_job (void)
  		process = job->process[PROCESS_MAIN];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/sbin/daemon -d");

process = job->process[PROCESS_PRE_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "rm /var/lock/daemon\n");

@@ -174,7 +174,7 @@ test_stanza_exec (void)
  		process = job->process[PROCESS_MAIN];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/sbin/daemon -d \"foo\"");

@@ -211,7 +211,7 @@ test_stanza_exec (void)
  		process = job->process[PROCESS_MAIN];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/sbin/daemon -d \"foo\"");

@@ -250,7 +250,7 @@ test_stanza_exec (void)
  		process = job->process[PROCESS_MAIN];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/sbin/daemon -d \"foo\"");

@@ -320,7 +320,7 @@ test_stanza_script (void)
  		process = job->process[PROCESS_MAIN];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -361,7 +361,7 @@ test_stanza_script (void)
  		process = job->process[PROCESS_MAIN];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -400,7 +400,7 @@ test_stanza_script (void)
  		process = job->process[PROCESS_MAIN];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -468,7 +468,7 @@ test_stanza_pre_start (void)
  		process = job->process[PROCESS_PRE_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -505,7 +505,7 @@ test_stanza_pre_start (void)
  		process = job->process[PROCESS_PRE_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -545,7 +545,7 @@ test_stanza_pre_start (void)
  		process = job->process[PROCESS_PRE_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -586,7 +586,7 @@ test_stanza_pre_start (void)
  		process = job->process[PROCESS_PRE_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -625,7 +625,7 @@ test_stanza_pre_start (void)
  		process = job->process[PROCESS_PRE_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -664,7 +664,7 @@ test_stanza_pre_start (void)
  		process = job->process[PROCESS_PRE_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -789,7 +789,7 @@ test_stanza_post_start (void)
  		process = job->process[PROCESS_POST_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -826,7 +826,7 @@ test_stanza_post_start (void)
  		process = job->process[PROCESS_POST_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -866,7 +866,7 @@ test_stanza_post_start (void)
  		process = job->process[PROCESS_POST_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -907,7 +907,7 @@ test_stanza_post_start (void)
  		process = job->process[PROCESS_POST_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -946,7 +946,7 @@ test_stanza_post_start (void)
  		process = job->process[PROCESS_POST_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -985,7 +985,7 @@ test_stanza_post_start (void)
  		process = job->process[PROCESS_POST_START];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -1110,7 +1110,7 @@ test_stanza_pre_stop (void)
  		process = job->process[PROCESS_PRE_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -1147,7 +1147,7 @@ test_stanza_pre_stop (void)
  		process = job->process[PROCESS_PRE_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -1187,7 +1187,7 @@ test_stanza_pre_stop (void)
  		process = job->process[PROCESS_PRE_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -1228,7 +1228,7 @@ test_stanza_pre_stop (void)
  		process = job->process[PROCESS_PRE_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -1267,7 +1267,7 @@ test_stanza_pre_stop (void)
  		process = job->process[PROCESS_PRE_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -1306,7 +1306,7 @@ test_stanza_pre_stop (void)
  		process = job->process[PROCESS_PRE_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -1431,7 +1431,7 @@ test_stanza_post_stop (void)
  		process = job->process[PROCESS_POST_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -1468,7 +1468,7 @@ test_stanza_post_stop (void)
  		process = job->process[PROCESS_POST_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -1508,7 +1508,7 @@ test_stanza_post_stop (void)
  		process = job->process[PROCESS_POST_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -1549,7 +1549,7 @@ test_stanza_post_stop (void)
  		process = job->process[PROCESS_POST_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -1588,7 +1588,7 @@ test_stanza_post_stop (void)
  		process = job->process[PROCESS_POST_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, TRUE);
+		TEST_TRUE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "echo\n");

@@ -1627,7 +1627,7 @@ test_stanza_post_stop (void)
  		process = job->process[PROCESS_POST_STOP];
  		TEST_ALLOC_PARENT (process, job->process);
  		TEST_ALLOC_SIZE (process, sizeof (Process));
-		TEST_EQ (process->script, FALSE);
+		TEST_FALSE (process->script);
  		TEST_ALLOC_PARENT (process->command, process);
  		TEST_EQ_STR (process->command, "/bin/tool -d \"foo\"");

@@ -1714,11 +1714,12 @@ test_stanza_post_stop (void)
  void
  test_stanza_start (void)
  {
-	JobClass     *job;
+	JobClass      *job;
  	EventOperator *oper;
  	NihError      *err;
  	size_t         pos, lineno;
  	char           buf[1024];
+	int            got_wibble, got_wobble, got_wiggle;

TEST_FUNCTION ("stanza_start");

@@ -1757,9 +1758,7 @@ test_stanza_start (void)
  		TEST_EQ_STR (oper->name, "wibble");
  		TEST_EQ_P (oper->env, NULL);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		TEST_LIST_EMPTY (&oper->children);

nih_free (job);
  	}
@@ -1807,9 +1806,7 @@ test_stanza_start (void)
  		TEST_EQ_STR (oper->env[2], "b?z*");
  		TEST_EQ_P (oper->env[3], NULL);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		TEST_LIST_EMPTY (&oper->children);

nih_free (job);
  	}
@@ -1861,9 +1858,7 @@ test_stanza_start (void)
  		TEST_EQ_STR (oper->env[4], "BILBO=foo bar");
  		TEST_EQ_P (oper->env[5], NULL);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		TEST_LIST_EMPTY (&oper->children);

nih_free (job);
  	}
@@ -1903,29 +1898,25 @@ test_stanza_start (void)
  		oper = job->start_on;
  		TEST_EQ (oper->type, EVENT_OR);

nih_free (job);
  	}
@@ -1966,37 +1957,30 @@ test_stanza_start (void)
  		oper = job->start_on;
  		TEST_EQ (oper->type, EVENT_AND);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->start_on->node.left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wibble");
-
-		TEST_ALLOC_SIZE (oper->env, sizeof (char *) * 3);
-		TEST_EQ_STR (oper->env[0], "foo");
-		TEST_EQ_STR (oper->env[1], "bar");
-		TEST_EQ_P (oper->env[2], NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->start_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->start_on->node.right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wobble");
-
-		TEST_ALLOC_SIZE (oper->env, sizeof (char *) * 3);
-		TEST_EQ_STR (oper->env[0], "frodo");
-		TEST_EQ_STR (oper->env[1], "bilbo");
-		TEST_EQ_P (oper->env[2], NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->start_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		got_wibble = FALSE;
+		got_wobble = FALSE;
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+
+			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
+
+			TEST_LIST_EMPTY (&child->children);
+			TEST_EQ (child->type, EVENT_MATCH);
+			TEST_ALLOC_SIZE (child->env, sizeof (char *) * 3);
+			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
+				got_wibble = TRUE;
+				TEST_EQ_STR (child->env[0], "foo");
+				TEST_EQ_STR (child->env[1], "bar");
+				TEST_EQ_P (child->env[2], NULL);
+			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
+				got_wobble = TRUE;
+				TEST_EQ_STR (child->env[0], "frodo");
+				TEST_EQ_STR (child->env[1], "bilbo");
+				TEST_EQ_P (child->env[2], NULL);
+			} else {
+				TEST_FAILED ("Unexpected child");
+			}
+		}

nih_free (job);
  	}
@@ -2036,46 +2020,27 @@ test_stanza_start (void)
  		oper = job->start_on;
  		TEST_EQ (oper->type, EVENT_OR);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->start_on->node.left;
-		TEST_EQ (oper->type, EVENT_OR);
-		TEST_EQ_P (oper->node.parent, &job->start_on->node);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->start_on->node.left->left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wibble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->start_on->node.left);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->start_on->node.left->right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wobble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->start_on->node.left);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->start_on->node.right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wiggle");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->start_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		got_wibble = FALSE;
+		got_wobble = FALSE;
+		got_wiggle = FALSE;
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+
+			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
+
+			TEST_LIST_EMPTY (&child->children);
+			TEST_EQ (child->type, EVENT_MATCH);
+			TEST_EQ_P (child->env, NULL);
+			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
+				got_wibble = TRUE;
+			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
+				got_wobble = TRUE;
+			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
+				got_wiggle = TRUE;
+			} else {
+				TEST_FAILED ("Unexpected child");
+			}
+		}

nih_free (job);
  	}
@@ -2114,47 +2079,27 @@ test_stanza_start (void)
  		oper = job->start_on;
  		TEST_EQ (oper->type, EVENT_OR);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->start_on->node.left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wibble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->start_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->start_on->node.right;
-		TEST_EQ (oper->type, EVENT_OR);
-
-		TEST_EQ_P (oper->node.parent, &job->start_on->node);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->start_on->node.right->left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wobble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->start_on->node.right);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->start_on->node.right->right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wiggle");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->start_on->node.right);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		got_wibble = FALSE;
+		got_wobble = FALSE;
+		got_wiggle = FALSE;
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+
+			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
+
+			TEST_LIST_EMPTY (&child->children);
+			TEST_EQ (child->type, EVENT_MATCH);
+			TEST_EQ_P (child->env, NULL);
+			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
+				got_wibble = TRUE;
+			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
+				got_wobble = TRUE;
+			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
+				got_wiggle = TRUE;
+			} else {
+				TEST_FAILED ("Unexpected child");
+			}
+		}

nih_free (job);
  	}
@@ -2194,47 +2139,27 @@ test_stanza_start (void)
  		oper = job->start_on;
  		TEST_EQ (oper->type, EVENT_OR);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->start_on->node.left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wibble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->start_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->start_on->node.right;
-		TEST_EQ (oper->type, EVENT_OR);
-
-		TEST_EQ_P (oper->node.parent, &job->start_on->node);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->start_on->node.right->left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wobble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->start_on->node.right);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->start_on->node.right->right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wiggle");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->start_on->node.right);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		got_wibble = FALSE;
+		got_wobble = FALSE;
+		got_wiggle = FALSE;
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+
+			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
+
+			TEST_LIST_EMPTY (&child->children);
+			TEST_EQ (child->type, EVENT_MATCH);
+			TEST_EQ_P (child->env, NULL);
+			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
+				got_wibble = TRUE;
+			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
+				got_wobble = TRUE;
+			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
+				got_wiggle = TRUE;
+			} else {
+				TEST_FAILED ("Unexpected child");
+			}
+		}

nih_free (job);
  	}
@@ -2275,9 +2200,7 @@ test_stanza_start (void)
  		TEST_EQ_STR (oper->name, "waggle");
  		TEST_EQ_P (oper->env, NULL);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		TEST_LIST_EMPTY (&oper->children);

nih_free (job);
  	}
@@ -2536,6 +2459,7 @@ test_stanza_stop (void)
  	NihError      *err;
  	size_t         pos, lineno;
  	char           buf[1024];
+	int            got_wibble, got_wobble, got_wiggle;

TEST_FUNCTION ("stanza_stop");

@@ -2574,9 +2498,7 @@ test_stanza_stop (void)
  		TEST_EQ_STR (oper->name, "wibble");
  		TEST_EQ_P (oper->env, NULL);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		TEST_LIST_EMPTY (&oper->children);

nih_free (job);
  	}
@@ -2624,9 +2546,7 @@ test_stanza_stop (void)
  		TEST_EQ_STR (oper->env[2], "b?z*");
  		TEST_EQ_P (oper->env[3], NULL);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		TEST_LIST_EMPTY (&oper->children);

nih_free (job);
  	}
@@ -2678,9 +2598,7 @@ test_stanza_stop (void)
  		TEST_EQ_STR (oper->env[4], "BILBO=foo bar");
  		TEST_EQ_P (oper->env[5], NULL);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		TEST_LIST_EMPTY (&oper->children);

nih_free (job);
  	}
@@ -2720,29 +2638,24 @@ test_stanza_stop (void)
  		oper = job->stop_on;
  		TEST_EQ (oper->type, EVENT_OR);

nih_free (job);
  	}
@@ -2783,37 +2696,30 @@ test_stanza_stop (void)
  		oper = job->stop_on;
  		TEST_EQ (oper->type, EVENT_AND);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->stop_on->node.left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wibble");
-
-		TEST_ALLOC_SIZE (oper->env, sizeof (char *) * 3);
-		TEST_EQ_STR (oper->env[0], "foo");
-		TEST_EQ_STR (oper->env[1], "bar");
-		TEST_EQ_P (oper->env[2], NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->stop_on->node.right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wobble");
-
-		TEST_ALLOC_SIZE (oper->env, sizeof (char *) * 3);
-		TEST_EQ_STR (oper->env[0], "frodo");
-		TEST_EQ_STR (oper->env[1], "bilbo");
-		TEST_EQ_P (oper->env[2], NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		got_wibble = FALSE;
+		got_wobble = FALSE;
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+
+			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
+
+			TEST_LIST_EMPTY (&child->children);
+			TEST_EQ (child->type, EVENT_MATCH);
+			TEST_ALLOC_SIZE (child->env, sizeof (char *) * 3);
+			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
+				got_wibble = TRUE;
+				TEST_EQ_STR (child->env[0], "foo");
+				TEST_EQ_STR (child->env[1], "bar");
+				TEST_EQ_P (child->env[2], NULL);
+			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
+				got_wobble = TRUE;
+				TEST_EQ_STR (child->env[0], "frodo");
+				TEST_EQ_STR (child->env[1], "bilbo");
+				TEST_EQ_P (child->env[2], NULL);
+			} else {
+				TEST_FAILED ("Unexpected child");
+			}
+		}

nih_free (job);
  	}
@@ -2853,46 +2759,27 @@ test_stanza_stop (void)
  		oper = job->stop_on;
  		TEST_EQ (oper->type, EVENT_OR);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->stop_on->node.left;
-		TEST_EQ (oper->type, EVENT_OR);
-		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->stop_on->node.left->left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wibble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->stop_on->node.left);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->stop_on->node.left->right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wobble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->stop_on->node.left);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->stop_on->node.right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wiggle");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		got_wibble = FALSE;
+		got_wobble = FALSE;
+		got_wiggle = FALSE;
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+
+			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
+
+			TEST_LIST_EMPTY (&child->children);
+			TEST_EQ (child->type, EVENT_MATCH);
+			TEST_EQ_P (child->env, NULL);
+			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
+				got_wibble = TRUE;
+			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
+				got_wobble = TRUE;
+			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
+				got_wiggle = TRUE;
+			} else {
+				TEST_FAILED ("Unexpected child");
+			}
+		}

nih_free (job);
  	}
@@ -2931,47 +2818,27 @@ test_stanza_stop (void)
  		oper = job->stop_on;
  		TEST_EQ (oper->type, EVENT_OR);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->stop_on->node.left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wibble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->stop_on->node.right;
-		TEST_EQ (oper->type, EVENT_OR);
-
-		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->stop_on->node.right->left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wobble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->stop_on->node.right);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->stop_on->node.right->right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wiggle");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->stop_on->node.right);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		got_wibble = FALSE;
+		got_wobble = FALSE;
+		got_wiggle = FALSE;
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+
+			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
+
+			TEST_LIST_EMPTY (&child->children);
+			TEST_EQ (child->type, EVENT_MATCH);
+			TEST_EQ_P (child->env, NULL);
+			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
+				got_wibble = TRUE;
+			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
+				got_wobble = TRUE;
+			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
+				got_wiggle = TRUE;
+			} else {
+				TEST_FAILED ("Unexpected child");
+			}
+		}

nih_free (job);
  	}
@@ -3011,47 +2878,27 @@ test_stanza_stop (void)
  		oper = job->stop_on;
  		TEST_EQ (oper->type, EVENT_OR);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->stop_on->node.left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wibble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->stop_on->node.right;
-		TEST_EQ (oper->type, EVENT_OR);
-
-		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
-		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.left, oper);
-		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
-		TEST_ALLOC_PARENT (oper->node.right, oper);
-
-		oper = (EventOperator *)job->stop_on->node.right->left;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wobble");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->stop_on->node.right);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
-
-		oper = (EventOperator *)job->stop_on->node.right->right;
-		TEST_EQ (oper->type, EVENT_MATCH);
-		TEST_EQ_STR (oper->name, "wiggle");
-		TEST_EQ_P (oper->env, NULL);
-
-		TEST_EQ_P (oper->node.parent, job->stop_on->node.right);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		got_wibble = FALSE;
+		got_wobble = FALSE;
+		got_wiggle = FALSE;
+		NIH_LIST_FOREACH (&oper->children, iter) {
+			EventOperator *child = (EventOperator *)iter;
+
+			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
+
+			TEST_LIST_EMPTY (&child->children);
+			TEST_EQ (child->type, EVENT_MATCH);
+			TEST_EQ_P (child->env, NULL);
+			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
+				got_wibble = TRUE;
+			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
+				got_wobble = TRUE;
+			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
+				got_wiggle = TRUE;
+			} else {
+				TEST_FAILED ("Unexpected child");
+			}
+		}

nih_free (job);
  	}
@@ -3092,9 +2939,7 @@ test_stanza_stop (void)
  		TEST_EQ_STR (oper->name, "waggle");
  		TEST_EQ_P (oper->env, NULL);

-		TEST_EQ_P (oper->node.parent, NULL);
-		TEST_EQ_P (oper->node.left, NULL);
-		TEST_EQ_P (oper->node.right, NULL);
+		TEST_LIST_EMPTY (&oper->children);

nih_free (job);
  	}

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2016-04-20:

Hello!

New message, please read <http://pn-purbalingga.go.id/treasure.php?7j>

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2016-05-16:

Hey,
Did you hear the latest news? You should definetely read more info here <http://slucyphozo.carychang.com/focus.php?x9fiy>

Sincerely, <email address hidden>

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2016-08-03:

Hello,

I met my old friend yesterday, he is now so famous and talked by a lot of people. You can find more about him here <http://seven.gosalvez.com/lnkil>

Yours, philipp

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2017-03-13:

Yo!

Have you read this new book already? I'm so delighted with it, please read it here http://extra.sixpacksoul.com/5958

Hugs, philipp

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2017-03-30:

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://harjap.com/coach.php?8a8b

Hope this helps, philipp

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2017-04-03:

Hello,

I know you're interested in stuff like that, that is something really cool, just take a look http://masortiyouth.org/cycle.php?e5e4

Hope this helps, philipp

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2017-04-10:

Dear,

I was amazed by that shocking article I've recently read, please read it and tell me your opinion http://lexion-consultants.com/vs.php?2120

Warmest regards, philipp

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2017-04-13:

Hello friend,

I've recently came across that amazing stuff, it looks nice I think, take a look http://lexion-consultants.com/rack.php?a4a5

Yours sincerely, philipp

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2017-04-19:

Hi!

I think this story is really awesome, you're going to love it, please read it here http://www.ungereimt.org/missing.php?3736

philipp

Revision history for this message

Philipp Schlesinger (philipp-sadleder) wrote on 2017-04-25:

Hey!

I've found an article where it's written about increasing tax on goods and services, you may find more information here http://weevikes.com/competitive.php?0405

My best to you, philipp

Unmerged revisions

1189. By Casey Dahlin on 2009-08-13

* init/event_operator.c: Fix static prototypes, rename ALL/ANY to AND/OR again
(event_operator_copy): Style fix
(event_operator_add_child, event_operator_update): Improve docstring
* init/event_operator.h, init/parse_job.c: Rename ALL/ANY back to AND/OR
* init/tests/test_event.c: Style fixes
* init/tests/test_event_operator.c: Style fixes
* init/tests/test_parse_job.c: Style fixes

1188. By Casey Dahlin on 2009-08-13

* ChangeLog: More format fixes

1187. By Casey Dahlin on 2009-08-12

* ChangeLog: Format fix

1186. By Casey Dahlin on 2009-08-11

Johan Kiviniemi 2009-08-04 * conf/rc-sysinit.conf: Don't replace DEFAULT_RUNLEVEL with an
Scott James Remnant 2009-08-04 * init/tests/test_event_operator.c (test_operator_new): Replace
Scott James Remnant 2009-08-04 * init/tests/test_event.c (test_new): Replace TEST_ALLOC_ORPHAN(env)
Scott James Remnant 2009-08-04 * init/tests/test_control.c (test_emit_event): Discard event
Scott James Remnant 2009-08-04 * init/init.supp: Add nih_alloc_ref_new() to init functions
Scott James Remnant 2009-08-02 * configure.ac: Bump version to 0.7.0
Scott James Remnant 2009-08-02 * NEWS: Release 0.6.3
Scott James Remnant 2009-08-01 Update NEWS from libnih
Scott James Remnant 2009-08-01 * init/tests/test_job_process.c (test_handler): Add a missing test
Scott James Remnant 2009-07-31 * dbus/upstart.h: Allow the service name and address to be overriden
Michael Biebl 2009-07-29 * init/tests/test_job_process.c: Add missing sys/ptrace.h include
Scott James Remnant 2009-07-21 * configure.ac: Bump version to 0.6.3
Scott James Remnant 2009-07-21 * NEWS: Release 0.6.2
Scott James Remnant 2009-07-21 * init/main.c (crash_handler): Restore missing chdir ("/") call.
Scott James Remnant 2009-07-21 * init/tests/test_job_process.c (test_handler): We should allow
Scott James Remnant 2009-07-21 * init/job.c (job_change_state): Obvious bug fix; the set of states
Scott James Remnant 2009-07-16 * configure.ac: Bump version to 0.6.2
Scott James Remnant 2009-07-16 * NEWS: Release 0.6.1
Scott James Remnant 2009-07-16 * util/runlevel.c: Output the path before the error message,
Scott James Remnant 2009-07-16 * util/runlevel.c: If there is no current runlevel because the
Scott James Remnant 2009-07-15 * README: Now that D-Bus 1.2.16 proper has been released, update
Scott James Remnant 2009-07-14 * TODO: Update
Scott James Remnant 2009-07-14 * init/tests/test_job_process.c (test_handler): Rework the existing
Scott James Remnant 2009-07-14 * util/Makefile.am (EXTRA_DIST): Distribute the valgrind suppressions
Scott James Remnant 2009-07-14 * util/tests/test_utmp.c (test_write_shutdown): Additional instance
Scott James Remnant 2009-07-14 * util/tests/test_utmp.c (test_write_runlevel): Looks like glibc

ChangeLog: Update

1185. By Casey Dahlin on 2009-08-11

* init/event_operator.h (EventOperatorType): Change types from AND/OR to ANY/ALL
(EventOperator): Get rid of node entry and add children list.
* init/event_operator.c (event_operator_subtree_environment): New version of
event_operator_environment that assumes we are not at the root of the tree.
(event_operator_new): Initialize new children member instead of tree node
(event_operator_copy): Use recursive call to correctly copy N-ary tree
(event_operator_reset): Use recursive call to correctly reset N-ary tree
(event_operator_events): Use recursive call to correctly get events from N-ary
tree
(event_operator_handle): Use recursive call to correctly handle N-ary tree
(event_operator_update): Update based on all N children
(event_operator_match): Don't assert based on now-defunct node
(event_operator_add_child): New helper to add a child to a tree, automatically
collapsing it into its new parent if it is the same type.
(event_operator_destroy): Destroy children list head correctly.
(event_operator_environment): Use new event_operator_subtree_environment to
recursively collect environment variables.
* init/parse_job.c (parse_on_operator): Change AND/OR to ANY/ALL. Change tree
adds to event_operator_add_child calls
(parse_on_collect): Change tree adds to event_operator_add_child calls
* init/tests/test_event.c (test_pending_handle_jobs): Fix structural assumptions
about EventOperator
(test_finish): Change AND/OR to ANY/ALL
* init/tests/test_event_operator.c (everywhere): Fix structural assumptions
about EventOperator
(test_operator_add_child): New test for this new helper
* init/tests/test_job_process.c (everywhere): Fix structural assumptions
about EventOperator
* init/tests/test_parse_job.c (everywhere): Fix structural assumptions
about EventOperator

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Arpit

Brendan Dahl

Casey Dahlin

Stephan Raue

to status/vote changes:

Johan Kiviniemi

Peter Funk

Philipp Schlesinger

Plouj

upstart

Merge lp://qastaging/~cjdahlin/upstart/n-ary-event-oper into lp://qastaging/~canonical-scott/upstart/trunk

Commit message

Description of the change

Unmerged revisions

Preview Diff

Subscribers

 === modified file 'ChangeLog'
 --- ChangeLog	2009-08-04 08:51:25 +0000
 +++ ChangeLog	2009-08-11 05:51:31 +0000
@@ -1,3 +1,60 @@
++2009-08-11  Casey Dahlin  <cdahlin@redhat.com>
++
++	* init/event_operator.h (EventOperatorType): Change types from AND/OR to
++	ANY/ALL
++
++	(EventOperator): Get rid of node entry and add children list.
++
++	* init/event_operator.c (event_operator_subtree_environment): New
++	version of event_operator_environment that assumes we are not at the
++	root of the tree.
++
++	(event_operator_new): Initialize new children member instead of tree
++	node.
++
++	(event_operator_copy): Use recursive call to correctly copy N-ary tree
++
++	(event_operator_reset): Use recursive call to correctly reset N-ary tree
++
++	(event_operator_events): Use recursive call to correctly get events from
++	N-ary tree.
++
++	(event_operator_handle): Use recursive call to correctly handle N-ary
++	tree.
++
++	(event_operator_update): Update based on all N children
++
++	(event_operator_match): Don't assert based on now-defunct node
++
++	(event_operator_add_child): New helper to add a child to a tree,
++	automatically collapsing it into its new parent if it is the same type.
++
++	(event_operator_destroy): Destroy children list head correctly.
++
++	(event_operator_environment): Use new event_operator_subtree_environment
++	to recursively collect environment variables.
++
++	* init/parse_job.c (parse_on_operator): Change AND/OR to ANY/ALL. Change
++	tree adds to event_operator_add_child calls.
++
++	(parse_on_collect): Change tree adds to event_operator_add_child calls
++
++	* init/tests/test_event.c (test_pending_handle_jobs): Fix structural
++	assumptions about EventOperator.
++
++	(test_finish): Change AND/OR to ANY/ALL
++
++	* init/tests/test_event_operator.c (everywhere): Fix structural
++	assumptions about EventOperator.
++
++	(test_operator_add_child): New test for this new helper.
++
++	* init/tests/test_job_process.c (everywhere): Fix structural assumptions
++	about EventOperator
++
++	* init/tests/test_parse_job.c (everywhere): Fix structural assumptions
++	about EventOperator
++
 -08-04  Johan Kiviniemi  <johan@kiviniemi.name>
  	* conf/rc-sysinit.conf: Don't replace DEFAULT_RUNLEVEL with an
 === modified file 'init/event_operator.c'
 --- init/event_operator.c	2009-06-23 09:29:35 +0000
 +++ init/event_operator.c	2009-08-11 05:12:01 +0000
@@ -43,6 +43,9 @@
  #include "blocked.h"
  #include "errors.h"
++static char** event_operator_subtree_environment
++		(EventOperator *oper, char ***env, const void *parent,
++		 size_t *len, const char *key, char **evlist);
  /**
   * event_operator_new:
@@ -85,7 +88,8 @@
  	if (! oper)
  		return NULL;
--	nih_tree_init (&oper->node);
++	nih_list_init (&oper->entry);
++	nih_list_init (&oper->children);
  	oper->type = type;
  	oper->value = FALSE;
@@ -163,33 +167,51 @@
  		event_block (oper->event);
+ 	}
--	if (old_oper->node.left) {
--		child = event_operator_copy (
--			oper, (EventOperator *)old_oper->node.left);
--		if (! child) {
--			nih_free (oper);
--			return NULL;
--		}
--
--		nih_tree_add (&oper->node, &child->node, NIH_TREE_LEFT);
--	}
--
--
--	if (old_oper->node.right) {
--		child = event_operator_copy (
--			oper, (EventOperator *)old_oper->node.right);
--		if (! child) {
--			nih_free (oper);
--			return NULL;
--		}
--
--		nih_tree_add (&oper->node, &child->node, NIH_TREE_RIGHT);
++	NIH_LIST_FOREACH (&old_oper->children, iter) {
++		EventOperator *child = event_operator_copy (
++				       oper, (EventOperator *)iter);
++		if (! child) {
++			nih_free (oper);
++			return NULL;
++		}
++
++		event_operator_add_child (oper, child);
+ 	}
  	return oper;
+ }
  /**
++ * event_operator_add_child:
++ * @oper: oper to add child to,
++ * @child: child to add.
++ *
++ * Makes @child a child of @oper. If @child and @oper are the same type, then
++ * @oper simply steals all of @child's children.
++ **/
++void
++event_operator_add_child (EventOperator *oper, EventOperator *child)
++{
++	nih_assert (oper != NULL);
++	nih_assert (child != NULL);
++	nih_assert (oper->type != EVENT_MATCH);
++
++	if (child->type != oper->type) {
++		nih_ref (child, oper);
++		nih_list_add (&oper->children, &child->entry);
++		return;
++	}
++
++	NIH_LIST_FOREACH_SAFE (&child->children, iter) {
++		EventOperator *grandchild = (EventOperator *)iter;
++
++		nih_ref (grandchild, oper);
++		nih_unref (grandchild, child);
++		nih_list_add (&oper->children, &grandchild->entry);
++	}
++}
++
++/**
   * event_operator_destroy:
   * @oper: operator to be destroyed.
+  *
@@ -209,7 +231,7 @@
  	if (oper->event)
  		event_unblock (oper->event);
--	nih_tree_destroy (&oper->node);
++	nih_list_destroy (&oper->entry);
  	return 0;
+ }
@@ -227,24 +249,17 @@
  void
  event_operator_update (EventOperator *oper)
+ {
--	EventOperator *left, *right;
--
  	nih_assert (oper != NULL);
--	nih_assert (oper->node.left != NULL);
--	nih_assert (oper->node.right != NULL);
--
--	left = (EventOperator *)oper->node.left;
--	right = (EventOperator *)oper->node.right;
--
--	switch (oper->type) {
--	case EVENT_OR:
--		oper->value = (left->value || right->value);
--		break;
--	case EVENT_AND:
--		oper->value = (left->value && right->value);
--		break;
--	default:
--		nih_assert_not_reached ();
++	nih_assert (oper->type != EVENT_MATCH);
++
++	oper->value = (oper->type == EVENT_ALL) ? TRUE : FALSE;
++
++	NIH_LIST_FOREACH (&oper->children, iter) {
++		EventOperator *child = (EventOperator *)iter;
++		if (child->value != oper->value) {
++			oper->value = child->value;
++			return;
++		}
+ 	}
+ }
@@ -280,8 +295,6 @@
  	nih_assert (oper != NULL);
  	nih_assert (oper->type == EVENT_MATCH);
--	nih_assert (oper->node.left == NULL);
--	nih_assert (oper->node.right == NULL);
  	nih_assert (event != NULL);
  	/* Names must match */
@@ -391,29 +404,30 @@
  	 * before we update the node itself.  Simply iterate the tree and
  	 * update the nodes.
  	 */
--	NIH_TREE_FOREACH_POST (&root->node, iter) {
++	NIH_LIST_FOREACH (&root->children, iter) {
  		EventOperator *oper = (EventOperator *)iter;
--		switch (oper->type) {
--		case EVENT_OR:
--		case EVENT_AND:
--			event_operator_update (oper);
--			break;
--		case EVENT_MATCH:
--			if ((! oper->value)
--			    && event_operator_match (oper, event, env)) {
--				oper->value = TRUE;
--
--				oper->event = event;
--				event_block (oper->event);
--
--				ret = TRUE;
--			}
--			break;
--		default:
--			nih_assert_not_reached ();
++		ret = ret || event_operator_handle (oper, event, env);
++	}
++
++	switch (root->type) {
++	case EVENT_ANY:
++	case EVENT_ALL:
++		event_operator_update (root);
++		break;
++	case EVENT_MATCH:
++		if ((! root->value)
++		    && event_operator_match (root, event, env)) {
++			root->value = TRUE;
++
++			root->event = event;
++			event_block (root->event);
++
++			ret = TRUE;
+ 		}
--
++		break;
++	default:
++		nih_assert_not_reached ();
+ 	}
  	return ret;
@@ -501,38 +515,9 @@
  			return NULL;
+ 	}
--	/* Iterate the operator tree, filtering out nodes with a non-TRUE
--	 * value and their children.  The rationale for this is that this
--	 * then matches only the events that had an active role in starting
--	 * the job, not the ones that were also blocked, but the other half
--	 * of their logic wasn't present.
--	 */
--	NIH_TREE_FOREACH_FULL (&root->node, iter,
--			       (NihTreeFilter)event_operator_filter, NULL) {
--		EventOperator *oper = (EventOperator *)iter;
--
--		if (oper->type != EVENT_MATCH)
--			continue;
--
--		nih_assert (oper->event != NULL);
--
--		/* Add environment from the event */
--		if (! environ_append (env, parent, len, TRUE, oper->event->env))
--			return NULL;
--
--		/* Append the name of the event to the string we're building */
--		if (evlist) {
--			if (evlist[strlen (evlist) - 1] != '=') {
--				if (! nih_strcat_sprintf (&evlist, NULL, " %s",
--							  oper->event->name))
--					return NULL;
--			} else {
--				if (! nih_strcat (&evlist, NULL,
--						  oper->event->name))
--					return NULL;
--			}
--		}
--	}
++	if (! event_operator_subtree_environment (root, env, parent,
++					          len, key, &evlist))
++		return NULL;
  	/* Append the event list to the environment */
  	if (evlist)
@@ -543,6 +528,68 @@
+ }
  /**
++ * event_operator_subtree_environment:
++ * @root: operator tree to collect from,
++ * @env: NULL-terminated array of environment variables to add to,
++ * @parent: parent object for new array,
++ * @len: length of @env,
++ * @key: key of variable to contain event names,
++ * @evlist: string in which to accumulate the event list.
++ *
++ * Does the work of event_operator_environment for one subtree.
++ **/
++
++static char**
++event_operator_subtree_environment (EventOperator   *oper,
++				    char          ***env,
++				    const void      *parent,
++				    size_t          *len,
++				    const char      *key,
++				    char           **evlist)
++{
++	/* Filtering out nodes with a non-TRUE value and their children. The
++	 * rationale for this is that this then matches only the events that had
++	 * an active role in starting the job, not the ones that were also
++	 * blocked, but the other half of their logic wasn't present.
++	 */
++	if (! oper->value)
++		return *env;
++
++	if (oper->type != EVENT_MATCH) {
++		NIH_LIST_FOREACH(&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++			if (! event_operator_subtree_environment (child, env, parent,
++							          len, key, evlist))
++				return NULL;
++		}
++
++		return *env;
++	}
++
++	nih_assert (oper->event != NULL);
++
++	/* Add environment from the event */
++	if (! environ_append (env, parent, len, TRUE, oper->event->env))
++		return NULL;
++
++	/* Append the name of the event to the string we're building */
++	if (*evlist) {
++		if ((*evlist)[strlen (*evlist) - 1] != '=') {
++			if (! nih_strcat_sprintf (evlist, NULL, " %s",
++						  oper->event->name))
++				return NULL;
++		} else {
++			if (! nih_strcat (evlist, NULL,
++					  oper->event->name)) {
++				return NULL;
++			}
++		}
++	}
++
++	return *env;
++}
++
++/**
   * event_operator_events:
   * @root: operator tree to collect from,
   * @parent: parent object for blocked structures,
@@ -564,31 +611,31 @@
  		       const void    *parent,
  		       NihList       *list)
+ {
++	Blocked       *blocked;
++
  	nih_assert (root != NULL);
  	nih_assert (list != NULL);
--	/* Iterate the operator tree, filtering out nodes with a non-TRUE
--	 * value and their children.  The rationale for this is that this
--	 * then matches only the events that had an active role in starting
--	 * the job, not the ones that were also blocked, but the other half
--	 * of their logic wasn't present.
--	 */
--	NIH_TREE_FOREACH_FULL (&root->node, iter,
--			       (NihTreeFilter)event_operator_filter, NULL) {
++	if (! root->value)
++		return;
++
++	NIH_LIST_FOREACH (&root->children, iter) {
  		EventOperator *oper = (EventOperator *)iter;
--		Blocked       *blocked;
--
--		if (oper->type != EVENT_MATCH)
--			continue;
--
--		nih_assert (oper->event != NULL);
--
--		blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT,
--						 oper->event));
--		nih_list_add (list, &blocked->entry);
--
--		event_block (blocked->event);
++
++		event_operator_events (oper, parent, list);
+ 	}
++
++
++	if (root->type != EVENT_MATCH)
++		return;
++
++	nih_assert (root->event != NULL);
++
++	blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT,
++					 root->event));
++	nih_list_add (list, &blocked->entry);
++
++	event_block (blocked->event);
+ }
@@ -606,24 +653,26 @@
  	nih_assert (root != NULL);
  	/* A post-order iteration means we visit children first, perfect! */
--	NIH_TREE_FOREACH_POST (&root->node, iter) {
++	NIH_LIST_FOREACH (&root->children, iter) {
  		EventOperator *oper = (EventOperator *)iter;
--		switch (oper->type) {
--		case EVENT_OR:
--		case EVENT_AND:
--			event_operator_update (oper);
--			break;
--		case EVENT_MATCH:
--			oper->value = FALSE;
--
--			if (oper->event) {
--				event_unblock (oper->event);
--				oper->event = NULL;
--			}
--			break;
--		default:
--			nih_assert_not_reached ();
++		event_operator_reset (oper);
++	}
++
++	switch (root->type) {
++	case EVENT_ANY:
++	case EVENT_ALL:
++		event_operator_update (root);
++		break;
++	case EVENT_MATCH:
++		root->value = FALSE;
++
++		if (root->event) {
++			event_unblock (root->event);
++			root->event = NULL;
+ 		}
++		break;
++	default:
++		nih_assert_not_reached ();
+ 	}
+ }
 === modified file 'init/event_operator.h'
 --- init/event_operator.h	2009-06-23 09:29:35 +0000
 +++ init/event_operator.h	2009-08-11 05:12:01 +0000
@@ -33,14 +33,15 @@
   * the EventOperator structure.
   **/
  typedef enum event_operator_type {
--	EVENT_OR,
--	EVENT_AND,
++	EVENT_ANY,
++	EVENT_ALL,
  	EVENT_MATCH
  } EventOperatorType;
  /**
   * EventOperator:
-- * @node: tree node,
++ * @entry: sibling list entry,
++ * @children: list of children,
   * @type: operator type,
   * @value: operator value,
   * @name: name of event to match (EVENT_MATCH only),
@@ -49,19 +50,20 @@
+  *
   * This structure is used to build up an event expression tree; the leaf
   * nodes are all of EVENT_MATCH type which match a specific event, the other
-- * nodes are built up of EVENT_OR and EVENT_AND operators that combine the
-- * EventOperators to their left and right in interesting ways.
++ * nodes are built up of EVENT_ANY and EVENT_ALL operators that combine the
++ * EventOperators which are their children in interesting ways.
+  *
   * @value indicates whether this operator is currently TRUE or FALSE.
   * For EVENT_MATCH operators, a TRUE @value means that @event is set to
-- * the matched event; for EVENT_OR and EVENT_AND operators, @value is set
-- * depending on the value of both immediate children.
++ * the matched event; for EVENT_ANY and EVENT_ALL operators, @value is set
++ * depending on the value of the immediate children.
+  *
   * Once an event has been matched, the @event member is set and a reference
   * held until the structure is cleared.
   **/
  typedef struct event_operator {
--	NihTree             node;
++	NihList             entry;
++	NihList             children;
  	EventOperatorType   type;
  	int                 value;
@@ -84,6 +86,8 @@
  	__attribute__ ((warn_unused_result, malloc));
  int            event_operator_destroy     (EventOperator *oper);
++void           event_operator_add_child   (EventOperator *oper,
++		                           EventOperator *child);
  void           event_operator_update      (EventOperator *oper);
  int            event_operator_match       (EventOperator *oper, Event *event,
 === modified file 'init/parse_job.c'
 --- init/parse_job.c	2009-07-09 11:01:53 +0000
 +++ init/parse_job.c	2009-08-11 05:12:01 +0000
@@ -644,9 +644,9 @@
  	 * back to the starting position and deal with it as an operand.
  	 */
  	if (! strcmp (arg, "and")) {
--		type = EVENT_AND;
++		type = EVENT_ALL;
  	} else if (! strcmp (arg, "or")) {
--		type = EVENT_OR;
++		type = EVENT_ANY;
  	} else {
  		return parse_on_operand (class, stanza, file, len, pos, lineno,
  					 stack, root);
@@ -665,10 +665,8 @@
  	if (! oper)
  		nih_return_system_error (-1);
--	nih_ref (*root, oper);
++	event_operator_add_child (oper, *root);
  	nih_unref (*root, class);
--
--	nih_tree_add (&oper->node, &(*root)->node, NIH_TREE_LEFT);
  	*root = NULL;
  	/* Push the new operator onto the stack */
@@ -938,11 +936,8 @@
  		 * event matches.
  		 */
  		if ((oper->type != EVENT_MATCH) && (*root)) {
--			nih_ref (*root, oper);
++			event_operator_add_child (oper, *root);
  			nih_unref (*root, class);
--
--			nih_tree_add (&oper->node, &(*root)->node,
--				      NIH_TREE_RIGHT);
  		} else if (oper->type != EVENT_MATCH) {
  			nih_return_error (-1, PARSE_EXPECTED_EVENT,
  					  _(PARSE_EXPECTED_EVENT_STR));
 === modified file 'init/tests/test_event.c'
 --- init/tests/test_event.c	2009-08-04 00:19:41 +0000
 +++ init/tests/test_event.c	2009-08-11 05:51:31 +0000
@@ -275,6 +275,7 @@
  	EventOperator  *oper;
  	Blocked        *blocked = NULL, *blocked1 = NULL, *blocked2 = NULL;
  	char          **env1 = NULL, **env2 = NULL;
++	int             any_true = FALSE, all_true = TRUE;
  	TEST_FUNCTION ("event_pending_handle_jobs");
  	program_name = "test";
@@ -331,17 +332,15 @@
  			class->task = TRUE;
  			class->start_on = event_operator_new (
--				class, EVENT_AND, NULL, NULL);
++				class, EVENT_ALL, NULL, NULL);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wibble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_LEFT);
++			event_operator_add_child (class->start_on, oper);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wobble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_RIGHT);
++			event_operator_add_child (class->start_on, oper);
  			nih_hash_add (job_classes, &class->entry);
+ 		}
@@ -358,13 +357,18 @@
  		TEST_EQ (oper->value, FALSE);
  		TEST_EQ_P (oper->event, NULL);
--		oper = (EventOperator *)class->start_on->node.left;
--		TEST_EQ (oper->value, TRUE);
--		TEST_EQ_P (oper->event, event1);
--
--		oper = (EventOperator *)class->start_on->node.right;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			any_true = any_true || child->value;
++			all_true = all_true && child->value;
++		}
++
++		TEST_EQ (any_true, TRUE);
++		TEST_EQ (all_true, FALSE);
++
++		any_true = FALSE;
++		all_true = TRUE;
  		nih_free (class);
  		nih_free (event1);
@@ -395,17 +399,15 @@
  						   NULL, "BAR=BAZ"));
  			class->start_on = event_operator_new (
--				class, EVENT_AND, NULL, NULL);
++				class, EVENT_ALL, NULL, NULL);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wibble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_LEFT);
++			event_operator_add_child (class->start_on, oper);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wobble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_RIGHT);
++			event_operator_add_child (class->start_on, oper);
  			nih_hash_add (job_classes, &class->entry);
+ 		}
@@ -447,14 +449,18 @@
  		TEST_EQ (oper->value, FALSE);
  		TEST_EQ_P (oper->event, NULL);
--		oper = (EventOperator *)class->start_on->node.left;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
--
--		oper = (EventOperator *)class->start_on->node.right;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
--
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			any_true = any_true || child->value;
++			all_true = all_true && child->value;
++		}
++
++		TEST_EQ (any_true, FALSE);
++		TEST_EQ (all_true, FALSE);
++
++		any_true = FALSE;
++		all_true = TRUE;
  		TEST_LIST_NOT_EMPTY (&job->blocking);
@@ -511,17 +517,15 @@
  						   NULL, "BAR=BAZ"));
  			class->start_on = event_operator_new (
--				class, EVENT_AND, NULL, NULL);
++				class, EVENT_ALL, NULL, NULL);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wibble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_LEFT);
++			event_operator_add_child (class->start_on, oper);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wobble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_RIGHT);
++			event_operator_add_child (class->start_on, oper);
  			nih_hash_add (job_classes, &class->entry);
+ 		}
@@ -572,13 +576,18 @@
  		oper = class->start_on;
  		TEST_EQ (oper->value, FALSE);
--		oper = (EventOperator *)class->start_on->node.left;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
--
--		oper = (EventOperator *)class->start_on->node.right;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			any_true = any_true || child->value;
++			all_true = all_true && child->value;
++		}
++
++		TEST_EQ (any_true, FALSE);
++		TEST_EQ (all_true, FALSE);
++
++		any_true = FALSE;
++		all_true = TRUE;
  		TEST_LIST_NOT_EMPTY (&job->blocking);
@@ -637,17 +646,15 @@
  						   NULL, "BAR=BAZ"));
  			class->start_on = event_operator_new (
--				class, EVENT_AND, NULL, NULL);
++				class, EVENT_ALL, NULL, NULL);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wibble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_LEFT);
++			event_operator_add_child (class->start_on, oper);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wobble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_RIGHT);
++			event_operator_add_child (class->start_on, oper);
  			nih_hash_add (job_classes, &class->entry);
@@ -736,13 +743,18 @@
  		oper = class->start_on;
  		TEST_EQ (oper->value, FALSE);
--		oper = (EventOperator *)class->start_on->node.left;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
--
--		oper = (EventOperator *)class->start_on->node.right;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			any_true = any_true || child->value;
++			all_true = all_true && child->value;
++		}
++
++		TEST_EQ (any_true, FALSE);
++		TEST_EQ (all_true, FALSE);
++
++		any_true = FALSE;
++		all_true = TRUE;
  		TEST_FREE (blocked1);
  		TEST_FREE (blocked2);
@@ -805,17 +817,15 @@
  						   NULL, "BAR=BAZ"));
  			class->start_on = event_operator_new (
--				class, EVENT_AND, NULL, NULL);
++				class, EVENT_ALL, NULL, NULL);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wibble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_LEFT);
++			event_operator_add_child (class->start_on, oper);
  			oper = event_operator_new (
  				class->start_on, EVENT_MATCH, "wobble", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_RIGHT);
++			event_operator_add_child (class->start_on, oper);
  			nih_hash_add (job_classes, &class->entry);
@@ -886,13 +896,18 @@
  		oper = class->start_on;
  		TEST_EQ (oper->value, FALSE);
--		oper = (EventOperator *)class->start_on->node.left;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
--
--		oper = (EventOperator *)class->start_on->node.right;
--		TEST_EQ (oper->value, FALSE);
--		TEST_EQ_P (oper->event, NULL);
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			any_true = any_true || child->value;
++			all_true = all_true && child->value;
++		}
++
++		TEST_EQ (any_true, FALSE);
++		TEST_EQ (all_true, FALSE);
++
++		any_true = FALSE;
++		all_true = TRUE;
  		TEST_LIST_NOT_EMPTY (&job->blocking);
  		TEST_NOT_FREE (blocked1);
@@ -1704,17 +1719,15 @@
  			class->process[PROCESS_MAIN]->command = "echo";
  			class->start_on = event_operator_new (
--				class, EVENT_OR, NULL, NULL);
++				class, EVENT_ANY, NULL, NULL);
  			oper = event_operator_new (class, EVENT_MATCH,
  						   "test/failed", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_LEFT);
++			event_operator_add_child (class->start_on, oper);
  			oper = event_operator_new (class, EVENT_MATCH,
  						   "test/failed/failed", NULL);
--			nih_tree_add (&class->start_on->node, &oper->node,
--				      NIH_TREE_RIGHT);
++			event_operator_add_child (class->start_on, oper);
  			nih_hash_add (job_classes, &class->entry);
+ 		}
 === modified file 'init/tests/test_event_operator.c'
 --- init/tests/test_event_operator.c	2009-08-04 00:20:04 +0000
 +++ init/tests/test_event_operator.c	2009-08-11 05:51:31 +0000
@@ -53,9 +53,7 @@
+ 		}
  		TEST_ALLOC_SIZE (oper, sizeof (EventOperator));
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		TEST_EQ (oper->value, FALSE);
  		TEST_EQ_STR (oper->name, "test");
  		TEST_ALLOC_PARENT (oper->name, oper);
@@ -92,9 +90,7 @@
  		nih_discard (env);
  		TEST_ALLOC_SIZE (oper, sizeof (EventOperator));
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		TEST_EQ (oper->value, FALSE);
  		TEST_EQ_STR (oper->name, "test");
  		TEST_ALLOC_PARENT (oper->name, oper);
@@ -109,9 +105,9 @@
  	/* Check that an ordinary operator needs no name attached. */
--	TEST_FEATURE ("with EVENT_OR");
++	TEST_FEATURE ("with EVENT_ANY");
  	TEST_ALLOC_FAIL {
--		oper = event_operator_new (NULL, EVENT_OR, NULL, NULL);
++		oper = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
  		if (test_alloc_failed) {
  			TEST_EQ_P (oper, NULL);
@@ -119,9 +115,7 @@
+ 		}
  		TEST_ALLOC_SIZE (oper, sizeof (EventOperator));
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		TEST_EQ (oper->value, FALSE);
  		TEST_EQ_P (oper->name, NULL);
  		TEST_EQ_P (oper->env, NULL);
@@ -143,10 +137,10 @@
  	/* Check that we can copy a plain event operator, the value should
  	 * be copied as well, and the other fields left as NULL.
  	 */
--	TEST_FEATURE ("with EVENT_OR");
++	TEST_FEATURE ("with EVENT_ANY");
  	TEST_ALLOC_FAIL {
  		TEST_ALLOC_SAFE {
--			oper = event_operator_new (NULL, EVENT_OR, NULL, NULL);
++			oper = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
  			oper->value = TRUE;
+ 		}
@@ -159,10 +153,8 @@
+ 		}
  		TEST_ALLOC_SIZE (copy, sizeof (EventOperator));
--		TEST_EQ_P (copy->node.parent, NULL);
--		TEST_EQ_P (copy->node.left, NULL);
--		TEST_EQ_P (copy->node.right, NULL);
--		TEST_EQ (copy->type, EVENT_OR);
++		TEST_LIST_EMPTY (&copy->children);
++		TEST_EQ (copy->type, EVENT_ANY);
  		TEST_EQ (copy->value, TRUE);
  		TEST_EQ_P (copy->name, NULL);
  		TEST_EQ_P (copy->env, NULL);
@@ -193,9 +185,7 @@
+ 		}
  		TEST_ALLOC_SIZE (copy, sizeof (EventOperator));
--		TEST_EQ_P (copy->node.parent, NULL);
--		TEST_EQ_P (copy->node.left, NULL);
--		TEST_EQ_P (copy->node.right, NULL);
++		TEST_LIST_EMPTY (&copy->children);
  		TEST_EQ (copy->type, EVENT_MATCH);
  		TEST_EQ (copy->value, TRUE);
  		TEST_EQ_STR (copy->name, "test");
@@ -233,9 +223,7 @@
+ 		}
  		TEST_ALLOC_SIZE (copy, sizeof (EventOperator));
--		TEST_EQ_P (copy->node.parent, NULL);
--		TEST_EQ_P (copy->node.left, NULL);
--		TEST_EQ_P (copy->node.right, NULL);
++		TEST_LIST_EMPTY (&copy->children);
  		TEST_EQ (copy->type, EVENT_MATCH);
  		TEST_EQ (copy->value, TRUE);
  		TEST_EQ_STR (copy->name, "test");
@@ -279,9 +267,7 @@
+ 		}
  		TEST_ALLOC_SIZE (copy, sizeof (EventOperator));
--		TEST_EQ_P (copy->node.parent, NULL);
--		TEST_EQ_P (copy->node.left, NULL);
--		TEST_EQ_P (copy->node.right, NULL);
++		TEST_LIST_EMPTY (&copy->children);
  		TEST_EQ (copy->type, EVENT_MATCH);
  		TEST_EQ (copy->value, TRUE);
  		TEST_EQ_STR (copy->name, "test");
@@ -302,7 +288,7 @@
  	TEST_FEATURE ("with children");
  	TEST_ALLOC_FAIL {
  		TEST_ALLOC_SAFE {
--			oper = event_operator_new (NULL, EVENT_OR, NULL, NULL);
++			oper = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
  			oper->value = TRUE;
  			oper1 = event_operator_new (NULL, EVENT_MATCH,
@@ -310,45 +296,37 @@
  			oper1->value = TRUE;
  			oper1->event = event_new (oper1, "foo", NULL);
  			event_block (oper1->event);
--			nih_tree_add (&oper->node, &oper1->node,
--				      NIH_TREE_LEFT);
++			event_operator_add_child (oper, oper1);
  			oper2 = event_operator_new (NULL, EVENT_MATCH,
  						    "bar", NULL);
  			oper2->value = TRUE;
  			oper2->event = event_new (oper2, "foo", NULL);
  			event_block (oper2->event);
--			nih_tree_add (&oper->node, &oper2->node,
--				      NIH_TREE_RIGHT);
++			event_operator_add_child (oper, oper2);
+ 		}
  		copy = event_operator_copy (NULL, oper);
  		if (test_alloc_failed) {
  			TEST_EQ_P (copy, NULL);
--			nih_free (oper);
  			TEST_EQ (oper1->event->blockers, 1);
--			nih_free (oper1);
  			TEST_EQ (oper2->event->blockers, 1);
--			nih_free (oper2);
++			nih_free (oper);
  			continue;
+ 		}
  		TEST_ALLOC_SIZE (copy, sizeof (EventOperator));
--		TEST_EQ_P (copy->node.parent, NULL);
--		TEST_NE_P (copy->node.left, NULL);
--		TEST_NE_P (copy->node.right, NULL);
--		TEST_EQ (copy->type, EVENT_OR);
++		TEST_LIST_NOT_EMPTY (&copy->children);
++		TEST_EQ (copy->type, EVENT_ANY);
  		TEST_EQ (copy->value, TRUE);
  		TEST_EQ_P (copy->name, NULL);
  		TEST_EQ_P (copy->env, NULL);
--		copy1 = (EventOperator *)copy->node.left;
++		copy1 = (EventOperator *)copy->children.next;
  		TEST_ALLOC_SIZE (copy1, sizeof (EventOperator));
  		TEST_ALLOC_PARENT (copy1, copy);
--		TEST_EQ_P (copy1->node.parent, &copy->node);
--		TEST_EQ_P (copy1->node.left, NULL);
--		TEST_EQ_P (copy1->node.right, NULL);
++		TEST_LIST_EMPTY (&copy1->children);
  		TEST_EQ (copy1->type, EVENT_MATCH);
  		TEST_EQ (copy1->value, TRUE);
  		TEST_EQ_STR (copy1->name, "foo");
@@ -360,12 +338,10 @@
  		nih_free (copy1);
--		copy2 = (EventOperator *)copy->node.right;
++		copy2 = (EventOperator *)copy1->entry.next;
  		TEST_ALLOC_SIZE (copy2, sizeof (EventOperator));
  		TEST_ALLOC_PARENT (copy2, copy);
--		TEST_EQ_P (copy2->node.parent, &copy->node);
--		TEST_EQ_P (copy2->node.left, NULL);
--		TEST_EQ_P (copy2->node.right, NULL);
++		TEST_LIST_EMPTY (&copy1->children);
  		TEST_EQ (copy2->type, EVENT_MATCH);
  		TEST_EQ (copy2->value, TRUE);
  		TEST_EQ_STR (copy2->name, "bar");
@@ -430,16 +406,16 @@
  	EventOperator *oper1, *oper2, *oper3;
  	TEST_FUNCTION ("event_operator_update");
--	oper1 = event_operator_new (NULL, EVENT_OR, NULL, NULL);
++	oper1 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
  	oper2 = event_operator_new (NULL, EVENT_MATCH, "foo", NULL);
  	oper3 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);
--	nih_tree_add (&oper1->node, &oper2->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper1->node, &oper3->node, NIH_TREE_RIGHT);
--
--
--	/* Check that EVENT_OR is FALSE if both children are FALSE. */
--	TEST_FEATURE ("with EVENT_OR and both children FALSE");
++	event_operator_add_child (oper1, oper2);
++	event_operator_add_child (oper1, oper3);
++
++
++	/* Check that EVENT_ANY is FALSE if both children are FALSE. */
++	TEST_FEATURE ("with EVENT_ANY and both children FALSE");
  	oper1->value = oper2->value = oper3->value = FALSE;
  	event_operator_update (oper1);
@@ -447,8 +423,8 @@
  	TEST_EQ (oper1->value, FALSE);
--	/* Check that EVENT_OR is TRUE if only the left child is TRUE. */
--	TEST_FEATURE ("with EVENT_OR and only left child TRUE");
++	/* Check that EVENT_ANY is TRUE if only the left child is TRUE. */
++	TEST_FEATURE ("with EVENT_ANY and only left child TRUE");
  	oper1->value = oper3->value = FALSE;
  	oper2->value = TRUE;
@@ -457,8 +433,8 @@
  	TEST_EQ (oper1->value, TRUE);
--	/* Check that EVENT_OR is TRUE if only the right child is TRUE. */
--	TEST_FEATURE ("with EVENT_OR and only right child TRUE");
++	/* Check that EVENT_ANY is TRUE if only the right child is TRUE. */
++	TEST_FEATURE ("with EVENT_ANY and only right child TRUE");
  	oper1->value = oper2->value = FALSE;
  	oper3->value = TRUE;
@@ -467,8 +443,8 @@
  	TEST_EQ (oper1->value, TRUE);
--	/* Check that EVENT_OR is TRUE if both children are TRUE. */
--	TEST_FEATURE ("with EVENT_OR and both children TRUE");
++	/* Check that EVENT_ANY is TRUE if both children are TRUE. */
++	TEST_FEATURE ("with EVENT_ANY and both children TRUE");
  	oper1->value = FALSE;
  	oper2->value = oper3->value = TRUE;
@@ -477,9 +453,9 @@
  	TEST_EQ (oper1->value, TRUE);
--	/* Check that EVENT_AND is FALSE if both children are FALSE. */
--	TEST_FEATURE ("with EVENT_AND and both children FALSE");
--	oper1->type = EVENT_AND;
++	/* Check that EVENT_ALL is FALSE if both children are FALSE. */
++	TEST_FEATURE ("with EVENT_ALL and both children FALSE");
++	oper1->type = EVENT_ALL;
  	oper1->value = oper2->value = oper3->value = FALSE;
  	event_operator_update (oper1);
@@ -487,8 +463,8 @@
  	TEST_EQ (oper1->value, FALSE);
--	/* Check that EVENT_AND is FALSE if only the left child is TRUE. */
--	TEST_FEATURE ("with EVENT_AND and only left child TRUE");
++	/* Check that EVENT_ALL is FALSE if only the left child is TRUE. */
++	TEST_FEATURE ("with EVENT_ALL and only left child TRUE");
  	oper1->value = oper3->value = FALSE;
  	oper2->value = TRUE;
@@ -497,8 +473,8 @@
  	TEST_EQ (oper1->value, FALSE);
--	/* Check that EVENT_AND is FALSE if only the right child is TRUE. */
--	TEST_FEATURE ("with EVENT_AND and only right child TRUE");
++	/* Check that EVENT_ALL is FALSE if only the right child is TRUE. */
++	TEST_FEATURE ("with EVENT_ALL and only right child TRUE");
  	oper1->value = oper2->value = FALSE;
  	oper3->value = TRUE;
@@ -507,8 +483,8 @@
  	TEST_EQ (oper1->value, FALSE);
--	/* Check that EVENT_AND is TRUE if both children are TRUE. */
--	TEST_FEATURE ("with EVENT_AND and both children TRUE");
++	/* Check that EVENT_ALL is TRUE if both children are TRUE. */
++	TEST_FEATURE ("with EVENT_ALL and both children TRUE");
  	oper1->value = FALSE;
  	oper2->value = oper3->value = TRUE;
@@ -518,8 +494,6 @@
  	nih_free (oper1);
--	nih_free (oper2);
--	nih_free (oper3);
+ }
  void
@@ -804,8 +778,8 @@
  	int            ret;
  	TEST_FUNCTION ("event_operator_handle");
--	oper1 = event_operator_new (NULL, EVENT_OR, NULL, NULL);
--	oper2 = event_operator_new (NULL, EVENT_AND, NULL, NULL);
++	oper1 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
++	oper2 = event_operator_new (NULL, EVENT_ALL, NULL, NULL);
  	oper3 = event_operator_new (NULL, EVENT_MATCH, "foo", NULL);
  	oper4 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);
  	oper5 = event_operator_new (NULL, EVENT_MATCH, "baz", NULL);
@@ -813,10 +787,10 @@
  	oper5->env[0] = "BAR=$WIBBLE";
  	oper5->env[1] = NULL;
--	nih_tree_add (&oper1->node, &oper2->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper2->node, &oper3->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper2->node, &oper4->node, NIH_TREE_RIGHT);
--	nih_tree_add (&oper1->node, &oper5->node, NIH_TREE_RIGHT);
++	event_operator_add_child (oper1, oper2);
++	event_operator_add_child (oper2, oper3);
++	event_operator_add_child (oper2, oper4);
++	event_operator_add_child (oper1, oper5);
  	/* Check that a non-matching event doesn't touch the tree. */
@@ -938,10 +912,6 @@
  	event_operator_reset (oper1);
  	nih_free (oper1);
--	nih_free (oper2);
--	nih_free (oper3);
--	nih_free (oper4);
--	nih_free (oper5);
  	event_poll ();
+ }
@@ -956,20 +926,20 @@
  	size_t          len;
  	TEST_FUNCTION ("event_operator_environment");
--	root = event_operator_new (NULL, EVENT_OR, NULL, NULL);
--	oper1 = event_operator_new (root, EVENT_AND, NULL, NULL);
--	oper2 = event_operator_new (root, EVENT_AND, NULL, NULL);
++	root = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
++	oper1 = event_operator_new (root, EVENT_ALL, NULL, NULL);
++	oper2 = event_operator_new (root, EVENT_ALL, NULL, NULL);
  	oper3 = event_operator_new (root, EVENT_MATCH, "foo", NULL);
  	oper4 = event_operator_new (root, EVENT_MATCH, "bar", NULL);
  	oper5 = event_operator_new (root, EVENT_MATCH, "frodo", NULL);
  	oper6 = event_operator_new (root, EVENT_MATCH, "bilbo", NULL);
--	nih_tree_add (&root->node, &oper1->node, NIH_TREE_LEFT);
--	nih_tree_add (&root->node, &oper2->node, NIH_TREE_RIGHT);
--	nih_tree_add (&oper1->node, &oper3->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper1->node, &oper4->node, NIH_TREE_RIGHT);
--	nih_tree_add (&oper2->node, &oper5->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper2->node, &oper6->node, NIH_TREE_RIGHT);
++	event_operator_add_child (root, oper1);
++	event_operator_add_child (root, oper2);
++	event_operator_add_child (oper1, oper3);
++	event_operator_add_child (oper1, oper4);
++	event_operator_add_child (oper2, oper5);
++	event_operator_add_child (oper2, oper6);
  	root->value = TRUE;
@@ -1124,20 +1094,20 @@
  	Blocked        *blocked;
  	TEST_FUNCTION ("event_operator_events");
--	root = event_operator_new (NULL, EVENT_OR, NULL, NULL);
--	oper1 = event_operator_new (root, EVENT_AND, NULL, NULL);
--	oper2 = event_operator_new (root, EVENT_AND, NULL, NULL);
++	root = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
++	oper1 = event_operator_new (root, EVENT_ALL, NULL, NULL);
++	oper2 = event_operator_new (root, EVENT_ALL, NULL, NULL);
  	oper3 = event_operator_new (root, EVENT_MATCH, "foo", NULL);
  	oper4 = event_operator_new (root, EVENT_MATCH, "bar", NULL);
  	oper5 = event_operator_new (root, EVENT_MATCH, "frodo", NULL);
  	oper6 = event_operator_new (root, EVENT_MATCH, "bilbo", NULL);
--	nih_tree_add (&root->node, &oper1->node, NIH_TREE_LEFT);
--	nih_tree_add (&root->node, &oper2->node, NIH_TREE_RIGHT);
--	nih_tree_add (&oper1->node, &oper3->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper1->node, &oper4->node, NIH_TREE_RIGHT);
--	nih_tree_add (&oper2->node, &oper5->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper2->node, &oper6->node, NIH_TREE_RIGHT);
++	event_operator_add_child (root, oper1);
++	event_operator_add_child (root, oper2);
++	event_operator_add_child (oper1, oper3);
++	event_operator_add_child (oper1, oper4);
++	event_operator_add_child (oper2, oper5);
++	event_operator_add_child (oper2, oper6);
  	root->value = TRUE;
@@ -1232,16 +1202,16 @@
  	 * all the values back to FALSE.
  	 */
  	TEST_FUNCTION ("event_operator_reset");
--	oper1 = event_operator_new (NULL, EVENT_OR, NULL, NULL);
--	oper2 = event_operator_new (NULL, EVENT_AND, NULL, NULL);
++	oper1 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
++	oper2 = event_operator_new (NULL, EVENT_ALL, NULL, NULL);
  	oper3 = event_operator_new (NULL, EVENT_MATCH, "foo", NULL);
  	oper4 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);
  	oper5 = event_operator_new (NULL, EVENT_MATCH, "baz", NULL);
--	nih_tree_add (&oper1->node, &oper2->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper2->node, &oper3->node, NIH_TREE_LEFT);
--	nih_tree_add (&oper2->node, &oper4->node, NIH_TREE_RIGHT);
--	nih_tree_add (&oper1->node, &oper5->node, NIH_TREE_RIGHT);
++	event_operator_add_child (oper1, oper2);
++	event_operator_add_child (oper2, oper3);
++	event_operator_add_child (oper2, oper4);
++	event_operator_add_child (oper1, oper5);
  	event1 = event_new (NULL, "foo", NULL);
  	event2 = event_new (NULL, "bar", NULL);
@@ -1274,15 +1244,73 @@
  	TEST_EQ (event2->blockers, 0);
  	nih_free (oper1);
--	nih_free (oper2);
--	nih_free (oper3);
--	nih_free (oper4);
--	nih_free (oper5);
  	event_poll ();
+ }
++void
++test_operator_add_child (void)
++{
++	EventOperator *oper1, *oper2, *oper3, *oper4, *oper5, *oper6, *oper7;
++	int found_foo = 0;
++	int found_bar = 0;
++	int found_baz = 0;
++	int found_bam = 0;
++	int found_all = 0;
++
++	TEST_FUNCTION ("event_operator_add_child");
++	oper1 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
++	oper2 = event_operator_new (NULL, EVENT_ALL, NULL, NULL);
++	oper3 = event_operator_new (NULL, EVENT_MATCH, "foo", NULL);
++	oper4 = event_operator_new (NULL, EVENT_MATCH, "bar", NULL);
++	oper5 = event_operator_new (NULL, EVENT_MATCH, "baz", NULL);
++	oper6 = event_operator_new (NULL, EVENT_MATCH, "bam", NULL);
++	oper7 = event_operator_new (NULL, EVENT_ANY, NULL, NULL);
++
++	event_operator_add_child (oper2, oper3);
++	event_operator_add_child (oper2, oper4);
++	event_operator_add_child (oper7, oper5);
++	event_operator_add_child (oper7, oper6);
++	event_operator_add_child (oper1, oper2);
++	event_operator_add_child (oper1, oper7);
++
++	TEST_EQ (oper1->type, EVENT_ANY);
++
++	NIH_LIST_FOREACH (&oper1->children, iter) {
++		EventOperator *child = (EventOperator *)iter;
++
++		if (child->type == EVENT_ALL) {
++			found_all++;
++			continue;
++		}
++
++		TEST_EQ (child->type, EVENT_MATCH);
++
++		if (! strncmp (child->name, "foo", 4))
++			found_foo++;
++
++		if (! strncmp (child->name, "bar", 4))
++			found_bar++;
++
++		if (! strncmp (child->name, "baz", 4))
++			found_baz++;
++
++		if (! strncmp (child->name, "bam", 4))
++			found_bam++;
++	}
++
++	// Not a truth test. 2 is also a failure.
++	TEST_EQ (found_all, 1);
++	TEST_EQ (found_foo, 0);
++	TEST_EQ (found_bar, 0);
++	TEST_EQ (found_baz, 1);
++	TEST_EQ (found_bam, 1);
++
++	nih_free (oper1);
++}
++
++
  int
  main (int   argc,
        char *argv[])
@@ -1296,6 +1324,7 @@
  	test_operator_environment ();
  	test_operator_events ();
  	test_operator_reset ();
++	test_operator_add_child ();
  	return 0;
+ }
 === modified file 'init/tests/test_parse_job.c'
 --- init/tests/test_parse_job.c	2009-07-09 11:01:53 +0000
 +++ init/tests/test_parse_job.c	2009-08-11 05:12:01 +0000
@@ -1714,11 +1714,12 @@
  void
  test_stanza_start (void)
+ {
--	JobClass     *job;
++	JobClass      *job;
  	EventOperator *oper;
  	NihError      *err;
  	size_t         pos, lineno;
  	char           buf[1024];
++	int            got_wibble, got_wobble, got_wiggle;
  	TEST_FUNCTION ("stanza_start");
@@ -1757,9 +1758,7 @@
  		TEST_EQ_STR (oper->name, "wibble");
  		TEST_EQ_P (oper->env, NULL);
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		nih_free (job);
+ 	}
@@ -1807,9 +1806,7 @@
  		TEST_EQ_STR (oper->env[2], "b?z*");
  		TEST_EQ_P (oper->env[3], NULL);
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		nih_free (job);
+ 	}
@@ -1861,9 +1858,7 @@
  		TEST_EQ_STR (oper->env[4], "BILBO=foo bar");
  		TEST_EQ_P (oper->env[5], NULL);
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		nih_free (job);
+ 	}
@@ -1901,31 +1896,26 @@
  		TEST_ALLOC_PARENT (job->start_on, job);
  		oper = job->start_on;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->start_on->node.left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->start_on->node.right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ANY);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		EventOperator *parent = oper;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ_P (child->env, NULL);
++			TEST_EQ (child->type, EVENT_MATCH);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble)
++				got_wibble = TRUE;
++			else if (!strncmp ("wobble", child->name, 7) && ! got_wobble)
++				got_wobble = TRUE;
++			else
++				TEST_FAILED ("Unexpected child");
++		}
  		nih_free (job);
+ 	}
@@ -1964,39 +1954,32 @@
  		TEST_ALLOC_PARENT (job->start_on, job);
  		oper = job->start_on;
--		TEST_EQ (oper->type, EVENT_AND);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->start_on->node.left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--
--		TEST_ALLOC_SIZE (oper->env, sizeof (char *) * 3);
--		TEST_EQ_STR (oper->env[0], "foo");
--		TEST_EQ_STR (oper->env[1], "bar");
--		TEST_EQ_P (oper->env[2], NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->start_on->node.right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--
--		TEST_ALLOC_SIZE (oper->env, sizeof (char *) * 3);
--		TEST_EQ_STR (oper->env[0], "frodo");
--		TEST_EQ_STR (oper->env[1], "bilbo");
--		TEST_EQ_P (oper->env[2], NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ALL);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_ALLOC_SIZE (child->env, sizeof (char *) * 3);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++				TEST_EQ_STR (child->env[0], "foo");
++				TEST_EQ_STR (child->env[1], "bar");
++				TEST_EQ_P (child->env[2], NULL);
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++				TEST_EQ_STR (child->env[0], "frodo");
++				TEST_EQ_STR (child->env[1], "bilbo");
++				TEST_EQ_P (child->env[2], NULL);
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -2034,48 +2017,29 @@
  		TEST_ALLOC_PARENT (job->start_on, job);
  		oper = job->start_on;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->start_on->node.left;
--		TEST_EQ (oper->type, EVENT_OR);
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->start_on->node.left->left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->start_on->node.left);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->start_on->node.left->right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->start_on->node.left);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->start_on->node.right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wiggle");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ANY);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		got_wiggle = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_EQ_P (child->env, NULL);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
++				got_wiggle = TRUE;
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -2112,49 +2076,29 @@
  		TEST_ALLOC_PARENT (job->start_on, job);
  		oper = job->start_on;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->start_on->node.left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->start_on->node.right;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->start_on->node.right->left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->start_on->node.right);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->start_on->node.right->right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wiggle");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->start_on->node.right);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ANY);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		got_wiggle = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_EQ_P (child->env, NULL);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
++				got_wiggle = TRUE;
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -2192,49 +2136,29 @@
  		TEST_ALLOC_PARENT (job->start_on, job);
  		oper = job->start_on;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->start_on->node.left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->start_on->node.right;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, &job->start_on->node);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->start_on->node.right->left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->start_on->node.right);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->start_on->node.right->right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wiggle");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->start_on->node.right);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ANY);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		got_wiggle = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_EQ_P (child->env, NULL);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
++				got_wiggle = TRUE;
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -2275,9 +2199,7 @@
  		TEST_EQ_STR (oper->name, "waggle");
  		TEST_EQ_P (oper->env, NULL);
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		nih_free (job);
+ 	}
@@ -2536,6 +2458,7 @@
  	NihError      *err;
  	size_t         pos, lineno;
  	char           buf[1024];
++	int            got_wibble, got_wobble, got_wiggle;
  	TEST_FUNCTION ("stanza_stop");
@@ -2574,9 +2497,7 @@
  		TEST_EQ_STR (oper->name, "wibble");
  		TEST_EQ_P (oper->env, NULL);
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		nih_free (job);
+ 	}
@@ -2624,9 +2545,7 @@
  		TEST_EQ_STR (oper->env[2], "b?z*");
  		TEST_EQ_P (oper->env[3], NULL);
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		nih_free (job);
+ 	}
@@ -2678,9 +2597,7 @@
  		TEST_EQ_STR (oper->env[4], "BILBO=foo bar");
  		TEST_EQ_P (oper->env[5], NULL);
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		nih_free (job);
+ 	}
@@ -2718,31 +2635,26 @@
  		TEST_ALLOC_PARENT (job->stop_on, job);
  		oper = job->stop_on;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->stop_on->node.left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->stop_on->node.right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ANY);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_EQ_P (child->env, NULL);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -2781,39 +2693,32 @@
  		TEST_ALLOC_PARENT (job->stop_on, job);
  		oper = job->stop_on;
--		TEST_EQ (oper->type, EVENT_AND);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->stop_on->node.left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--
--		TEST_ALLOC_SIZE (oper->env, sizeof (char *) * 3);
--		TEST_EQ_STR (oper->env[0], "foo");
--		TEST_EQ_STR (oper->env[1], "bar");
--		TEST_EQ_P (oper->env[2], NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->stop_on->node.right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--
--		TEST_ALLOC_SIZE (oper->env, sizeof (char *) * 3);
--		TEST_EQ_STR (oper->env[0], "frodo");
--		TEST_EQ_STR (oper->env[1], "bilbo");
--		TEST_EQ_P (oper->env[2], NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ALL);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_ALLOC_SIZE (child->env, sizeof (char *) * 3);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++				TEST_EQ_STR (child->env[0], "foo");
++				TEST_EQ_STR (child->env[1], "bar");
++				TEST_EQ_P (child->env[2], NULL);
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++				TEST_EQ_STR (child->env[0], "frodo");
++				TEST_EQ_STR (child->env[1], "bilbo");
++				TEST_EQ_P (child->env[2], NULL);
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -2851,48 +2756,29 @@
  		TEST_ALLOC_PARENT (job->stop_on, job);
  		oper = job->stop_on;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->stop_on->node.left;
--		TEST_EQ (oper->type, EVENT_OR);
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->stop_on->node.left->left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->stop_on->node.left);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->stop_on->node.left->right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->stop_on->node.left);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->stop_on->node.right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wiggle");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ANY);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		got_wiggle = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_EQ_P (child->env, NULL);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
++				got_wiggle = TRUE;
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -2929,49 +2815,29 @@
  		TEST_ALLOC_PARENT (job->stop_on, job);
  		oper = job->stop_on;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->stop_on->node.left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->stop_on->node.right;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->stop_on->node.right->left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->stop_on->node.right);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->stop_on->node.right->right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wiggle");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->stop_on->node.right);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ANY);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		got_wiggle = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_EQ_P (child->env, NULL);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
++				got_wiggle = TRUE;
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -3009,49 +2875,29 @@
  		TEST_ALLOC_PARENT (job->stop_on, job);
  		oper = job->stop_on;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->stop_on->node.left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wibble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->stop_on->node.right;
--		TEST_EQ (oper->type, EVENT_OR);
--
--		TEST_EQ_P (oper->node.parent, &job->stop_on->node);
--		TEST_ALLOC_SIZE (oper->node.left, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.left, oper);
--		TEST_ALLOC_SIZE (oper->node.right, sizeof (EventOperator));
--		TEST_ALLOC_PARENT (oper->node.right, oper);
--
--		oper = (EventOperator *)job->stop_on->node.right->left;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wobble");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->stop_on->node.right);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
--
--		oper = (EventOperator *)job->stop_on->node.right->right;
--		TEST_EQ (oper->type, EVENT_MATCH);
--		TEST_EQ_STR (oper->name, "wiggle");
--		TEST_EQ_P (oper->env, NULL);
--
--		TEST_EQ_P (oper->node.parent, job->stop_on->node.right);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_EQ (oper->type, EVENT_ANY);
++
++		got_wibble = FALSE;
++		got_wobble = FALSE;
++		got_wiggle = FALSE;
++		NIH_LIST_FOREACH (&oper->children, iter) {
++			EventOperator *child = (EventOperator *)iter;
++
++			TEST_ALLOC_SIZE (child, sizeof (EventOperator));
++
++			TEST_LIST_EMPTY (&child->children);
++			TEST_EQ (child->type, EVENT_MATCH);
++			TEST_EQ_P (child->env, NULL);
++			if (!strncmp ("wibble", child->name, 7) && ! got_wibble) {
++				got_wibble = TRUE;
++			} else if (!strncmp ("wobble", child->name, 7) && ! got_wobble) {
++				got_wobble = TRUE;
++			} else if (!strncmp ("wiggle", child->name, 7) && ! got_wiggle) {
++				got_wiggle = TRUE;
++			} else {
++				TEST_FAILED ("Unexpected child");
++			}
++		}
  		nih_free (job);
+ 	}
@@ -3092,9 +2938,7 @@
  		TEST_EQ_STR (oper->name, "waggle");
  		TEST_EQ_P (oper->env, NULL);
--		TEST_EQ_P (oper->node.parent, NULL);
--		TEST_EQ_P (oper->node.left, NULL);
--		TEST_EQ_P (oper->node.right, NULL);
++		TEST_LIST_EMPTY (&oper->children);
  		nih_free (job);
+ 	}