# -*- coding: iso-8859-1 -*-
# vim: set ft=python ts=3 sw=3 expandtab:
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
#              C E D A R
#          S O L U T I O N S       "Software done right."
#           S O F T W A R E
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# Copyright (c) 2004-2005,2007,2010,2015 Kenneth J. Pronovici.
# All rights reserved.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License,
# Version 2, as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# Copies of the GNU General Public License are available from
# the Free Software Foundation website, http://www.gnu.org/.
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# Author   : Kenneth J. Pronovici <pronovic@ieee.org>
# Language : Python 3 (>= 3.4)
# Project  : Cedar Backup, release 3
# Purpose  : Tests command-line interface functionality.
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

########################################################################
# Module documentation
########################################################################

"""
Unit tests for CedarBackup3/cli.py.

Code Coverage
=============

   This module contains individual tests for the many of the public functions
   and classes implemented in cli.py.  Where possible, we test functions that
   print output by passing a custom file descriptor.  Sometimes, we only ensure
   that a function or method runs without failure, and we don't validate what
   its result is or what it prints out.

Naming Conventions
==================

   I prefer to avoid large unit tests which validate more than one piece of
   functionality, and I prefer to avoid using overly descriptive (read: long)
   test names, as well.  Instead, I use lots of very small tests that each
   validate one specific thing.  These small tests are then named with an index
   number, yielding something like ``testAddDir_001`` or ``testValidate_010``.
   Each method has a docstring describing what it's supposed to accomplish.  I
   feel that this makes it easier to judge how important a given failure is,
   and also makes it somewhat easier to diagnose and fix individual problems.

Full vs. Reduced Tests
======================

   All of the tests in this module are considered safe to be run in an average
   build environment.  There is a no need to use a CLITESTS_FULL environment
   variable to provide a "reduced feature set" test suite as for some of the
   other test modules.

@author Kenneth J. Pronovici <pronovic@ieee.org>
"""


########################################################################
# Import modules and do runtime validations
########################################################################

import unittest
from os.path import isdir, isfile, islink, isabs, exists
from getopt import GetoptError
from CedarBackup3.testutil import failUnlessAssignRaises, captureOutput
from CedarBackup3.config import OptionsConfig, PeersConfig, ExtensionsConfig
from CedarBackup3.config import LocalPeer, RemotePeer
from CedarBackup3.config import ExtendedAction, ActionDependencies, PreActionHook, PostActionHook
from CedarBackup3.cli import _usage, _version, _diagnostics
from CedarBackup3.cli import Options
from CedarBackup3.cli import _ActionSet
from CedarBackup3.action import executeCollect, executeStage, executeStore, executePurge, executeRebuild, executeValidate


#######################################################################
# Test Case Classes
#######################################################################

######################
# TestFunctions class
######################

class TestFunctions(unittest.TestCase):

   """Tests for the public functions."""

   ################
   # Setup methods
   ################

   def setUp(self):
      pass

   def tearDown(self):
      pass


   ########################
   # Test simple functions
   ########################

   def testSimpleFuncs_001(self):
      """
      Test that the _usage() function runs without errors.
      We don't care what the output is, and we don't check.
      """
      captureOutput(_usage)

   def testSimpleFuncs_002(self):
      """
      Test that the _version() function runs without errors.
      We don't care what the output is, and we don't check.
      """
      captureOutput(_version)

   def testSimpleFuncs_003(self):
      """
      Test that the _diagnostics() function runs without errors.
      We don't care what the output is, and we don't check.
      """
      captureOutput(_diagnostics)


####################
# TestOptions class
####################

class TestOptions(unittest.TestCase):

   """Tests for the Options class."""

   ################
   # Setup methods
   ################

   def setUp(self):
      pass

   def tearDown(self):
      pass


   ##################
   # Utility methods
   ##################

   def failUnlessAssignRaises(self, exception, obj, prop, value):
      """Equivalent of :any:`failUnlessRaises`, but used for property assignments instead."""
      failUnlessAssignRaises(self, exception, obj, prop, value)


   ############################
   # Test __repr__ and __str__
   ############################

   def testStringFuncs_001(self):
      """
      Just make sure that the string functions don't have errors (i.e. bad variable names).
      """
      obj = Options()
      obj.__repr__()
      obj.__str__()


   ##################################
   # Test constructor and attributes
   ##################################

   def testConstructor_001(self):
      """
      Test constructor with no arguments.
      """
      options = Options()
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_002(self):
      """
      Test constructor with validate=False, no other arguments.
      """
      options = Options(validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_003(self):
      """
      Test constructor with argumentList=[], validate=False.
      """
      options = Options(argumentList=[], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_004(self):
      """
      Test constructor with argumentString="", validate=False.
      """
      options = Options(argumentString="", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_005(self):
      """
      Test constructor with argumentList=["--help", ], validate=False.
      """
      options = Options(argumentList=["--help", ], validate=False)
      self.assertEqual(True, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_006(self):
      """
      Test constructor with argumentString="--help", validate=False.
      """
      options = Options(argumentString="--help", validate=False)
      self.assertEqual(True, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_007(self):
      """
      Test constructor with argumentList=["-h", ], validate=False.
      """
      options = Options(argumentList=["-h", ], validate=False)
      self.assertEqual(True, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_008(self):
      """
      Test constructor with argumentString="-h", validate=False.
      """
      options = Options(argumentString="-h", validate=False)
      self.assertEqual(True, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_009(self):
      """
      Test constructor with argumentList=["--version", ], validate=False.
      """
      options = Options(argumentList=["--version", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(True, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_010(self):
      """
      Test constructor with argumentString="--version", validate=False.
      """
      options = Options(argumentString="--version", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(True, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_011(self):
      """
      Test constructor with argumentList=["-V", ], validate=False.
      """
      options = Options(argumentList=["-V", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(True, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_012(self):
      """
      Test constructor with argumentString="-V", validate=False.
      """
      options = Options(argumentString="-V", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(True, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_013(self):
      """
      Test constructor with argumentList=["--verbose", ], validate=False.
      """
      options = Options(argumentList=["--verbose", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(True, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_014(self):
      """
      Test constructor with argumentString="--verbose", validate=False.
      """
      options = Options(argumentString="--verbose", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(True, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_015(self):
      """
      Test constructor with argumentList=["-b", ], validate=False.
      """
      options = Options(argumentList=["-b", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(True, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_016(self):
      """
      Test constructor with argumentString="-b", validate=False.
      """
      options = Options(argumentString="-b", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(True, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_017(self):
      """
      Test constructor with argumentList=["--quiet", ], validate=False.
      """
      options = Options(argumentList=["--quiet", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(True, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_018(self):
      """
      Test constructor with argumentString="--quiet", validate=False.
      """
      options = Options(argumentString="--quiet", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(True, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_019(self):
      """
      Test constructor with argumentList=["-q", ], validate=False.
      """
      options = Options(argumentList=["-q", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(True, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_020(self):
      """
      Test constructor with argumentString="-q", validate=False.
      """
      options = Options(argumentString="-q", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(True, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_021(self):
      """
      Test constructor with argumentList=["--config", ], validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentList=["--config", ], validate=False)

   def testConstructor_022(self):
      """
      Test constructor with argumentString="--config", validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentString="--config", validate=False)

   def testConstructor_023(self):
      """
      Test constructor with argumentList=["-c", ], validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentList=["-c", ], validate=False)

   def testConstructor_024(self):
      """
      Test constructor with argumentString="-c", validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentString="-c", validate=False)

   def testConstructor_025(self):
      """
      Test constructor with argumentList=["--config", "something", ], validate=False.
      """
      options = Options(argumentList=["--config", "something", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual("something", options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_026(self):
      """
      Test constructor with argumentString="--config something", validate=False.
      """
      options = Options(argumentString="--config something", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual("something", options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_027(self):
      """
      Test constructor with argumentList=["-c", "something", ], validate=False.
      """
      options = Options(argumentList=["-c", "something", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual("something", options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_028(self):
      """
      Test constructor with argumentString="-c something", validate=False.
      """
      options = Options(argumentString="-c something", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual("something", options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_029(self):
      """
      Test constructor with argumentList=["--full", ], validate=False.
      """
      options = Options(argumentList=["--full", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(True, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_030(self):
      """
      Test constructor with argumentString="--full", validate=False.
      """
      options = Options(argumentString="--full", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(True, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_031(self):
      """
      Test constructor with argumentList=["-f", ], validate=False.
      """
      options = Options(argumentList=["-f", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(True, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_032(self):
      """
      Test constructor with argumentString="-f", validate=False.
      """
      options = Options(argumentString="-f", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(True, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_033(self):
      """
      Test constructor with argumentList=["--logfile", ], validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentList=["--logfile", ], validate=False)

   def testConstructor_034(self):
      """
      Test constructor with argumentString="--logfile", validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentString="--logfile", validate=False)

   def testConstructor_035(self):
      """
      Test constructor with argumentList=["-l", ], validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentList=["-l", ], validate=False)

   def testConstructor_036(self):
      """
      Test constructor with argumentString="-l", validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentString="-l", validate=False)

   def testConstructor_037(self):
      """
      Test constructor with argumentList=["--logfile", "something", ], validate=False.
      """
      options = Options(argumentList=["--logfile", "something", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual("something", options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_038(self):
      """
      Test constructor with argumentString="--logfile something", validate=False.
      """
      options = Options(argumentString="--logfile something", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual("something", options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_039(self):
      """
      Test constructor with argumentList=["-l", "something", ], validate=False.
      """
      options = Options(argumentList=["-l", "something", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual("something", options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_040(self):
      """
      Test constructor with argumentString="-l something", validate=False.
      """
      options = Options(argumentString="-l something", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual("something", options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_041(self):
      """
      Test constructor with argumentList=["--owner", ], validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentList=["--owner", ], validate=False)

   def testConstructor_042(self):
      """
      Test constructor with argumentString="--owner", validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentString="--owner", validate=False)

   def testConstructor_043(self):
      """
      Test constructor with argumentList=["-o", ], validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentList=["-o", ], validate=False)

   def testConstructor_044(self):
      """
      Test constructor with argumentString="-o", validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentString="-o", validate=False)

   def testConstructor_045(self):
      """
      Test constructor with argumentList=["--owner", "something", ], validate=False.
      """
      self.assertRaises(ValueError, Options, argumentList=["--owner", "something", ], validate=False)

   def testConstructor_046(self):
      """
      Test constructor with argumentString="--owner something", validate=False.
      """
      self.assertRaises(ValueError, Options, argumentString="--owner something", validate=False)

   def testConstructor_047(self):
      """
      Test constructor with argumentList=["-o", "something", ], validate=False.
      """
      self.assertRaises(ValueError, Options, argumentList=["-o", "something", ], validate=False)

   def testConstructor_048(self):
      """
      Test constructor with argumentString="-o something", validate=False.
      """
      self.assertRaises(ValueError, Options, argumentString="-o something", validate=False)

   def testConstructor_049(self):
      """
      Test constructor with argumentList=["--owner", "a:b", ], validate=False.
      """
      options = Options(argumentList=["--owner", "a:b", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(("a", "b"), options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_050(self):
      """
      Test constructor with argumentString="--owner a:b", validate=False.
      """
      options = Options(argumentString="--owner a:b", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(("a", "b"), options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_051(self):
      """
      Test constructor with argumentList=["-o", "a:b", ], validate=False.
      """
      options = Options(argumentList=["-o", "a:b", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(("a", "b"), options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_052(self):
      """
      Test constructor with argumentString="-o a:b", validate=False.
      """
      options = Options(argumentString="-o a:b", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(("a", "b"), options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_053(self):
      """
      Test constructor with argumentList=["--mode", ], validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentList=["--mode", ], validate=False)

   def testConstructor_054(self):
      """
      Test constructor with argumentString="--mode", validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentString="--mode", validate=False)

   def testConstructor_055(self):
      """
      Test constructor with argumentList=["-m", ], validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentList=["-m", ], validate=False)

   def testConstructor_056(self):
      """
      Test constructor with argumentString="-m", validate=False.
      """
      self.assertRaises(GetoptError, Options, argumentString="-m", validate=False)

   def testConstructor_057(self):
      """
      Test constructor with argumentList=["--mode", "something", ], validate=False.
      """
      self.assertRaises(ValueError, Options, argumentList=["--mode", "something", ], validate=False)

   def testConstructor_058(self):
      """
      Test constructor with argumentString="--mode something", validate=False.
      """
      self.assertRaises(ValueError, Options, argumentString="--mode something", validate=False)

   def testConstructor_059(self):
      """
      Test constructor with argumentList=["-m", "something", ], validate=False.
      """
      self.assertRaises(ValueError, Options, argumentList=["-m", "something", ], validate=False)

   def testConstructor_060(self):
      """
      Test constructor with argumentString="-m something", validate=False.
      """
      self.assertRaises(ValueError, Options, argumentString="-m something", validate=False)

   def testConstructor_061(self):
      """
      Test constructor with argumentList=["--mode", "631", ], validate=False.
      """
      options = Options(argumentList=["--mode", "631", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(0o631, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_062(self):
      """
      Test constructor with argumentString="--mode 631", validate=False.
      """
      options = Options(argumentString="--mode 631", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(0o631, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_063(self):
      """
      Test constructor with argumentList=["-m", "631", ], validate=False.
      """
      options = Options(argumentList=["-m", "631", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(0o631, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_064(self):
      """
      Test constructor with argumentString="-m 631", validate=False.
      """
      options = Options(argumentString="-m 631", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(0o631, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_065(self):
      """
      Test constructor with argumentList=["--output", ], validate=False.
      """
      options = Options(argumentList=["--output", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(True, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_066(self):
      """
      Test constructor with argumentString="--output", validate=False.
      """
      options = Options(argumentString="--output", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(True, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_067(self):
      """
      Test constructor with argumentList=["-O", ], validate=False.
      """
      options = Options(argumentList=["-O", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(True, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_068(self):
      """
      Test constructor with argumentString="-O", validate=False.
      """
      options = Options(argumentString="-O", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(True, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_069(self):
      """
      Test constructor with argumentList=["--debug", ], validate=False.
      """
      options = Options(argumentList=["--debug", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(True, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_070(self):
      """
      Test constructor with argumentString="--debug", validate=False.
      """
      options = Options(argumentString="--debug", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(True, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_071(self):
      """
      Test constructor with argumentList=["-d", ], validate=False.
      """
      options = Options(argumentList=["-d", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(True, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_072(self):
      """
      Test constructor with argumentString="-d", validate=False.
      """
      options = Options(argumentString="-d", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(True, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_073(self):
      """
      Test constructor with argumentList=["--stack", ], validate=False.
      """
      options = Options(argumentList=["--stack", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(True, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_074(self):
      """
      Test constructor with argumentString="--stack", validate=False.
      """
      options = Options(argumentString="--stack", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(True, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_075(self):
      """
      Test constructor with argumentList=["-s", ], validate=False.
      """
      options = Options(argumentList=["-s", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(True, options.stacktrace)
      self.assertEqual([], options.actions)

   def testConstructor_076(self):
      """
      Test constructor with argumentString="-s", validate=False.
      """
      options = Options(argumentString="-s", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(True, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_077(self):
      """
      Test constructor with argumentList=["all", ], validate=False.
      """
      options = Options(argumentList=["all", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["all", ], options.actions)

   def testConstructor_078(self):
      """
      Test constructor with argumentString="all", validate=False.
      """
      options = Options(argumentString="all", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["all", ], options.actions)

   def testConstructor_079(self):
      """
      Test constructor with argumentList=["collect", ], validate=False.
      """
      options = Options(argumentList=["collect", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", ], options.actions)

   def testConstructor_080(self):
      """
      Test constructor with argumentString="collect", validate=False.
      """
      options = Options(argumentString="collect", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", ], options.actions)

   def testConstructor_081(self):
      """
      Test constructor with argumentList=["stage", ], validate=False.
      """
      options = Options(argumentList=["stage", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["stage", ], options.actions)

   def testConstructor_082(self):
      """
      Test constructor with argumentString="stage", validate=False.
      """
      options = Options(argumentString="stage", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["stage", ], options.actions)

   def testConstructor_083(self):
      """
      Test constructor with argumentList=["store", ], validate=False.
      """
      options = Options(argumentList=["store", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["store", ], options.actions)

   def testConstructor_084(self):
      """
      Test constructor with argumentString="store", validate=False.
      """
      options = Options(argumentString="store", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["store", ], options.actions)

   def testConstructor_085(self):
      """
      Test constructor with argumentList=["purge", ], validate=False.
      """
      options = Options(argumentList=["purge", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["purge", ], options.actions)

   def testConstructor_086(self):
      """
      Test constructor with argumentString="purge", validate=False.
      """
      options = Options(argumentString="purge", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["purge", ], options.actions)

   def testConstructor_087(self):
      """
      Test constructor with argumentList=["rebuild", ], validate=False.
      """
      options = Options(argumentList=["rebuild", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["rebuild", ], options.actions)

   def testConstructor_088(self):
      """
      Test constructor with argumentString="rebuild", validate=False.
      """
      options = Options(argumentString="rebuild", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["rebuild", ], options.actions)

   def testConstructor_089(self):
      """
      Test constructor with argumentList=["validate", ], validate=False.
      """
      options = Options(argumentList=["validate", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["validate", ], options.actions)

   def testConstructor_090(self):
      """
      Test constructor with argumentString="validate", validate=False.
      """
      options = Options(argumentString="validate", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["validate", ], options.actions)

   def testConstructor_091(self):
      """
      Test constructor with argumentList=["collect", "all", ], validate=False.
      """
      options = Options(argumentList=["collect", "all", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "all", ], options.actions)

   def testConstructor_092(self):
      """
      Test constructor with argumentString="collect all", validate=False.
      """
      options = Options(argumentString="collect all", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "all", ], options.actions)

   def testConstructor_093(self):
      """
      Test constructor with argumentList=["collect", "rebuild", ], validate=False.
      """
      options = Options(argumentList=["collect", "rebuild", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "rebuild", ], options.actions)

   def testConstructor_094(self):
      """
      Test constructor with argumentString="collect rebuild", validate=False.
      """
      options = Options(argumentString="collect rebuild", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "rebuild", ], options.actions)

   def testConstructor_095(self):
      """
      Test constructor with argumentList=["collect", "validate", ], validate=False.
      """
      options = Options(argumentList=["collect", "validate", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "validate", ], options.actions)

   def testConstructor_096(self):
      """
      Test constructor with argumentString="collect validate", validate=False.
      """
      options = Options(argumentString="collect validate", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "validate", ], options.actions)

   def testConstructor_097(self):
      """
      Test constructor with argumentList=["-d", "--verbose", "-O", "--mode", "600", "collect", "stage", ], validate=False.
      """
      options = Options(argumentList=["-d", "--verbose", "-O", "--mode", "600", "collect", "stage", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(True, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(0o600, options.mode)
      self.assertEqual(True, options.output)
      self.assertEqual(True, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "stage", ], options.actions)

   def testConstructor_098(self):
      """
      Test constructor with argumentString="-d --verbose -O --mode 600 collect stage", validate=False.
      """
      options = Options(argumentString="-d --verbose -O --mode 600 collect stage", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(True, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(0o600, options.mode)
      self.assertEqual(True, options.output)
      self.assertEqual(True, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "stage", ], options.actions)

   def testConstructor_099(self):
      """
      Test constructor with argumentList=[], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=[], validate=True)

   def testConstructor_100(self):
      """
      Test constructor with argumentString="", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="", validate=True)

   def testConstructor_101(self):
      """
      Test constructor with argumentList=["--help", ], validate=True.
      """
      options = Options(argumentList=["--help", ], validate=True)
      self.assertEqual(True, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_102(self):
      """
      Test constructor with argumentString="--help", validate=True.
      """
      options = Options(argumentString="--help", validate=True)
      self.assertEqual(True, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_103(self):
      """
      Test constructor with argumentList=["-h", ], validate=True.
      """
      options = Options(argumentList=["-h", ], validate=True)
      self.assertEqual(True, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_104(self):
      """
      Test constructor with argumentString="-h", validate=True.
      """
      options = Options(argumentString="-h", validate=True)
      self.assertEqual(True, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_105(self):
      """
      Test constructor with argumentList=["--version", ], validate=True.
      """
      options = Options(argumentList=["--version", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(True, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_106(self):
      """
      Test constructor with argumentString="--version", validate=True.
      """
      options = Options(argumentString="--version", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(True, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_107(self):
      """
      Test constructor with argumentList=["-V", ], validate=True.
      """
      options = Options(argumentList=["-V", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(True, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_108(self):
      """
      Test constructor with argumentString="-V", validate=True.
      """
      options = Options(argumentString="-V", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(True, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_109(self):
      """
      Test constructor with argumentList=["--verbose", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--verbose", ], validate=True)

   def testConstructor_110(self):
      """
      Test constructor with argumentString="--verbose", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--verbose", validate=True)

   def testConstructor_111(self):
      """
      Test constructor with argumentList=["-b", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-b", ], validate=True)

   def testConstructor_112(self):
      """
      Test constructor with argumentString="-b", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-b", validate=True)

   def testConstructor_113(self):
      """
      Test constructor with argumentList=["--quiet", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--quiet", ], validate=True)

   def testConstructor_114(self):
      """
      Test constructor with argumentString="--quiet", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--quiet", validate=True)

   def testConstructor_115(self):
      """
      Test constructor with argumentList=["-q", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-q", ], validate=True)

   def testConstructor_116(self):
      """
      Test constructor with argumentString="-q", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-q", validate=True)

   def testConstructor_117(self):
      """
      Test constructor with argumentList=["--config", ], validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentList=["--config", ], validate=True)

   def testConstructor_118(self):
      """
      Test constructor with argumentString="--config", validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentString="--config", validate=True)

   def testConstructor_119(self):
      """
      Test constructor with argumentList=["-c", ], validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentList=["-c", ], validate=True)

   def testConstructor_120(self):
      """
      Test constructor with argumentString="-c", validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentString="-c", validate=True)

   def testConstructor_121(self):
      """
      Test constructor with argumentList=["--config", "something", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--config", "something", ], validate=True)

   def testConstructor_122(self):
      """
      Test constructor with argumentString="--config something", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--config something", validate=True)

   def testConstructor_123(self):
      """
      Test constructor with argumentList=["-c", "something", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-c", "something", ], validate=True)

   def testConstructor_124(self):
      """
      Test constructor with argumentString="-c something", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-c something", validate=True)

   def testConstructor_125(self):
      """
      Test constructor with argumentList=["--full", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--full", ], validate=True)

   def testConstructor_126(self):
      """
      Test constructor with argumentString="--full", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--full", validate=True)

   def testConstructor_127(self):
      """
      Test constructor with argumentList=["-f", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-f", ], validate=True)

   def testConstructor_128(self):
      """
      Test constructor with argumentString="-f", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-f", validate=True)

   def testConstructor_129(self):
      """
      Test constructor with argumentList=["--logfile", ], validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentList=["--logfile", ], validate=True)

   def testConstructor_130(self):
      """
      Test constructor with argumentString="--logfile", validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentString="--logfile", validate=True)

   def testConstructor_131(self):
      """
      Test constructor with argumentList=["-l", ], validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentList=["-l", ], validate=True)

   def testConstructor_132(self):
      """
      Test constructor with argumentString="-l", validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentString="-l", validate=True)

   def testConstructor_133(self):
      """
      Test constructor with argumentList=["--logfile", "something", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--logfile", "something", ], validate=True)

   def testConstructor_134(self):
      """
      Test constructor with argumentString="--logfile something", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--logfile something", validate=True)

   def testConstructor_135(self):
      """
      Test constructor with argumentList=["-l", "something", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-l", "something", ], validate=True)

   def testConstructor_136(self):
      """
      Test constructor with argumentString="-l something", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-l something", validate=True)

   def testConstructor_137(self):
      """
      Test constructor with argumentList=["--owner", ], validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentList=["--owner", ], validate=True)

   def testConstructor_138(self):
      """
      Test constructor with argumentString="--owner", validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentString="--owner", validate=True)

   def testConstructor_139(self):
      """
      Test constructor with argumentList=["-o", ], validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentList=["-o", ], validate=True)

   def testConstructor_140(self):
      """
      Test constructor with argumentString="-o", validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentString="-o", validate=True)

   def testConstructor_141(self):
      """
      Test constructor with argumentList=["--owner", "something", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--owner", "something", ], validate=True)

   def testConstructor_142(self):
      """
      Test constructor with argumentString="--owner something", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--owner something", validate=True)

   def testConstructor_143(self):
      """
      Test constructor with argumentList=["-o", "something", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-o", "something", ], validate=True)

   def testConstructor_144(self):
      """
      Test constructor with argumentString="-o something", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-o something", validate=True)

   def testConstructor_145(self):
      """
      Test constructor with argumentList=["--owner", "a:b", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--owner", "a:b", ], validate=True)

   def testConstructor_146(self):
      """
      Test constructor with argumentString="--owner a:b", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--owner a:b", validate=True)

   def testConstructor_147(self):
      """
      Test constructor with argumentList=["-o", "a:b", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-o", "a:b", ], validate=True)

   def testConstructor_148(self):
      """
      Test constructor with argumentString="-o a:b", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-o a:b", validate=True)

   def testConstructor_149(self):
      """
      Test constructor with argumentList=["--mode", ], validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentList=["--mode", ], validate=True)

   def testConstructor_150(self):
      """
      Test constructor with argumentString="--mode", validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentString="--mode", validate=True)

   def testConstructor_151(self):
      """
      Test constructor with argumentList=["-m", ], validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentList=["-m", ], validate=True)

   def testConstructor_152(self):
      """
      Test constructor with argumentString="-m", validate=True.
      """
      self.assertRaises(GetoptError, Options, argumentString="-m", validate=True)

   def testConstructor_153(self):
      """
      Test constructor with argumentList=["--mode", "something", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--mode", "something", ], validate=True)

   def testConstructor_154(self):
      """
      Test constructor with argumentString="--mode something", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--mode something", validate=True)

   def testConstructor_155(self):
      """
      Test constructor with argumentList=["-m", "something", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-m", "something", ], validate=True)

   def testConstructor_156(self):
      """
      Test constructor with argumentString="-m something", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-m something", validate=True)

   def testConstructor_157(self):
      """
      Test constructor with argumentList=["--mode", "631", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--mode", "631", ], validate=True)

   def testConstructor_158(self):
      """
      Test constructor with argumentString="--mode 631", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--mode 631", validate=True)

   def testConstructor_159(self):
      """
      Test constructor with argumentList=["-m", "631", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-m", "631", ], validate=True)

   def testConstructor_160(self):
      """
      Test constructor with argumentString="-m 631", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-m 631", validate=True)

   def testConstructor_161(self):
      """
      Test constructor with argumentList=["--output", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--output", ], validate=True)

   def testConstructor_162(self):
      """
      Test constructor with argumentString="--output", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--output", validate=True)

   def testConstructor_163(self):
      """
      Test constructor with argumentList=["-O", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-O", ], validate=True)

   def testConstructor_164(self):
      """
      Test constructor with argumentString="-O", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-O", validate=True)

   def testConstructor_165(self):
      """
      Test constructor with argumentList=["--debug", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--debug", ], validate=True)

   def testConstructor_166(self):
      """
      Test constructor with argumentString="--debug", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--debug", validate=True)

   def testConstructor_167(self):
      """
      Test constructor with argumentList=["-d", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-d", ], validate=True)

   def testConstructor_168(self):
      """
      Test constructor with argumentString="-d", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-d", validate=True)

   def testConstructor_169(self):
      """
      Test constructor with argumentList=["--stack", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--stack", ], validate=True)

   def testConstructor_170(self):
      """
      Test constructor with argumentString="--stack", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--stack", validate=True)

   def testConstructor_171(self):
      """
      Test constructor with argumentList=["-s", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-s", ], validate=True)

   def testConstructor_172(self):
      """
      Test constructor with argumentString="-s", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-s", validate=True)

   def testConstructor_173(self):
      """
      Test constructor with argumentList=["all", ], validate=True.
      """
      options = Options(argumentList=["all", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["all", ], options.actions)

   def testConstructor_174(self):
      """
      Test constructor with argumentString="all", validate=True.
      """
      options = Options(argumentString="all", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["all", ], options.actions)

   def testConstructor_175(self):
      """
      Test constructor with argumentList=["collect", ], validate=True.
      """
      options = Options(argumentList=["collect", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", ], options.actions)

   def testConstructor_176(self):
      """
      Test constructor with argumentString="collect", validate=True.
      """
      options = Options(argumentString="collect", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", ], options.actions)

   def testConstructor_177(self):
      """
      Test constructor with argumentList=["stage", ], validate=True.
      """
      options = Options(argumentList=["stage", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["stage", ], options.actions)

   def testConstructor_178(self):
      """
      Test constructor with argumentString="stage", validate=True.
      """
      options = Options(argumentString="stage", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["stage", ], options.actions)

   def testConstructor_179(self):
      """
      Test constructor with argumentList=["store", ], validate=True.
      """
      options = Options(argumentList=["store", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["store", ], options.actions)

   def testConstructor_180(self):
      """
      Test constructor with argumentString="store", validate=True.
      """
      options = Options(argumentString="store", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["store", ], options.actions)

   def testConstructor_181(self):
      """
      Test constructor with argumentList=["purge", ], validate=True.
      """
      options = Options(argumentList=["purge", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["purge", ], options.actions)

   def testConstructor_182(self):
      """
      Test constructor with argumentString="purge", validate=True.
      """
      options = Options(argumentString="purge", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["purge", ], options.actions)

   def testConstructor_183(self):
      """
      Test constructor with argumentList=["rebuild", ], validate=True.
      """
      options = Options(argumentList=["rebuild", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["rebuild", ], options.actions)

   def testConstructor_184(self):
      """
      Test constructor with argumentString="rebuild", validate=True.
      """
      options = Options(argumentString="rebuild", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["rebuild", ], options.actions)

   def testConstructor_185(self):
      """
      Test constructor with argumentList=["validate", ], validate=True.
      """
      options = Options(argumentList=["validate", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["validate", ], options.actions)

   def testConstructor_186(self):
      """
      Test constructor with argumentString="validate", validate=True.
      """
      options = Options(argumentString="validate", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["validate", ], options.actions)

   def testConstructor_187(self):
      """
      Test constructor with argumentList=["-d", "--verbose", "-O", "--mode", "600", "collect", "stage", ], validate=True.
      """
      options = Options(argumentList=["-d", "--verbose", "-O", "--mode", "600", "collect", "stage", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(True, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(0o600, options.mode)
      self.assertEqual(True, options.output)
      self.assertEqual(True, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "stage", ], options.actions)

   def testConstructor_188(self):
      """
      Test constructor with argumentString="-d --verbose -O --mode 600 collect stage", validate=True.
      """
      options = Options(argumentString="-d --verbose -O --mode 600 collect stage", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(True, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(0o600, options.mode)
      self.assertEqual(True, options.output)
      self.assertEqual(True, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual(["collect", "stage", ], options.actions)

   def testConstructor_189(self):
      """
      Test constructor with argumentList=["--managed", ], validate=False.
      """
      options = Options(argumentList=["--managed", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(True, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_190(self):
      """
      Test constructor with argumentString="--managed", validate=False.
      """
      options = Options(argumentString="--managed", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(True, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_191(self):
      """
      Test constructor with argumentList=["-M", ], validate=False.
      """
      options = Options(argumentList=["-M", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(True, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_192(self):
      """
      Test constructor with argumentString="-M", validate=False.
      """
      options = Options(argumentString="-M", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(True, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_193(self):
      """
      Test constructor with argumentList=["--managed-only", ], validate=False.
      """
      options = Options(argumentList=["--managed-only", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(True, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_194(self):
      """
      Test constructor with argumentString="--managed-only", validate=False.
      """
      options = Options(argumentString="--managed-only", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(True, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_195(self):
      """
      Test constructor with argumentList=["-N", ], validate=False.
      """
      options = Options(argumentList=["-N", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(True, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_196(self):
      """
      Test constructor with argumentString="-N", validate=False.
      """
      options = Options(argumentString="-N", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(True, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(False, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_197(self):
      """
      Test constructor with argumentList=["--managed", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--managed", ], validate=True)

   def testConstructor_198(self):
      """
      Test constructor with argumentString="--managed", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--managed", validate=True)

   def testConstructor_199(self):
      """
      Test constructor with argumentList=["-M", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-M", ], validate=True)

   def testConstructor_200(self):
      """
      Test constructor with argumentString="-M", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-M", validate=True)

   def testConstructor_201(self):
      """
      Test constructor with argumentList=["--managed-only", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["--managed-only", ], validate=True)

   def testConstructor_202(self):
      """
      Test constructor with argumentString="--managed-only", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="--managed-only", validate=True)

   def testConstructor_203(self):
      """
      Test constructor with argumentList=["-N", ], validate=True.
      """
      self.assertRaises(ValueError, Options, argumentList=["-N", ], validate=True)

   def testConstructor_204(self):
      """
      Test constructor with argumentString="-N", validate=True.
      """
      self.assertRaises(ValueError, Options, argumentString="-N", validate=True)

   def testConstructor_205(self):
      """
      Test constructor with argumentList=["--diagnostics", ], validate=False.
      """
      options = Options(argumentList=["--diagnostics", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(True, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_206(self):
      """
      Test constructor with argumentString="--diagnostics", validate=False.
      """
      options = Options(argumentString="--diagnostics", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(True, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_207(self):
      """
      Test constructor with argumentList=["-D", ], validate=False.
      """
      options = Options(argumentList=["-D", ], validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(True, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_208(self):
      """
      Test constructor with argumentString="-D", validate=False.
      """
      options = Options(argumentString="-D", validate=False)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(True, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_209(self):
      """
      Test constructor with argumentList=["--diagnostics", ], validate=True.
      """
      options = Options(argumentList=["--diagnostics", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(True, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_210(self):
      """
      Test constructor with argumentString="--diagnostics", validate=True.
      """
      options = Options(argumentString="--diagnostics", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(True, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_211(self):
      """
      Test constructor with argumentList=["-D", ], validate=True.
      """
      options = Options(argumentList=["-D", ], validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(True, options.diagnostics)
      self.assertEqual([], options.actions)

   def testConstructor_212(self):
      """
      Test constructor with argumentString="-D", validate=True.
      """
      options = Options(argumentString="-D", validate=True)
      self.assertEqual(False, options.help)
      self.assertEqual(False, options.version)
      self.assertEqual(False, options.verbose)
      self.assertEqual(False, options.quiet)
      self.assertEqual(None, options.config)
      self.assertEqual(False, options.full)
      self.assertEqual(False, options.managed)
      self.assertEqual(False, options.managedOnly)
      self.assertEqual(None, options.logfile)
      self.assertEqual(None, options.owner)
      self.assertEqual(None, options.mode)
      self.assertEqual(False, options.output)
      self.assertEqual(False, options.debug)
      self.assertEqual(False, options.stacktrace)
      self.assertEqual(True, options.diagnostics)
      self.assertEqual([], options.actions)


   ############################
   # Test comparison operators
   ############################

   def testComparison_001(self):
      """
      Test comparison of two identical objects, all attributes at defaults.
      """
      options1 = Options()
      options2 = Options()
      self.assertEqual(options1, options2)
      self.assertTrue(options1 == options2)
      self.assertTrue(not options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(options1 >= options2)
      self.assertTrue(not options1 != options2)

   def testComparison_002(self):
      """
      Test comparison of two identical objects, all attributes filled in and same.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertEqual(options1, options2)
      self.assertTrue(options1 == options2)
      self.assertTrue(not options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(options1 >= options2)
      self.assertTrue(not options1 != options2)

   def testComparison_003(self):
      """
      Test comparison of two identical objects, all attributes filled in, help different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = False
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(not options1 < options2)
      self.assertTrue(not options1 <= options2)
      self.assertTrue(options1 > options2)
      self.assertTrue(options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_004(self):
      """
      Test comparison of two identical objects, all attributes filled in, version different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = False
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_005(self):
      """
      Test comparison of two identical objects, all attributes filled in, verbose different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = False
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_006(self):
      """
      Test comparison of two identical objects, all attributes filled in, quiet different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = False
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(not options1 < options2)
      self.assertTrue(not options1 <= options2)
      self.assertTrue(options1 > options2)
      self.assertTrue(options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_007(self):
      """
      Test comparison of two identical objects, all attributes filled in, config different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "whatever"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(not options1 < options2)
      self.assertTrue(not options1 <= options2)
      self.assertTrue(options1 > options2)
      self.assertTrue(options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_008(self):
      """
      Test comparison of two identical objects, all attributes filled in, full different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = False
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_009(self):
      """
      Test comparison of two identical objects, all attributes filled in, logfile different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "stuff"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_010(self):
      """
      Test comparison of two identical objects, all attributes filled in, owner different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("c", "d")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_011(self):
      """
      Test comparison of two identical objects, all attributes filled in, mode different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = 0o600
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_012(self):
      """
      Test comparison of two identical objects, all attributes filled in, output different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = False
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_013(self):
      """
      Test comparison of two identical objects, all attributes filled in, debug different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = False
      options1.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(not options1 < options2)
      self.assertTrue(not options1 <= options2)
      self.assertTrue(options1 > options2)
      self.assertTrue(options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_014(self):
      """
      Test comparison of two identical objects, all attributes filled in, stacktrace different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = True
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_015(self):
      """
      Test comparison of two identical objects, all attributes filled in, managed different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = False
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_016(self):
      """
      Test comparison of two identical objects, all attributes filled in, managedOnly different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = False
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = "631"
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = False
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)

   def testComparison_017(self):
      """
      Test comparison of two identical objects, all attributes filled in, diagnostics different.
      """
      options1 = Options()
      options2 = Options()

      options1.help = True
      options1.version = True
      options1.verbose = True
      options1.quiet = True
      options1.config = "config"
      options1.full = True
      options1.managed = True
      options1.managedOnly = True
      options1.logfile = "logfile"
      options1.owner = ("a", "b")
      options1.mode = 0o631
      options1.output = True
      options1.debug = True
      options1.stacktrace = False
      options1.diagnostics = False
      options1.actions = ["collect", ]

      options2.help = True
      options2.version = True
      options2.verbose = True
      options2.quiet = True
      options2.config = "config"
      options2.full = True
      options2.managed = True
      options2.managedOnly = True
      options2.logfile = "logfile"
      options2.owner = ("a", "b")
      options2.mode = 0o631
      options2.output = True
      options2.debug = True
      options2.stacktrace = False
      options2.diagnostics = True
      options2.actions = ["collect", ]

      self.assertNotEqual(options1, options2)
      self.assertTrue(not options1 == options2)
      self.assertTrue(options1 < options2)
      self.assertTrue(options1 <= options2)
      self.assertTrue(not options1 > options2)
      self.assertTrue(not options1 >= options2)
      self.assertTrue(options1 != options2)


   ###########################
   # Test buildArgumentList()
   ###########################

   def testBuildArgumentList_001(self):
      """Test with no values set, validate=False."""
      options = Options()
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual([], argumentList)

   def testBuildArgumentList_002(self):
      """Test with help set, validate=False."""
      options = Options()
      options.help = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--help", ], argumentList)

   def testBuildArgumentList_003(self):
      """Test with version set, validate=False."""
      options = Options()
      options.version = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--version", ], argumentList)

   def testBuildArgumentList_004(self):
      """Test with verbose set, validate=False."""
      options = Options()
      options.verbose = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--verbose", ], argumentList)

   def testBuildArgumentList_005(self):
      """Test with quiet set, validate=False."""
      options = Options()
      options.quiet = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--quiet", ], argumentList)

   def testBuildArgumentList_006(self):
      """Test with config set, validate=False."""
      options = Options()
      options.config = "stuff"
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--config", "stuff", ], argumentList)

   def testBuildArgumentList_007(self):
      """Test with full set, validate=False."""
      options = Options()
      options.full = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--full", ], argumentList)

   def testBuildArgumentList_008(self):
      """Test with logfile set, validate=False."""
      options = Options()
      options.logfile = "bogus"
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--logfile", "bogus", ], argumentList)

   def testBuildArgumentList_009(self):
      """Test with owner set, validate=False."""
      options = Options()
      options.owner = ("ken", "group")
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--owner", "ken:group", ], argumentList)

   def testBuildArgumentList_010(self):
      """Test with mode set, validate=False."""
      options = Options()
      options.mode = 0o644
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--mode", "644", ], argumentList)

   def testBuildArgumentList_011(self):
      """Test with output set, validate=False."""
      options = Options()
      options.output = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--output", ], argumentList)

   def testBuildArgumentList_012(self):
      """Test with debug set, validate=False."""
      options = Options()
      options.debug = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--debug", ], argumentList)

   def testBuildArgumentList_013(self):
      """Test with stacktrace set, validate=False."""
      options = Options()
      options.stacktrace = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--stack", ], argumentList)

   def testBuildArgumentList_014(self):
      """Test with actions containing one item, validate=False."""
      options = Options()
      options.actions = [ "collect", ]
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["collect", ], argumentList)

   def testBuildArgumentList_015(self):
      """Test with actions containing multiple items, validate=False."""
      options = Options()
      options.actions = [ "collect", "stage", "store", "purge", ]
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["collect", "stage", "store", "purge", ], argumentList)

   def testBuildArgumentList_016(self):
      """Test with all values set, actions containing one item, validate=False."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.managed = True
      options.managedOnly = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", ]
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--help", "--version", "--verbose", "--quiet", "--config", "config",
                        "--full", "--managed", "--managed-only",
                        "--logfile", "logfile", "--owner", "a:b", "--mode", "631",
                        "--output", "--debug", "--stack", "--diagnostics", "collect", ], argumentList)

   def testBuildArgumentList_017(self):
      """Test with all values set, actions containing multiple items, validate=False."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.managed = True
      options.managedOnly = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", "stage", ]
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--help", "--version", "--verbose", "--quiet", "--config", "config",
                        "--full", "--managed", "--managed-only",
                        "--logfile", "logfile", "--owner", "a:b", "--mode", "631",
                        "--output", "--debug", "--stack", "--diagnostics", "collect", "stage", ], argumentList)

   def testBuildArgumentList_018(self):
      """Test with no values set, validate=True."""
      options = Options()
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_019(self):
      """Test with help set, validate=True."""
      options = Options()
      options.help = True
      argumentList = options.buildArgumentList(validate=True)
      self.assertEqual(["--help", ], argumentList)

   def testBuildArgumentList_020(self):
      """Test with version set, validate=True."""
      options = Options()
      options.version = True
      argumentList = options.buildArgumentList(validate=True)
      self.assertEqual(["--version", ], argumentList)

   def testBuildArgumentList_021(self):
      """Test with verbose set, validate=True."""
      options = Options()
      options.verbose = True
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_022(self):
      """Test with quiet set, validate=True."""
      options = Options()
      options.quiet = True
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_023(self):
      """Test with config set, validate=True."""
      options = Options()
      options.config = "stuff"
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_024(self):
      """Test with full set, validate=True."""
      options = Options()
      options.full = True
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_025(self):
      """Test with logfile set, validate=True."""
      options = Options()
      options.logfile = "bogus"
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_026(self):
      """Test with owner set, validate=True."""
      options = Options()
      options.owner = ("ken", "group")
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_027(self):
      """Test with mode set, validate=True."""
      options = Options()
      options.mode = 0o644
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_028(self):
      """Test with output set, validate=True."""
      options = Options()
      options.output = True
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_029(self):
      """Test with debug set, validate=True."""
      options = Options()
      options.debug = True
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_030(self):
      """Test with stacktrace set, validate=True."""
      options = Options()
      options.stacktrace = True
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_031(self):
      """Test with actions containing one item, validate=True."""
      options = Options()
      options.actions = [ "collect", ]
      argumentList = options.buildArgumentList(validate=True)
      self.assertEqual(["collect", ], argumentList)

   def testBuildArgumentList_032(self):
      """Test with actions containing multiple items, validate=True."""
      options = Options()
      options.actions = [ "collect", "stage", "store", "purge", ]
      argumentList = options.buildArgumentList(validate=True)
      self.assertEqual(["collect", "stage", "store", "purge", ], argumentList)

   def testBuildArgumentList_033(self):
      """Test with all values set (except managed ones), actions containing one item, validate=True."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", ]
      argumentList = options.buildArgumentList(validate=True)
      self.assertEqual(["--help", "--version", "--verbose", "--quiet", "--config", "config",
                        "--full", "--logfile", "logfile", "--owner", "a:b", "--mode", "631",
                        "--output", "--debug", "--stack", "--diagnostics", "collect", ], argumentList)

   def testBuildArgumentList_034(self):
      """Test with all values set (except managed ones), actions containing multiple items, validate=True."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", "stage", ]
      argumentList = options.buildArgumentList(validate=True)
      self.assertEqual(["--help", "--version", "--verbose", "--quiet", "--config", "config",
                        "--full", "--logfile", "logfile", "--owner", "a:b", "--mode", "631",
                        "--output", "--debug", "--stack", "--diagnostics", "collect", "stage", ], argumentList)

   def testBuildArgumentList_035(self):
      """Test with managed set, validate=False."""
      options = Options()
      options.managed = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--managed", ], argumentList)

   def testBuildArgumentList_036(self):
      """Test with managed set, validate=True."""
      options = Options()
      options.managed = True
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_037(self):
      """Test with managedOnly set, validate=False."""
      options = Options()
      options.managedOnly = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--managed-only", ], argumentList)

   def testBuildArgumentList_038(self):
      """Test with managedOnly set, validate=True."""
      options = Options()
      options.managedOnly = True
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_039(self):
      """Test with all values set, actions containing one item, validate=True."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.managed = True
      options.managedOnly = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", ]
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_040(self):
      """Test with all values set, actions containing multiple items, validate=True."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.managed = True
      options.managedOnly = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", "stage", ]
      self.assertRaises(ValueError, options.buildArgumentList, validate=True)

   def testBuildArgumentList_041(self):
      """Test with diagnostics set, validate=False."""
      options = Options()
      options.diagnostics = True
      argumentList = options.buildArgumentList(validate=False)
      self.assertEqual(["--diagnostics", ], argumentList)

   def testBuildArgumentList_042(self):
      """Test with diagnostics set, validate=True."""
      options = Options()
      options.diagnostics = True
      argumentList = options.buildArgumentList(validate=True)
      self.assertEqual(["--diagnostics", ], argumentList)


   #############################
   # Test buildArgumentString()
   #############################

   def testBuildArgumentString_001(self):
      """Test with no values set, validate=False."""
      options = Options()
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("", argumentString)

   def testBuildArgumentString_002(self):
      """Test with help set, validate=False."""
      options = Options()
      options.help = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--help ", argumentString)

   def testBuildArgumentString_003(self):
      """Test with version set, validate=False."""
      options = Options()
      options.version = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--version ", argumentString)

   def testBuildArgumentString_004(self):
      """Test with verbose set, validate=False."""
      options = Options()
      options.verbose = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--verbose ", argumentString)

   def testBuildArgumentString_005(self):
      """Test with quiet set, validate=False."""
      options = Options()
      options.quiet = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--quiet ", argumentString)

   def testBuildArgumentString_006(self):
      """Test with config set, validate=False."""
      options = Options()
      options.config = "stuff"
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual('--config "stuff" ', argumentString)

   def testBuildArgumentString_007(self):
      """Test with full set, validate=False."""
      options = Options()
      options.full = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--full ", argumentString)

   def testBuildArgumentString_008(self):
      """Test with logfile set, validate=False."""
      options = Options()
      options.logfile = "bogus"
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual('--logfile "bogus" ', argumentString)

   def testBuildArgumentString_009(self):
      """Test with owner set, validate=False."""
      options = Options()
      options.owner = ("ken", "group")
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual('--owner "ken:group" ', argumentString)

   def testBuildArgumentString_010(self):
      """Test with mode set, validate=False."""
      options = Options()
      options.mode = 0o644
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual('--mode 644 ', argumentString)

   def testBuildArgumentString_011(self):
      """Test with output set, validate=False."""
      options = Options()
      options.output = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--output ", argumentString)

   def testBuildArgumentString_012(self):
      """Test with debug set, validate=False."""
      options = Options()
      options.debug = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--debug ", argumentString)

   def testBuildArgumentString_013(self):
      """Test with stacktrace set, validate=False."""
      options = Options()
      options.stacktrace = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--stack ", argumentString)

   def testBuildArgumentString_014(self):
      """Test with actions containing one item, validate=False."""
      options = Options()
      options.actions = [ "collect", ]
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual('"collect" ', argumentString)

   def testBuildArgumentString_015(self):
      """Test with actions containing multiple items, validate=False."""
      options = Options()
      options.actions = [ "collect", "stage", "store", "purge", ]
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual('"collect" "stage" "store" "purge" ', argumentString)

   def testBuildArgumentString_016(self):
      """Test with all values set, actions containing one item, validate=False."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.managed = True
      options.managedOnly = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", ]
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual('--help --version --verbose --quiet --config "config" --full --managed --managed-only --logfile "logfile" --owner "a:b" --mode 631 --output --debug --stack --diagnostics "collect" ', argumentString)

   def testBuildArgumentString_017(self):
      """Test with all values set, actions containing multiple items, validate=False."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", "stage", ]
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual('--help --version --verbose --quiet --config "config" --full --logfile "logfile" --owner "a:b" --mode 631 --output --debug --stack --diagnostics "collect" "stage" ', argumentString)

   def testBuildArgumentString_018(self):
      """Test with no values set, validate=True."""
      options = Options()
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_019(self):
      """Test with help set, validate=True."""
      options = Options()
      options.help = True
      argumentString = options.buildArgumentString(validate=True)
      self.assertEqual("--help ", argumentString)

   def testBuildArgumentString_020(self):
      """Test with version set, validate=True."""
      options = Options()
      options.version = True
      argumentString = options.buildArgumentString(validate=True)
      self.assertEqual("--version ", argumentString)

   def testBuildArgumentString_021(self):
      """Test with verbose set, validate=True."""
      options = Options()
      options.verbose = True
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_022(self):
      """Test with quiet set, validate=True."""
      options = Options()
      options.quiet = True
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_023(self):
      """Test with config set, validate=True."""
      options = Options()
      options.config = "stuff"
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_024(self):
      """Test with full set, validate=True."""
      options = Options()
      options.full = True
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_025(self):
      """Test with logfile set, validate=True."""
      options = Options()
      options.logfile = "bogus"
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_026(self):
      """Test with owner set, validate=True."""
      options = Options()
      options.owner = ("ken", "group")
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_027(self):
      """Test with mode set, validate=True."""
      options = Options()
      options.mode = 0o644
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_028(self):
      """Test with output set, validate=True."""
      options = Options()
      options.output = True
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_029(self):
      """Test with debug set, validate=True."""
      options = Options()
      options.debug = True
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_030(self):
      """Test with stacktrace set, validate=True."""
      options = Options()
      options.stacktrace = True
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_031(self):
      """Test with actions containing one item, validate=True."""
      options = Options()
      options.actions = [ "collect", ]
      argumentString = options.buildArgumentString(validate=True)
      self.assertEqual('"collect" ', argumentString)

   def testBuildArgumentString_032(self):
      """Test with actions containing multiple items, validate=True."""
      options = Options()
      options.actions = [ "collect", "stage", "store", "purge", ]
      argumentString = options.buildArgumentString(validate=True)
      self.assertEqual('"collect" "stage" "store" "purge" ', argumentString)

   def testBuildArgumentString_033(self):
      """Test with all values set (except managed ones), actions containing one item, validate=True."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", ]
      argumentString = options.buildArgumentString(validate=True)
      self.assertEqual('--help --version --verbose --quiet --config "config" --full --logfile "logfile" --owner "a:b" --mode 631 --output --debug --stack --diagnostics "collect" ', argumentString)

   def testBuildArgumentString_034(self):
      """Test with all values set (except managed ones), actions containing multiple items, validate=True."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", "stage", ]
      argumentString = options.buildArgumentString(validate=True)
      self.assertEqual('--help --version --verbose --quiet --config "config" --full --logfile "logfile" --owner "a:b" --mode 631 --output --debug --stack --diagnostics "collect" "stage" ', argumentString)

   def testBuildArgumentString_035(self):
      """Test with managed set, validate=False."""
      options = Options()
      options.managed = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--managed ", argumentString)

   def testBuildArgumentString_036(self):
      """Test with managed set, validate=True."""
      options = Options()
      options.managed = True
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_037(self):
      """Test with full set, validate=False."""
      options = Options()
      options.managedOnly = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--managed-only ", argumentString)

   def testBuildArgumentString_038(self):
      """Test with managedOnly set, validate=True."""
      options = Options()
      options.managedOnly = True
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_039(self):
      """Test with all values set (except managed ones), actions containing one item, validate=True."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.managed = True
      options.managedOnly = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", ]
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_040(self):
      """Test with all values set (except managed ones), actions containing multiple items, validate=True."""
      options = Options()
      options.help = True
      options.version = True
      options.verbose = True
      options.quiet = True
      options.config = "config"
      options.full = True
      options.managed = True
      options.managedOnly = True
      options.logfile = "logfile"
      options.owner = ("a", "b")
      options.mode = "631"
      options.output = True
      options.debug = True
      options.stacktrace = True
      options.diagnostics = True
      options.actions = ["collect", "stage", ]
      self.assertRaises(ValueError, options.buildArgumentString, validate=True)

   def testBuildArgumentString_041(self):
      """Test with diagnostics set, validate=False."""
      options = Options()
      options.diagnostics = True
      argumentString = options.buildArgumentString(validate=False)
      self.assertEqual("--diagnostics ", argumentString)

   def testBuildArgumentString_042(self):
      """Test with diagnostics set, validate=True."""
      options = Options()
      options.diagnostics = True
      argumentString = options.buildArgumentString(validate=True)
      self.assertEqual("--diagnostics ", argumentString)


######################
# TestActionSet class
######################

class TestActionSet(unittest.TestCase):

   """Tests for the _ActionSet class."""

   ################
   # Setup methods
   ################

   def setUp(self):
      pass

   def tearDown(self):
      pass


   #######################################
   # Test constructor, "index" order mode
   #######################################

   def testActionSet_001(self):
      """
      Test with actions=None, extensions=None.
      """
      actions = None
      extensions = ExtensionsConfig(None, None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_002(self):
      """
      Test with actions=[], extensions=None.
      """
      actions = []
      extensions = ExtensionsConfig(None, None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_003(self):
      """
      Test with actions=[], extensions=[].
      """
      actions = []
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_004(self):
      """
      Test with actions=[ collect ], extensions=[].
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testActionSet_005(self):
      """
      Test with actions=[ stage ], extensions=[].
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

   def testActionSet_006(self):
      """
      Test with actions=[ store ], extensions=[].
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)

   def testActionSet_007(self):
      """
      Test with actions=[ purge ], extensions=[].
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)

   def testActionSet_008(self):
      """
      Test with actions=[ all ], extensions=[].
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testActionSet_009(self):
      """
      Test with actions=[ rebuild ], extensions=[].
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("rebuild", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeRebuild, actionSet.actionSet[0].function)

   def testActionSet_010(self):
      """
      Test with actions=[ validate ], extensions=[].
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("validate", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeValidate, actionSet.actionSet[0].function)

   def testActionSet_011(self):
      """
      Test with actions=[ collect, collect ], extensions=[].
      """
      actions = [ "collect", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_012(self):
      """
      Test with actions=[ collect, stage ], extensions=[].
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testActionSet_013(self):
      """
      Test with actions=[ collect, store ], extensions=[].
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testActionSet_014(self):
      """
      Test with actions=[ collect, purge ], extensions=[].
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_015(self):
      """
      Test with actions=[ collect, all ], extensions=[].
      """
      actions = [ "collect", "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_016(self):
      """
      Test with actions=[ collect, rebuild ], extensions=[].
      """
      actions = [ "collect", "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_017(self):
      """
      Test with actions=[ collect, validate ], extensions=[].
      """
      actions = [ "collect", "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_018(self):
      """
      Test with actions=[ stage, collect ], extensions=[].
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testActionSet_019(self):
      """
      Test with actions=[ stage, stage ], extensions=[].
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testActionSet_020(self):
      """
      Test with actions=[ stage, store ], extensions=[].
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testActionSet_021(self):
      """
      Test with actions=[ stage, purge ], extensions=[].
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_022(self):
      """
      Test with actions=[ stage, all ], extensions=[].
      """
      actions = [ "stage", "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_023(self):
      """
      Test with actions=[ stage, rebuild ], extensions=[].
      """
      actions = [ "stage", "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_024(self):
      """
      Test with actions=[ stage, validate ], extensions=[].
      """
      actions = [ "stage", "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_025(self):
      """
      Test with actions=[ store, collect ], extensions=[].
      """
      actions = [ "store", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testActionSet_026(self):
      """
      Test with actions=[ store, stage ], extensions=[].
      """
      actions = [ "store", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testActionSet_027(self):
      """
      Test with actions=[ store, store ], extensions=[].
      """
      actions = [ "store", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testActionSet_028(self):
      """
      Test with actions=[ store, purge ], extensions=[].
      """
      actions = [ "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_029(self):
      """
      Test with actions=[ store, all ], extensions=[].
      """
      actions = [ "store", "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_030(self):
      """
      Test with actions=[ store, rebuild ], extensions=[].
      """
      actions = [ "store", "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_031(self):
      """
      Test with actions=[ store, validate ], extensions=[].
      """
      actions = [ "store", "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_032(self):
      """
      Test with actions=[ purge, collect ], extensions=[].
      """
      actions = [ "purge", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_033(self):
      """
      Test with actions=[ purge, stage ], extensions=[].
      """
      actions = [ "purge", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_034(self):
      """
      Test with actions=[ purge, store ], extensions=[].
      """
      actions = [ "purge", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_035(self):
      """
      Test with actions=[ purge, purge ], extensions=[].
      """
      actions = [ "purge", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_036(self):
      """
      Test with actions=[ purge, all ], extensions=[].
      """
      actions = [ "purge", "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_037(self):
      """
      Test with actions=[ purge, rebuild ], extensions=[].
      """
      actions = [ "purge", "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_038(self):
      """
      Test with actions=[ purge, validate ], extensions=[].
      """
      actions = [ "purge", "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_039(self):
      """
      Test with actions=[ all, collect ], extensions=[].
      """
      actions = [ "all", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_040(self):
      """
      Test with actions=[ all, stage ], extensions=[].
      """
      actions = [ "all", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_041(self):
      """
      Test with actions=[ all, store ], extensions=[].
      """
      actions = [ "all", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_042(self):
      """
      Test with actions=[ all, purge ], extensions=[].
      """
      actions = [ "all", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_043(self):
      """
      Test with actions=[ all, all ], extensions=[].
      """
      actions = [ "all", "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_044(self):
      """
      Test with actions=[ all, rebuild ], extensions=[].
      """
      actions = [ "all", "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_045(self):
      """
      Test with actions=[ all, validate ], extensions=[].
      """
      actions = [ "all", "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_046(self):
      """
      Test with actions=[ rebuild, collect ], extensions=[].
      """
      actions = [ "rebuild", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_047(self):
      """
      Test with actions=[ rebuild, stage ], extensions=[].
      """
      actions = [ "rebuild", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_048(self):
      """
      Test with actions=[ rebuild, store ], extensions=[].
      """
      actions = [ "rebuild", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_049(self):
      """
      Test with actions=[ rebuild, purge ], extensions=[].
      """
      actions = [ "rebuild", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_050(self):
      """
      Test with actions=[ rebuild, all ], extensions=[].
      """
      actions = [ "rebuild", "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_051(self):
      """
      Test with actions=[ rebuild, rebuild ], extensions=[].
      """
      actions = [ "rebuild", "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_052(self):
      """
      Test with actions=[ rebuild, validate ], extensions=[].
      """
      actions = [ "rebuild", "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_053(self):
      """
      Test with actions=[ validate, collect ], extensions=[].
      """
      actions = [ "validate", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_054(self):
      """
      Test with actions=[ validate, stage ], extensions=[].
      """
      actions = [ "validate", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_055(self):
      """
      Test with actions=[ validate, store ], extensions=[].
      """
      actions = [ "validate", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_056(self):
      """
      Test with actions=[ validate, purge ], extensions=[].
      """
      actions = [ "validate", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_057(self):
      """
      Test with actions=[ validate, all ], extensions=[].
      """
      actions = [ "validate", "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_058(self):
      """
      Test with actions=[ validate, rebuild ], extensions=[].
      """
      actions = [ "validate", "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_059(self):
      """
      Test with actions=[ validate, validate ], extensions=[].
      """
      actions = [ "validate", "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_060(self):
      """
      Test with actions=[ bogus ], extensions=[].
      """
      actions = [ "bogus", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_061(self):
      """
      Test with actions=[ bogus, collect ], extensions=[].
      """
      actions = [ "bogus", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_062(self):
      """
      Test with actions=[ bogus, stage ], extensions=[].
      """
      actions = [ "bogus", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_063(self):
      """
      Test with actions=[ bogus, store ], extensions=[].
      """
      actions = [ "bogus", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_064(self):
      """
      Test with actions=[ bogus, purge ], extensions=[].
      """
      actions = [ "bogus", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_065(self):
      """
      Test with actions=[ bogus, all ], extensions=[].
      """
      actions = [ "bogus", "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_066(self):
      """
      Test with actions=[ bogus, rebuild ], extensions=[].
      """
      actions = [ "bogus", "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_067(self):
      """
      Test with actions=[ bogus, validate ], extensions=[].
      """
      actions = [ "bogus", "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_068(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ].
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_069(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, index 50) ].
      """
      actions = [ "stage", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testActionSet_070(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ].
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testActionSet_071(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, index 50) ].
      """
      actions = [ "purge", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_072(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, index 50) ].
      """
      actions = [ "all", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_073(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, index 50) ].
      """
      actions = [ "rebuild", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_074(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, index 50) ].
      """
      actions = [ "validate", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_075(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ].
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(150, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_076(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, index 150) ].
      """
      actions = [ "stage", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testActionSet_077(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ].
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testActionSet_078(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, index 150) ].
      """
      actions = [ "purge", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_079(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, index 150) ].
      """
      actions = [ "all", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_080(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, index 150) ].
      """
      actions = [ "rebuild", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_081(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, index 150) ].
      """
      actions = [ "validate", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_082(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 250) ].
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 250), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(250, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_083(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, index 250) ].
      """
      actions = [ "stage", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 250), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(250, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_084(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 250) ].
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 250), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(250, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testActionSet_085(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, index 250) ].
      """
      actions = [ "purge", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 250), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(250, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_086(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, index 250) ].
      """
      actions = [ "all", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 250), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_087(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, index 250) ].
      """
      actions = [ "rebuild", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 250), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_088(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, index 250) ].
      """
      actions = [ "validate", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 250), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_089(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 350) ].
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 350), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(350, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_090(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, index 350) ].
      """
      actions = [ "stage", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 350), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(350, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_091(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 350) ].
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 350), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)
      self.assertEqual(350, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_092(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, index 350) ].
      """
      actions = [ "purge", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 350), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(350, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testActionSet_093(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, index 350) ].
      """
      actions = [ "all", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 350), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_094(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, index 350) ].
      """
      actions = [ "rebuild", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 350), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_095(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, index 350) ].
      """
      actions = [ "validate", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 350), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_096(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 450) ].
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 450), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(450, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_097(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, index 450) ].
      """
      actions = [ "stage", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 450), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(450, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_098(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 450) ].
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 450), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)
      self.assertEqual(450, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_099(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, index 450) ].
      """
      actions = [ "purge", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 450), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)
      self.assertEqual(450, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_100(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, index 450) ].
      """
      actions = [ "all", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 450), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_101(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, index 450) ].
      """
      actions = [ "rebuild", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 450), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_102(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, index 450) ].
      """
      actions = [ "validate", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 450), ], None)
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testActionSet_103(self):
      """
      Test with actions=[ one, one ], extensions=[ (one, index 450) ].
      """
      actions = [ "one", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 450), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(450, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(450, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testActionSet_104(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[].
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testActionSet_105(self):
      """
      Test with actions=[ stage, purge, collect, store ], extensions=[].
      """
      actions = [ "stage", "purge", "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testActionSet_106(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four, five ], extensions=[ (index 50, 150, 250, 350, 450)].
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 9)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)
      self.assertEqual(150, actionSet.actionSet[2].index)
      self.assertEqual("two", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(isfile, actionSet.actionSet[2].function)
      self.assertEqual(200, actionSet.actionSet[3].index)
      self.assertEqual("stage", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[3].function)
      self.assertEqual(250, actionSet.actionSet[4].index)
      self.assertEqual("three", actionSet.actionSet[4].name)
      self.assertEqual(None, actionSet.actionSet[4].preHooks)
      self.assertEqual(None, actionSet.actionSet[4].postHooks)
      self.assertEqual(islink, actionSet.actionSet[4].function)
      self.assertEqual(300, actionSet.actionSet[5].index)
      self.assertEqual("store", actionSet.actionSet[5].name)
      self.assertEqual(None, actionSet.actionSet[5].preHooks)
      self.assertEqual(None, actionSet.actionSet[5].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[5].function)
      self.assertEqual(350, actionSet.actionSet[6].index)
      self.assertEqual("four", actionSet.actionSet[6].name)
      self.assertEqual(None, actionSet.actionSet[6].preHooks)
      self.assertEqual(None, actionSet.actionSet[6].postHooks)
      self.assertEqual(isabs, actionSet.actionSet[6].function)
      self.assertEqual(400, actionSet.actionSet[7].index)
      self.assertEqual("purge", actionSet.actionSet[7].name)
      self.assertEqual(None, actionSet.actionSet[7].preHooks)
      self.assertEqual(None, actionSet.actionSet[7].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[7].function)
      self.assertEqual(450, actionSet.actionSet[8].index)
      self.assertEqual("five", actionSet.actionSet[8].name)
      self.assertEqual(None, actionSet.actionSet[8].preHooks)
      self.assertEqual(None, actionSet.actionSet[8].postHooks)
      self.assertEqual(exists, actionSet.actionSet[8].function)

   def testActionSet_107(self):
      """
      Test with actions=[ one, five, collect, store, three, stage, four, purge, two ], extensions=[ (index 50, 150, 250, 350, 450)].
      """
      actions = [ "one", "five", "collect", "store", "three", "stage", "four", "purge", "two", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 9)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)
      self.assertEqual(150, actionSet.actionSet[2].index)
      self.assertEqual("two", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(isfile, actionSet.actionSet[2].function)
      self.assertEqual(200, actionSet.actionSet[3].index)
      self.assertEqual("stage", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[3].function)
      self.assertEqual(250, actionSet.actionSet[4].index)
      self.assertEqual("three", actionSet.actionSet[4].name)
      self.assertEqual(None, actionSet.actionSet[4].preHooks)
      self.assertEqual(None, actionSet.actionSet[4].postHooks)
      self.assertEqual(islink, actionSet.actionSet[4].function)
      self.assertEqual(300, actionSet.actionSet[5].index)
      self.assertEqual("store", actionSet.actionSet[5].name)
      self.assertEqual(None, actionSet.actionSet[5].preHooks)
      self.assertEqual(None, actionSet.actionSet[5].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[5].function)
      self.assertEqual(350, actionSet.actionSet[6].index)
      self.assertEqual("four", actionSet.actionSet[6].name)
      self.assertEqual(None, actionSet.actionSet[6].preHooks)
      self.assertEqual(None, actionSet.actionSet[6].postHooks)
      self.assertEqual(isabs, actionSet.actionSet[6].function)
      self.assertEqual(400, actionSet.actionSet[7].index)
      self.assertEqual("purge", actionSet.actionSet[7].name)
      self.assertEqual(None, actionSet.actionSet[7].preHooks)
      self.assertEqual(None, actionSet.actionSet[7].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[7].function)
      self.assertEqual(450, actionSet.actionSet[8].index)
      self.assertEqual("five", actionSet.actionSet[8].name)
      self.assertEqual(None, actionSet.actionSet[8].preHooks)
      self.assertEqual(None, actionSet.actionSet[8].postHooks)
      self.assertEqual(exists, actionSet.actionSet[8].function)

   def testActionSet_108(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ].
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testActionSet_109(self):
      """
      Test with actions=[ collect ], extensions=[], hooks=[]
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.hooks = []
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testActionSet_110(self):
      """
      Test with actions=[ collect ], extensions=[], pre-hook on 'stage' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.hooks = [ PreActionHook("stage", "something") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testActionSet_111(self):
      """
      Test with actions=[ collect ], extensions=[], post-hook on 'stage' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("stage", "something") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testActionSet_112(self):
      """
      Test with actions=[ collect ], extensions=[], pre-hook on 'collect' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.hooks = [ PreActionHook("collect", "something") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("collect", "something"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testActionSet_113(self):
      """
      Test with actions=[ collect ], extensions=[], post-hook on 'collect' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("collect", "something") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("collect", "something"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testActionSet_114(self):
      """
      Test with actions=[ collect ], extensions=[], pre- and post-hook on 'collect' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.hooks = [ PreActionHook("collect", "something1"), PostActionHook("collect", "something2") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("collect", "something1"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("collect", "something2"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testActionSet_115(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], hooks=[]
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = []
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testActionSet_116(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], pre-hook on "store" action.
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PreActionHook("store", "whatever"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testActionSet_117(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], post-hook on "store" action.
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("store", "whatever"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testActionSet_118(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], pre-hook on "one" action.
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PreActionHook("one", "extension"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("one", "extension"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testActionSet_119(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], post-hook on "one" action.
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testActionSet_120(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], pre- and post-hook on "one" action.
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension2"), PreActionHook("one", "extension1"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("one", "extension1"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension2"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testActionSet_121(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ], hooks=[]
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = []
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_122(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ], pre-hook on "purge" action
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PreActionHook("purge", "rm -f"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_123(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ], post-hook on "purge" action
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("purge", "rm -f"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_124(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ], pre-hook on "collect" action
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PreActionHook("collect", "something"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual([ PreActionHook("collect", "something"), ], actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_125(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ], post-hook on "collect" action
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("collect", "something"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual([ PostActionHook("collect", "something"), ], actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_126(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ], pre-hook on "one" action
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PreActionHook("one", "extension"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("one", "extension"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_127(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ], post-hook on "one" action
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_128(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ], set of various pre- and post hooks.
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension"),
                        PreActionHook("collect", "something1"), PreActionHook("collect", "something2"),
                        PostActionHook("stage", "whatever1"), PostActionHook("stage", "whatever2"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual([ PreActionHook("collect", "something1"), PreActionHook("collect", "something2") ], actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testActionSet_129(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, index 50) ], set of various pre- and post hooks.
      """
      actions = [ "stage", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension"),
                        PreActionHook("collect", "something1"), PreActionHook("collect", "something2"),
                        PostActionHook("stage", "whatever1"), PostActionHook("stage", "whatever2"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual([ PostActionHook("stage", "whatever1"), PostActionHook("stage", "whatever2") ], actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)


   ############################################
   # Test constructor, "dependency" order mode
   ############################################

   def testDependencyMode_001(self):
      """
      Test with actions=None, extensions=None.
      """
      actions = None
      extensions = ExtensionsConfig(None, "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_002(self):
      """
      Test with actions=[], extensions=None.
      """
      actions = []
      extensions = ExtensionsConfig(None, "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_003(self):
      """
      Test with actions=[], extensions=[].
      """
      actions = []
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_004(self):
      """
      Test with actions=[ collect ], extensions=[].
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_005(self):
      """
      Test with actions=[ stage ], extensions=[].
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

   def testDependencyMode_006(self):
      """
      Test with actions=[ store ], extensions=[].
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)

   def testDependencyMode_007(self):
      """
      Test with actions=[ purge ], extensions=[].
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)

   def testDependencyMode_008(self):
      """
      Test with actions=[ all ], extensions=[].
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testDependencyMode_009(self):
      """
      Test with actions=[ rebuild ], extensions=[].
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("rebuild", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeRebuild, actionSet.actionSet[0].function)

   def testDependencyMode_010(self):
      """
      Test with actions=[ validate ], extensions=[].
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("validate", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeValidate, actionSet.actionSet[0].function)

   def testDependencyMode_011(self):
      """
      Test with actions=[ collect, collect ], extensions=[].
      """
      actions = [ "collect", "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_012(self):
      """
      Test with actions=[ collect, stage ], extensions=[].
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_013(self):
      """
      Test with actions=[ collect, store ], extensions=[].
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_014(self):
      """
      Test with actions=[ collect, purge ], extensions=[].
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_015(self):
      """
      Test with actions=[ collect, all ], extensions=[].
      """
      actions = [ "collect", "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_016(self):
      """
      Test with actions=[ collect, rebuild ], extensions=[].
      """
      actions = [ "collect", "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_017(self):
      """
      Test with actions=[ collect, validate ], extensions=[].
      """
      actions = [ "collect", "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_018(self):
      """
      Test with actions=[ stage, collect ], extensions=[].
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_019(self):
      """
      Test with actions=[ stage, stage ], extensions=[].
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_020(self):
      """
      Test with actions=[ stage, store ], extensions=[].
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_021(self):
      """
      Test with actions=[ stage, purge ], extensions=[].
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_022(self):
      """
      Test with actions=[ stage, all ], extensions=[].
      """
      actions = [ "stage", "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_023(self):
      """
      Test with actions=[ stage, rebuild ], extensions=[].
      """
      actions = [ "stage", "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_024(self):
      """
      Test with actions=[ stage, validate ], extensions=[].
      """
      actions = [ "stage", "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_025(self):
      """
      Test with actions=[ store, collect ], extensions=[].
      """
      actions = [ "store", "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_026(self):
      """
      Test with actions=[ store, stage ], extensions=[].
      """
      actions = [ "store", "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_027(self):
      """
      Test with actions=[ store, store ], extensions=[].
      """
      actions = [ "store", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_028(self):
      """
      Test with actions=[ store, purge ], extensions=[].
      """
      actions = [ "store", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_029(self):
      """
      Test with actions=[ store, all ], extensions=[].
      """
      actions = [ "store", "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_030(self):
      """
      Test with actions=[ store, rebuild ], extensions=[].
      """
      actions = [ "store", "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_031(self):
      """
      Test with actions=[ store, validate ], extensions=[].
      """
      actions = [ "store", "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_032(self):
      """
      Test with actions=[ purge, collect ], extensions=[].
      """
      actions = [ "purge", "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_033(self):
      """
      Test with actions=[ purge, stage ], extensions=[].
      """
      actions = [ "purge", "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_034(self):
      """
      Test with actions=[ purge, store ], extensions=[].
      """
      actions = [ "purge", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_035(self):
      """
      Test with actions=[ purge, purge ], extensions=[].
      """
      actions = [ "purge", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_036(self):
      """
      Test with actions=[ purge, all ], extensions=[].
      """
      actions = [ "purge", "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_037(self):
      """
      Test with actions=[ purge, rebuild ], extensions=[].
      """
      actions = [ "purge", "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_038(self):
      """
      Test with actions=[ purge, validate ], extensions=[].
      """
      actions = [ "purge", "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_039(self):
      """
      Test with actions=[ all, collect ], extensions=[].
      """
      actions = [ "all", "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_040(self):
      """
      Test with actions=[ all, stage ], extensions=[].
      """
      actions = [ "all", "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_041(self):
      """
      Test with actions=[ all, store ], extensions=[].
      """
      actions = [ "all", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_042(self):
      """
      Test with actions=[ all, purge ], extensions=[].
      """
      actions = [ "all", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_043(self):
      """
      Test with actions=[ all, all ], extensions=[].
      """
      actions = [ "all", "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_044(self):
      """
      Test with actions=[ all, rebuild ], extensions=[].
      """
      actions = [ "all", "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_045(self):
      """
      Test with actions=[ all, validate ], extensions=[].
      """
      actions = [ "all", "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_046(self):
      """
      Test with actions=[ rebuild, collect ], extensions=[].
      """
      actions = [ "rebuild", "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_047(self):
      """
      Test with actions=[ rebuild, stage ], extensions=[].
      """
      actions = [ "rebuild", "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_048(self):
      """
      Test with actions=[ rebuild, store ], extensions=[].
      """
      actions = [ "rebuild", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_049(self):
      """
      Test with actions=[ rebuild, purge ], extensions=[].
      """
      actions = [ "rebuild", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_050(self):
      """
      Test with actions=[ rebuild, all ], extensions=[].
      """
      actions = [ "rebuild", "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_051(self):
      """
      Test with actions=[ rebuild, rebuild ], extensions=[].
      """
      actions = [ "rebuild", "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_052(self):
      """
      Test with actions=[ rebuild, validate ], extensions=[].
      """
      actions = [ "rebuild", "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_053(self):
      """
      Test with actions=[ validate, collect ], extensions=[].
      """
      actions = [ "validate", "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_054(self):
      """
      Test with actions=[ validate, stage ], extensions=[].
      """
      actions = [ "validate", "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_055(self):
      """
      Test with actions=[ validate, store ], extensions=[].
      """
      actions = [ "validate", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_056(self):
      """
      Test with actions=[ validate, purge ], extensions=[].
      """
      actions = [ "validate", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_057(self):
      """
      Test with actions=[ validate, all ], extensions=[].
      """
      actions = [ "validate", "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_058(self):
      """
      Test with actions=[ validate, rebuild ], extensions=[].
      """
      actions = [ "validate", "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_059(self):
      """
      Test with actions=[ validate, validate ], extensions=[].
      """
      actions = [ "validate", "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_060(self):
      """
      Test with actions=[ bogus ], extensions=[].
      """
      actions = [ "bogus", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_061(self):
      """
      Test with actions=[ bogus, collect ], extensions=[].
      """
      actions = [ "bogus", "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_062(self):
      """
      Test with actions=[ bogus, stage ], extensions=[].
      """
      actions = [ "bogus", "stage", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_063(self):
      """
      Test with actions=[ bogus, store ], extensions=[].
      """
      actions = [ "bogus", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_064(self):
      """
      Test with actions=[ bogus, purge ], extensions=[].
      """
      actions = [ "bogus", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_065(self):
      """
      Test with actions=[ bogus, all ], extensions=[].
      """
      actions = [ "bogus", "all", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_066(self):
      """
      Test with actions=[ bogus, rebuild ], extensions=[].
      """
      actions = [ "bogus", "rebuild", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_067(self):
      """
      Test with actions=[ bogus, validate ], extensions=[].
      """
      actions = [ "bogus", "validate", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_068(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ].
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_069(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, before stage) ].
      """
      actions = [ "stage", "one", ]
      dependencies = ActionDependencies(["stage", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_070(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, before store) ].
      """
      actions = [ "store", "one", ]
      dependencies = ActionDependencies(["store", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_071(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, before purge) ].
      """
      actions = [ "purge", "one", ]
      dependencies = ActionDependencies(["purge", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_072(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, before collect) ].
      """
      actions = [ "all", "one", ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_073(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, before collect) ].
      """
      actions = [ "rebuild", "one", ]
      dependencies = ActionDependencies(["collect", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_074(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, before collect) ].
      """
      actions = [ "validate", "one", ]
      dependencies = ActionDependencies(["stage", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_075(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, after collect) ].
      """
      actions = [ "collect", "one", ]
      dependencies = ActionDependencies([], ["collect", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testDependencyMode_076(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, after collect) ].
      """
      actions = [ "stage", "one", ]
      dependencies = ActionDependencies(None, ["collect", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_077(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, after collect) ].
      """
      actions = [ "store", "one", ]
      dependencies = ActionDependencies([], ["collect", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_078(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, after collect) ].
      """
      actions = [ "purge", "one", ]
      dependencies = ActionDependencies(None, ["collect", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_079(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, before stage) ].
      """
      actions = [ "stage", "one", ]
      dependencies = ActionDependencies(["stage", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_080(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, before stage ) ].
      """
      actions = [ "store", "one", ]
      dependencies = ActionDependencies(["stage", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_081(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, before stage) ].
      """
      actions = [ "purge", "one", ]
      dependencies = ActionDependencies(["stage", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_082(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, after collect) ].
      """
      actions = [ "all", "one", ]
      dependencies = ActionDependencies(None, ["collect", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_083(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, after collect) ].
      """
      actions = [ "rebuild", "one", ]
      dependencies = ActionDependencies([], ["collect", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_084(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, after collect) ].
      """
      actions = [ "validate", "one", ]
      dependencies = ActionDependencies(None, ["collect", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_085(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, after stage) ].
      """
      actions = [ "collect", "one", ]
      dependencies = ActionDependencies([], ["stage", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testDependencyMode_086(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, after stage) ].
      """
      actions = [ "stage", "one", ]
      dependencies = ActionDependencies([], ["stage", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testDependencyMode_087(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, after stage) ].
      """
      actions = [ "store", "one", ]
      dependencies = ActionDependencies(None, ["stage", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_088(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, after stage) ].
      """
      actions = [ "purge", "one", ]
      dependencies = ActionDependencies([], ["stage", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_089(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before store) ].
      """
      actions = [ "collect", "one", ]
      dependencies = ActionDependencies(["store", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_090(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, before store) ].
      """
      actions = [ "stage", "one", ]
      dependencies = ActionDependencies(["store", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_091(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, before store) ].
      """
      actions = [ "store", "one", ]
      dependencies = ActionDependencies(["store", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_092(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, before store) ].
      """
      actions = [ "purge", "one", ]
      dependencies = ActionDependencies(["store", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_093(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, after stage) ].
      """
      actions = [ "all", "one", ]
      dependencies = ActionDependencies(None, ["stage", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_094(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, after stage) ].
      """
      actions = [ "rebuild", "one", ]
      dependencies = ActionDependencies([], ["stage", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_095(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, after stage) ].
      """
      actions = [ "validate", "one", ]
      dependencies = ActionDependencies(None, ["stage", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_096(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, after store) ].
      """
      actions = [ "collect", "one", ]
      dependencies = ActionDependencies(["store", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_097(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, after store) ].
      """
      actions = [ "stage", "one", ]
      dependencies = ActionDependencies(["store", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_098(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, after store) ].
      """
      actions = [ "store", "one", ]
      dependencies = ActionDependencies(["store", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testDependencyMode_099(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, after store) ].
      """
      actions = [ "purge", "one", ]
      dependencies = ActionDependencies(["store", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testDependencyMode_100(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before purge) ].
      """
      actions = [ "collect", "one", ]
      dependencies = ActionDependencies([], ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_101(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, before purge) ].
      """
      actions = [ "stage", "one", ]
      dependencies = ActionDependencies(None, ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

   def testDependencyMode_102(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, before purge) ].
      """
      actions = [ "store", "one", ]
      dependencies = ActionDependencies([], ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)

   def testDependencyMode_103(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, before purge) ].
      """
      actions = [ "purge", "one", ]
      dependencies = ActionDependencies(None, ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testDependencyMode_104(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, after store) ].
      """
      actions = [ "all", "one", ]
      dependencies = ActionDependencies(["store", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_105(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, after store) ].
      """
      actions = [ "rebuild", "one", ]
      dependencies = ActionDependencies(["store", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_106(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, after store) ].
      """
      actions = [ "validate", "one", ]
      dependencies = ActionDependencies(["store", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_107(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, after purge) ].
      """
      actions = [ "collect", "one", ]
      dependencies = ActionDependencies(None, ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_108(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, after purge) ].
      """
      actions = [ "stage", "one", ]
      dependencies = ActionDependencies([], ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

   def testDependencyMode_109(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, after purge) ].
      """
      actions = [ "store", "one", ]
      dependencies = ActionDependencies(None, ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)

   def testDependencyMode_110(self):
      """
      Test with actions=[ purge, one ], extensions=[ (one, after purge) ].
      """
      actions = [ "purge", "one", ]
      dependencies = ActionDependencies([], ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testDependencyMode_111(self):
      """
      Test with actions=[ all, one ], extensions=[ (one, after purge) ].
      """
      actions = [ "all", "one", ]
      dependencies = ActionDependencies(None, ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_112(self):
      """
      Test with actions=[ rebuild, one ], extensions=[ (one, after purge) ].
      """
      actions = [ "rebuild", "one", ]
      dependencies = ActionDependencies([], ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_113(self):
      """
      Test with actions=[ validate, one ], extensions=[ (one, after purge) ].
      """
      actions = [ "validate", "one", ]
      dependencies = ActionDependencies(None, ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_114(self):
      """
      Test with actions=[ one, one ], extensions=[ (one, after purge) ].
      """
      actions = [ "one", "one", ]
      dependencies = ActionDependencies([], ["purge", ])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testDependencyMode_115(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[].
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testDependencyMode_116(self):
      """
      Test with actions=[ stage, purge, collect, store ], extensions=[].
      """
      actions = [ "stage", "purge", "collect", "store", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testDependencyMode_117(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four, five ],
      extensions=[ one before collect, two before stage, etc. ].
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      dependencies1 = ActionDependencies(["collect", "stage", "store", "purge", ], None)
      dependencies2 = ActionDependencies(["stage", "store", "purge", ], ["collect", ])
      dependencies3 = ActionDependencies(["store", "purge", ], ["collect", "stage", ])
      dependencies4 = ActionDependencies(["purge", ], ["collect", "stage", "store", ])
      dependencies5 = ActionDependencies([], ["collect", "stage", "store", "purge", ])
      eaction1 = ExtendedAction("one", "os.path", "isdir", dependencies=dependencies1)
      eaction2 = ExtendedAction("two", "os.path", "isfile", dependencies=dependencies2)
      eaction3 = ExtendedAction("three", "os.path", "islink", dependencies=dependencies3)
      eaction4 = ExtendedAction("four", "os.path", "isabs", dependencies=dependencies4)
      eaction5 = ExtendedAction("five", "os.path", "exists", dependencies=dependencies5)
      extensions = ExtensionsConfig([ eaction1, eaction2, eaction3, eaction4, eaction5, ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 9)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)
      self.assertEqual("two", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(isfile, actionSet.actionSet[2].function)
      self.assertEqual("stage", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[3].function)
      self.assertEqual("three", actionSet.actionSet[4].name)
      self.assertEqual(None, actionSet.actionSet[4].preHooks)
      self.assertEqual(None, actionSet.actionSet[4].postHooks)
      self.assertEqual(islink, actionSet.actionSet[4].function)
      self.assertEqual("store", actionSet.actionSet[5].name)
      self.assertEqual(None, actionSet.actionSet[5].preHooks)
      self.assertEqual(None, actionSet.actionSet[5].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[5].function)
      self.assertEqual("four", actionSet.actionSet[6].name)
      self.assertEqual(None, actionSet.actionSet[6].preHooks)
      self.assertEqual(None, actionSet.actionSet[6].postHooks)
      self.assertEqual(isabs, actionSet.actionSet[6].function)
      self.assertEqual("purge", actionSet.actionSet[7].name)
      self.assertEqual(None, actionSet.actionSet[7].preHooks)
      self.assertEqual(None, actionSet.actionSet[7].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[7].function)
      self.assertEqual("five", actionSet.actionSet[8].name)
      self.assertEqual(None, actionSet.actionSet[8].preHooks)
      self.assertEqual(None, actionSet.actionSet[8].postHooks)
      self.assertEqual(exists, actionSet.actionSet[8].function)

   def testDependencyMode_118(self):
      """
      Test with actions=[ one, five, collect, store, three, stage, four, purge, two ],
      extensions=[ one before collect, two before stage, etc. ].
      """
      actions = [ "one", "five", "collect", "store", "three", "stage", "four", "purge", "two", ]
      dependencies1 = ActionDependencies(["collect", "stage", "store", "purge", ], [])
      dependencies2 = ActionDependencies(["stage", "store", "purge", ], ["collect", ])
      dependencies3 = ActionDependencies(["store", "purge", ], ["collect", "stage", ])
      dependencies4 = ActionDependencies(["purge", ], ["collect", "stage", "store", ])
      dependencies5 = ActionDependencies(None, ["collect", "stage", "store", "purge", ])
      eaction1 = ExtendedAction("one", "os.path", "isdir", dependencies=dependencies1)
      eaction2 = ExtendedAction("two", "os.path", "isfile", dependencies=dependencies2)
      eaction3 = ExtendedAction("three", "os.path", "islink", dependencies=dependencies3)
      eaction4 = ExtendedAction("four", "os.path", "isabs", dependencies=dependencies4)
      eaction5 = ExtendedAction("five", "os.path", "exists", dependencies=dependencies5)
      extensions = ExtensionsConfig([ eaction1, eaction2, eaction3, eaction4, eaction5, ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 9)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)
      self.assertEqual("two", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(isfile, actionSet.actionSet[2].function)
      self.assertEqual("stage", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[3].function)
      self.assertEqual("three", actionSet.actionSet[4].name)
      self.assertEqual(None, actionSet.actionSet[4].preHooks)
      self.assertEqual(None, actionSet.actionSet[4].postHooks)
      self.assertEqual(islink, actionSet.actionSet[4].function)
      self.assertEqual("store", actionSet.actionSet[5].name)
      self.assertEqual(None, actionSet.actionSet[5].preHooks)
      self.assertEqual(None, actionSet.actionSet[5].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[5].function)
      self.assertEqual("four", actionSet.actionSet[6].name)
      self.assertEqual(None, actionSet.actionSet[6].preHooks)
      self.assertEqual(None, actionSet.actionSet[6].postHooks)
      self.assertEqual(isabs, actionSet.actionSet[6].function)
      self.assertEqual("purge", actionSet.actionSet[7].name)
      self.assertEqual(None, actionSet.actionSet[7].preHooks)
      self.assertEqual(None, actionSet.actionSet[7].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[7].function)
      self.assertEqual("five", actionSet.actionSet[8].name)
      self.assertEqual(None, actionSet.actionSet[8].preHooks)
      self.assertEqual(None, actionSet.actionSet[8].postHooks)
      self.assertEqual(exists, actionSet.actionSet[8].function)

   def testDependencyMode_119(self):
      """
      Test with actions=[ one ], extensions=[ (one, before collect) ].
      """
      actions = [ "one", ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testDependencyMode_120(self):
      """
      Test with actions=[ collect ], extensions=[], hooks=[]
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      options.hooks = []
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_121(self):
      """
      Test with actions=[ collect ], extensions=[], pre-hook on 'stage' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      options.hooks = [ PreActionHook("stage", "something") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_122(self):
      """
      Test with actions=[ collect ], extensions=[], post-hook on 'stage' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      options.hooks = [ PostActionHook("stage", "something") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_123(self):
      """
      Test with actions=[ collect ], extensions=[], pre-hook on 'collect' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      options.hooks = [ PreActionHook("collect", "something") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("collect", "something"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_124(self):
      """
      Test with actions=[ collect ], extensions=[], post-hook on 'collect' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      options.hooks = [ PostActionHook("collect", "something") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("collect", "something"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_125(self):
      """
      Test with actions=[ collect ], extensions=[], pre- and post-hook on 'collect' action.
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], "dependency")
      options = OptionsConfig()
      options.hooks = [ PreActionHook("collect", "something1"), PostActionHook("collect", "something2") ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("collect", "something1"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("collect", "something2"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testDependencyMode_126(self):
      """
      Test with actions=[ one ], extensions=[ (one, before collect) ], hooks=[]
      """
      actions = [ "one", ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = []
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testDependencyMode_127(self):
      """
      Test with actions=[ one ], extensions=[ (one, before collect) ], pre-hook on "store" action.
      """
      actions = [ "one", ]
      dependencies = ActionDependencies(["collect", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PreActionHook("store", "whatever"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testDependencyMode_128(self):
      """
      Test with actions=[ one ], extensions=[ (one, before collect) ], post-hook on "store" action.
      """
      actions = [ "one", ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PostActionHook("store", "whatever"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testDependencyMode_129(self):
      """
      Test with actions=[ one ], extensions=[ (one, before collect) ], pre-hook on "one" action.
      """
      actions = [ "one", ]
      dependencies = ActionDependencies(["collect", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PreActionHook("one", "extension"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("one", "extension"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testDependencyMode_130(self):
      """
      Test with actions=[ one ], extensions=[ (one, before collect) ], post-hook on "one" action.
      """
      actions = [ "one", ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testDependencyMode_131(self):
      """
      Test with actions=[ one ], extensions=[ (one, before collect) ], pre- and post-hook on "one" action.
      """
      actions = [ "one", ]
      dependencies = ActionDependencies(["collect", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension2"), PreActionHook("one", "extension1"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("one", "extension1"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension2"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testDependencyMode_132(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ], hooks=[]
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = []
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_133(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ], pre-hook on "purge" action
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PreActionHook("purge", "rm -f"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_134(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ], post-hook on "purge" action
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PostActionHook("purge", "rm -f"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_135(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ], pre-hook on "collect" action
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PreActionHook("collect", "something"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual([ PreActionHook("collect", "something"), ], actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_136(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ], post-hook on "collect" action
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PostActionHook("collect", "something"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual([ PostActionHook("collect", "something"), ], actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_137(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ], pre-hook on "one" action
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PreActionHook("one", "extension"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual([ PreActionHook("one", "extension"), ], actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_138(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ], post-hook on "one" action
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], [])
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_139a(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, before collect) ], set of various pre- and post hooks.
      """
      actions = [ "collect", "one",  ]
      dependencies = ActionDependencies(["collect", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension"),
                        PreActionHook("collect", "something1"),  PreActionHook("collect", "something2"),
                        PostActionHook("stage", "whatever"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual([ PreActionHook("collect", "something1"), PreActionHook("collect", "something2"), ], actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testDependencyMode_139b(self):
      """
      Test with actions=[ stage, one ], extensions=[ (one, before stage) ], set of various pre- and post hooks.
      """
      actions = [ "stage", "one",  ]
      dependencies = ActionDependencies(["stage", ], None)
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", dependencies=dependencies), ], "dependency")
      options = OptionsConfig()
      options = OptionsConfig()
      options.hooks = [ PostActionHook("one", "extension"),
                        PreActionHook("collect", "something1"),
                        PostActionHook("stage", "whatever1"), PostActionHook("stage", "whatever2"), ]
      actionSet = _ActionSet(actions, extensions, options, None, False, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual([ PostActionHook("one", "extension"), ], actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual([ PostActionHook("stage", "whatever1"), PostActionHook("stage", "whatever2"), ], actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testDependencyMode_140(self):
      """
      Test with actions=[ one, five, collect, store, three, stage, four, purge, two ],
      extensions= [recursive loop].
      """
      actions = [ "one", "five", "collect", "store", "three", "stage", "four", "purge", "two", ]
      dependencies1 = ActionDependencies(["collect", "stage", "store", "purge", ], [])
      dependencies2 = ActionDependencies(["stage", "store", "purge", ], ["collect", ])
      dependencies3 = ActionDependencies(["store", "purge", ], ["collect", "stage", ])
      dependencies4 = ActionDependencies(["purge", ], ["collect", "stage", "store", ])
      dependencies5 = ActionDependencies(["one", ], ["collect", "stage", "store", "purge", ])
      eaction1 = ExtendedAction("one", "os.path", "isdir", dependencies=dependencies1)
      eaction2 = ExtendedAction("two", "os.path", "isfile", dependencies=dependencies2)
      eaction3 = ExtendedAction("three", "os.path", "islink", dependencies=dependencies3)
      eaction4 = ExtendedAction("four", "os.path", "isabs", dependencies=dependencies4)
      eaction5 = ExtendedAction("five", "os.path", "exists", dependencies=dependencies5)
      extensions = ExtensionsConfig([ eaction1, eaction2, eaction3, eaction4, eaction5, ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)

   def testDependencyMode_141(self):
      """
      Test with actions=[ one, five, collect, store, three, stage, four, purge, two ],
      and one extension for which a dependency does not exist.
      """
      actions = [ "one", "five", "collect", "store", "three", "stage", "four", "purge", "two", ]
      dependencies1 = ActionDependencies(["collect", "stage", "store", "purge", ], [])
      dependencies2 = ActionDependencies(["stage", "store", "purge", ], ["collect", ])
      dependencies3 = ActionDependencies(["store", "bogus", ], ["collect", "stage", ])
      dependencies4 = ActionDependencies(["purge", ], ["collect", "stage", "store", ])
      dependencies5 = ActionDependencies([], ["collect", "stage", "store", "purge", ])
      eaction1 = ExtendedAction("one", "os.path", "isdir", dependencies=dependencies1)
      eaction2 = ExtendedAction("two", "os.path", "isfile", dependencies=dependencies2)
      eaction3 = ExtendedAction("three", "os.path", "islink", dependencies=dependencies3)
      eaction4 = ExtendedAction("four", "os.path", "isabs", dependencies=dependencies4)
      eaction5 = ExtendedAction("five", "os.path", "exists", dependencies=dependencies5)
      extensions = ExtensionsConfig([ eaction1, eaction2, eaction3, eaction4, eaction5, ], "dependency")
      options = OptionsConfig()
      self.assertRaises(ValueError, _ActionSet, actions, extensions, options, None, False, True)


   #########################################
   # Test constructor, with managed peers
   #########################################

   def testManagedPeer_001(self):
      """
      Test with actions=[ collect ], extensions=[], peers=None, managed=True,
      local=True
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testManagedPeer_002(self):
      """
      Test with actions=[ stage ], extensions=[], peers=None, managed=True,
      local=True
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

   def testManagedPeer_003(self):
      """
      Test with actions=[ store ], extensions=[], peers=None, managed=True,
      local=True
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)

   def testManagedPeer_004(self):
      """
      Test with actions=[ purge ], extensions=[], peers=None, managed=True,
      local=True
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)

   def testManagedPeer_005(self):
      """
      Test with actions=[ all ], extensions=[], peers=None, managed=True,
      local=True
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testManagedPeer_006(self):
      """
      Test with actions=[ rebuild ], extensions=[], peers=None, managed=True,
      local=True
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("rebuild", actionSet.actionSet[0].name)
      self.assertEqual(executeRebuild, actionSet.actionSet[0].function)

   def testManagedPeer_007(self):
      """
      Test with actions=[ validate ], extensions=[], peers=None, managed=True,
      local=True
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("validate", actionSet.actionSet[0].name)
      self.assertEqual(executeValidate, actionSet.actionSet[0].function)

   def testManagedPeer_008(self):
      """
      Test with actions=[ collect, stage ], extensions=[], peers=None,
      managed=True, local=True
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testManagedPeer_009(self):
      """
      Test with actions=[ collect, store ], extensions=[], peers=None,
      managed=True, local=True
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_010(self):
      """
      Test with actions=[ collect, purge ], extensions=[], peers=None,
      managed=True, local=True
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testManagedPeer_011(self):
      """
      Test with actions=[ stage, collect ], extensions=[], peers=None,
      managed=True, local=True
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testManagedPeer_012(self):
      """
      Test with actions=[ stage, stage ], extensions=[], peers=None,
      managed=True, local=True
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testManagedPeer_013(self):
      """
      Test with actions=[ stage, store ], extensions=[], peers=None,
      managed=True, local=True
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_014(self):
      """
      Test with actions=[ stage, purge ], extensions=[], peers=None,
      managed=True, local=True
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testManagedPeer_015(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ],
      peers=None, managed=True, local=True
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testManagedPeer_016(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ],
      peers=None, managed=True, local=True
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_017(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ],
      peers=None, managed=True, local=True
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(150, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testManagedPeer_018(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ],
      peers=None, managed=True, local=True
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_019(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[],
      peers=None, managed=True, local=True
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testManagedPeer_020(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four,
      five ], extensions=[ (index 50, 150, 250, 350, 450)], peers=None,
      managed=True, local=True
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 9)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)
      self.assertEqual(150, actionSet.actionSet[2].index)
      self.assertEqual("two", actionSet.actionSet[2].name)
      self.assertEqual(isfile, actionSet.actionSet[2].function)
      self.assertEqual(200, actionSet.actionSet[3].index)
      self.assertEqual("stage", actionSet.actionSet[3].name)
      self.assertEqual(executeStage, actionSet.actionSet[3].function)
      self.assertEqual(250, actionSet.actionSet[4].index)
      self.assertEqual("three", actionSet.actionSet[4].name)
      self.assertEqual(islink, actionSet.actionSet[4].function)
      self.assertEqual(300, actionSet.actionSet[5].index)
      self.assertEqual("store", actionSet.actionSet[5].name)
      self.assertEqual(executeStore, actionSet.actionSet[5].function)
      self.assertEqual(350, actionSet.actionSet[6].index)
      self.assertEqual("four", actionSet.actionSet[6].name)
      self.assertEqual(isabs, actionSet.actionSet[6].function)
      self.assertEqual(400, actionSet.actionSet[7].index)
      self.assertEqual("purge", actionSet.actionSet[7].name)
      self.assertEqual(executePurge, actionSet.actionSet[7].function)
      self.assertEqual(450, actionSet.actionSet[8].index)
      self.assertEqual("five", actionSet.actionSet[8].name)
      self.assertEqual(exists, actionSet.actionSet[8].function)

   def testManagedPeer_021(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], peers=None,
      managed=True, local=True
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      actionSet = _ActionSet(actions, extensions, options, None, True, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testManagedPeer_022(self):
      """
      Test with actions=[ collect ], extensions=[], no peers, managed=True,
      local=True
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

   def testManagedPeer_023(self):
      """
      Test with actions=[ stage ], extensions=[], no peers, managed=True,
      local=True
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

   def testManagedPeer_024(self):
      """
      Test with actions=[ store ], extensions=[], no peers, managed=True,
      local=True
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)

   def testManagedPeer_025(self):
      """
      Test with actions=[ purge ], extensions=[], no peers, managed=True,
      local=True
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)

   def testManagedPeer_026(self):
      """
      Test with actions=[ all ], extensions=[], no peers, managed=True,
      local=True
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testManagedPeer_027(self):
      """
      Test with actions=[ rebuild ], extensions=[], no peers, managed=True,
      local=True
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("rebuild", actionSet.actionSet[0].name)
      self.assertEqual(executeRebuild, actionSet.actionSet[0].function)

   def testManagedPeer_028(self):
      """
      Test with actions=[ validate ], extensions=[], no peers, managed=True,
      local=True
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("validate", actionSet.actionSet[0].name)
      self.assertEqual(executeValidate, actionSet.actionSet[0].function)

   def testManagedPeer_029(self):
      """
      Test with actions=[ collect, stage ], extensions=[], no peers,
      managed=True, local=True
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testManagedPeer_030(self):
      """
      Test with actions=[ collect, store ], extensions=[], no peers,
      managed=True, local=True
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_031(self):
      """
      Test with actions=[ collect, purge ], extensions=[], no peers,
      managed=True, local=True
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testManagedPeer_032(self):
      """
      Test with actions=[ stage, collect ], extensions=[], no peers,
      managed=True, local=True
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testManagedPeer_033(self):
      """
      Test with actions=[ stage, stage ], extensions=[], no peers,
      managed=True, local=True
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testManagedPeer_034(self):
      """
      Test with actions=[ stage, store ], extensions=[], no peers,
      managed=True, local=True
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_035(self):
      """
      Test with actions=[ stage, purge ], extensions=[], no peers,
      managed=True, local=True
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)
      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

   def testManagedPeer_036(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ],
      no peers, managed=True, local=True
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)

   def testManagedPeer_037(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ],
      no peers, managed=True, local=True
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_038(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ],
      no peers, managed=True, local=True
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(150, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertEqual(isdir, actionSet.actionSet[1].function)

   def testManagedPeer_039(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ],
      no peers, managed=True, local=True
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_040(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[],
      no peers, managed=True, local=True
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 4)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)
      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)
      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)
      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertEqual(executePurge, actionSet.actionSet[3].function)

   def testManagedPeer_041(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four,
      five ], extensions=[ (index 50, 150, 250, 350, 450)], no peers,
      managed=True, local=True
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 9)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)
      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertEqual(executeCollect, actionSet.actionSet[1].function)
      self.assertEqual(150, actionSet.actionSet[2].index)
      self.assertEqual("two", actionSet.actionSet[2].name)
      self.assertEqual(isfile, actionSet.actionSet[2].function)
      self.assertEqual(200, actionSet.actionSet[3].index)
      self.assertEqual("stage", actionSet.actionSet[3].name)
      self.assertEqual(executeStage, actionSet.actionSet[3].function)
      self.assertEqual(250, actionSet.actionSet[4].index)
      self.assertEqual("three", actionSet.actionSet[4].name)
      self.assertEqual(islink, actionSet.actionSet[4].function)
      self.assertEqual(300, actionSet.actionSet[5].index)
      self.assertEqual("store", actionSet.actionSet[5].name)
      self.assertEqual(executeStore, actionSet.actionSet[5].function)
      self.assertEqual(350, actionSet.actionSet[6].index)
      self.assertEqual("four", actionSet.actionSet[6].name)
      self.assertEqual(isabs, actionSet.actionSet[6].function)
      self.assertEqual(400, actionSet.actionSet[7].index)
      self.assertEqual("purge", actionSet.actionSet[7].name)
      self.assertEqual(executePurge, actionSet.actionSet[7].function)
      self.assertEqual(450, actionSet.actionSet[8].index)
      self.assertEqual("five", actionSet.actionSet[8].name)
      self.assertEqual(exists, actionSet.actionSet[8].function)

   def testManagedPeer_042(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], no peers,
      managed=True, local=True
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

   def testManagedPeer_043(self):
      """
      Test with actions=[ collect ], extensions=[], no peers, managed=True,
      local=False
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_044(self):
      """
      Test with actions=[ stage ], extensions=[], no peers, managed=True,
      local=False
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_045(self):
      """
      Test with actions=[ store ], extensions=[], no peers, managed=True,
      local=False
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_046(self):
      """
      Test with actions=[ purge ], extensions=[], no peers, managed=True,
      local=False
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_047(self):
      """
      Test with actions=[ all ], extensions=[], no peers, managed=True,
      local=False
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_048(self):
      """
      Test with actions=[ rebuild ], extensions=[], no peers, managed=True,
      local=False
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_049(self):
      """
      Test with actions=[ validate ], extensions=[], no peers, managed=True,
      local=False
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_050(self):
      """
      Test with actions=[ collect, stage ], extensions=[], no peers,
      managed=True, local=False
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_051(self):
      """
      Test with actions=[ collect, store ], extensions=[], no peers,
      managed=True, local=False
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_052(self):
      """
      Test with actions=[ collect, purge ], extensions=[], no peers,
      managed=True, local=False
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_053(self):
      """
      Test with actions=[ stage, collect ], extensions=[], no peers,
      managed=True, local=False
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_054(self):
      """
      Test with actions=[ stage, stage ], extensions=[], no peers,
      managed=True, local=False
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_055(self):
      """
      Test with actions=[ stage, store ], extensions=[], no peers,
      managed=True, local=False
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_056(self):
      """
      Test with actions=[ stage, purge ], extensions=[], no peers,
      managed=True, local=False
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_057(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ],
      no peers, managed=True, local=False
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_058(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ],
      no peers, managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_059(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ],
      no peers, managed=True, local=False
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_060(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ],
      no peers, managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_061(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[],
      no peers, managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_062(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four,
      five ], extensions=[ (index 50, 150, 250, 350, 450)], no peers,
      managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_063(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], no peers,
      managed=True, local=False
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_064(self):
      """
      Test with actions=[ collect ], extensions=[], one peer (not managed), managed=True,
      local=False
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_065(self):
      """
      Test with actions=[ stage ], extensions=[], one peer (not managed), managed=True,
      local=False
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_066(self):
      """
      Test with actions=[ store ], extensions=[], one peer (not managed), managed=True,
      local=False
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_067(self):
      """
      Test with actions=[ purge ], extensions=[], one peer (not managed), managed=True,
      local=False
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_068(self):
      """
      Test with actions=[ all ], extensions=[], one peer (not managed), managed=True,
      local=False
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_069(self):
      """
      Test with actions=[ rebuild ], extensions=[], one peer (not managed), managed=True,
      local=False
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_070(self):
      """
      Test with actions=[ validate ], extensions=[], one peer (not managed), managed=True,
      local=False
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_071(self):
      """
      Test with actions=[ collect, stage ], extensions=[], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_072(self):
      """
      Test with actions=[ collect, store ], extensions=[], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_073(self):
      """
      Test with actions=[ collect, purge ], extensions=[], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_074(self):
      """
      Test with actions=[ stage, collect ], extensions=[], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_075(self):
      """
      Test with actions=[ stage, stage ], extensions=[], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_076(self):
      """
      Test with actions=[ stage, store ], extensions=[], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_077(self):
      """
      Test with actions=[ stage, purge ], extensions=[], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_078(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ],
      one peer (not managed), managed=True, local=False
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_079(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ],
      one peer (not managed), managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_080(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ],
      one peer (not managed), managed=True, local=False
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_081(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ],
      one peer (not managed), managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_082(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[],
      one peer (not managed), managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_083(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four,
      five ], extensions=[ (index 50, 150, 250, 350, 450)], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_084(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], one peer (not managed),
      managed=True, local=False
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_085(self):
      """
      Test with actions=[ collect ], extensions=[], one peer (managed), managed=True,
      local=False
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", None, "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_086(self):
      """
      Test with actions=[ stage ], extensions=[], one peer (managed), managed=True,
      local=False
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_087(self):
      """
      Test with actions=[ store ], extensions=[], one peer (managed), managed=True,
      local=False
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_088(self):
      """
      Test with actions=[ purge ], extensions=[], one peer (managed), managed=True,
      local=False
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_089(self):
      """
      Test with actions=[ all ], extensions=[], one peer (managed), managed=True,
      local=False
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

   def testManagedPeer_090(self):
      """
      Test with actions=[ rebuild ], extensions=[], one peer (managed), managed=True,
      local=False
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_091(self):
      """
      Test with actions=[ validate ], extensions=[], one peer (managed), managed=True,
      local=False
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_092(self):
      """
      Test with actions=[ collect, stage ], extensions=[], one peer (managed),
      managed=True, local=False
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)

      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_093(self):
      """
      Test with actions=[ collect, store ], extensions=[], one peer (managed),
      managed=True, local=False
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)

      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_094(self):
      """
      Test with actions=[ collect, purge ], extensions=[], one peer (managed),
      managed=True, local=False
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

   def testManagedPeer_095(self):
      """
      Test with actions=[ stage, collect ], extensions=[], one peer (managed),
      managed=True, local=False
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_096(self):
      """
      Test with actions=[ stage, stage ], extensions=[], one peer (managed),
      managed=True, local=False
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_097(self):
      """
      Test with actions=[ stage, store ], extensions=[], one peer (managed),
      managed=True, local=False
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_098(self):
      """
      Test with actions=[ stage, purge ], extensions=[], one peer (managed),
      managed=True, local=False
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_099(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ],
      one peer (managed), managed=True, local=False
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_100(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ],
      one peer (managed), managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_101(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ],
      one peer (managed), managed=True, local=False
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(150, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

   def testManagedPeer_102(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ],
      one peer (managed), managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_103(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[],
      one peer (managed), managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

   def testManagedPeer_104(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four,
      five ], extensions=[ (index 50, 150, 250, 350, 450)], one peer (managed),
      managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[2].index)
      self.assertEqual("purge", actionSet.actionSet[2].name)
      self.assertFalse(actionSet.actionSet[2].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[2].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[2].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[2].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[2].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[2].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[2].remotePeers[0].cbackCommand)

   def testManagedPeer_105(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], one peer (managed),
      managed=True, local=False
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_106(self):
      """
      Test with actions=[ collect ], extensions=[], two peers (one managed, one not), managed=True,
      local=False
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", None, "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_107(self):
      """
      Test with actions=[ stage ], extensions=[], two peers (one managed, one not), managed=True,
      local=False
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_108(self):
      """
      Test with actions=[ store ], extensions=[], two peers (one managed, one not), managed=True,
      local=False
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_109(self):
      """
      Test with actions=[ purge ], extensions=[], two peers (one managed, one not), managed=True,
      local=False
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_110(self):
      """
      Test with actions=[ all ], extensions=[], two peers (one managed, one not), managed=True,
      local=False
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

   def testManagedPeer_111(self):
      """
      Test with actions=[ rebuild ], extensions=[], two peers (one managed, one not), managed=True,
      local=False
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_112(self):
      """
      Test with actions=[ validate ], extensions=[], two peers (one managed, one not), managed=True,
      local=False
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_113(self):
      """
      Test with actions=[ collect, stage ], extensions=[], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_114(self):
      """
      Test with actions=[ collect, store ], extensions=[], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_115(self):
      """
      Test with actions=[ collect, purge ], extensions=[], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

   def testManagedPeer_116(self):
      """
      Test with actions=[ stage, collect ], extensions=[], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_117(self):
      """
      Test with actions=[ stage, stage ], extensions=[], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_118(self):
      """
      Test with actions=[ stage, store ], extensions=[], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_119(self):
      """
      Test with actions=[ stage, purge ], extensions=[], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_120(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ],
      two peers (one managed, one not), managed=True, local=False
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_121(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ],
      two peers (one managed, one not), managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_122(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ],
      two peers (one managed, one not), managed=True, local=False
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(150, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

   def testManagedPeer_123(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ],
      two peers (one managed, one not), managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_124(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[],
      two peers (one managed, one not), managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

   def testManagedPeer_125(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four,
      five ], extensions=[ (index 50, 150, 250, 350, 450)], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[2].index)
      self.assertEqual("purge", actionSet.actionSet[2].name)
      self.assertFalse(actionSet.actionSet[2].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[2].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[2].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[2].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[2].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[2].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[2].remotePeers[0].cbackCommand)

   def testManagedPeer_126(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], two peers (one managed, one not),
      managed=True, local=False
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=False), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)

   def testManagedPeer_127(self):
      """
      Test with actions=[ collect ], extensions=[], two peers (both managed), managed=True,
      local=False
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", None, "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_128(self):
      """
      Test with actions=[ stage ], extensions=[], two peers (both managed), managed=True,
      local=False
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_129(self):
      """
      Test with actions=[ store ], extensions=[], two peers (both managed), managed=True,
      local=False
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_130(self):
      """
      Test with actions=[ purge ], extensions=[], two peers (both managed), managed=True,
      local=False
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_131(self):
      """
      Test with actions=[ all ], extensions=[], two peers (both managed), managed=True,
      local=False
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 2)
      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

   def testManagedPeer_132(self):
      """
      Test with actions=[ rebuild ], extensions=[], two peers (both managed), managed=True,
      local=False
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_133(self):
      """
      Test with actions=[ validate ], extensions=[], two peers (both managed), managed=True,
      local=False
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_134(self):
      """
      Test with actions=[ collect, stage ], extensions=[], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_135(self):
      """
      Test with actions=[ collect, store ], extensions=[], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_136(self):
      """
      Test with actions=[ collect, purge ], extensions=[], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

   def testManagedPeer_137(self):
      """
      Test with actions=[ stage, collect ], extensions=[], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_138(self):
      """
      Test with actions=[ stage, stage ], extensions=[], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_139(self):
      """
      Test with actions=[ stage, store ], extensions=[], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 0)

   def testManagedPeer_140(self):
      """
      Test with actions=[ stage, purge ], extensions=[], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_141(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ],
      two peers (both managed), managed=True, local=False
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

   def testManagedPeer_142(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ],
      two peers (both managed), managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_143(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ],
      two peers (both managed), managed=True, local=False
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

      self.assertEqual(150, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

   def testManagedPeer_144(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ],
      two peers (both managed), managed=True, local=False
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_145(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[],
      two peers (both managed), managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

   def testManagedPeer_146(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four,
      five ], extensions=[ (index 50, 150, 250, 350, 450)], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", "three", "four", "five", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[2].index)
      self.assertEqual("purge", actionSet.actionSet[2].name)
      self.assertFalse(actionSet.actionSet[2].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[2].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[2].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[2].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[2].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[2].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[2].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[2].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[2].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[2].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[2].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[2].remotePeers[1].cbackCommand)

   def testManagedPeer_147(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], two peers (both managed),
      managed=True, local=False
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, False)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertFalse(actionSet.actionSet[0].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[0].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[0].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[0].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[0].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[0].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[0].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[0].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[0].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[0].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[0].remotePeers[1].cbackCommand)

   def testManagedPeer_148(self):
      """
      Test with actions=[ collect ], extensions=[], two peers (both managed), managed=True,
      local=True
      """
      actions = [ "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", None, "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

   def testManagedPeer_149(self):
      """
      Test with actions=[ stage ], extensions=[], two peers (both managed), managed=True,
      local=True
      """
      actions = [ "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

   def testManagedPeer_150(self):
      """
      Test with actions=[ store ], extensions=[], two peers (both managed), managed=True,
      local=True
      """
      actions = [ "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(300, actionSet.actionSet[0].index)
      self.assertEqual("store", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[0].function)

   def testManagedPeer_151(self):
      """
      Test with actions=[ purge ], extensions=[], two peers (both managed), managed=True,
      local=True
      """
      actions = [ "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(400, actionSet.actionSet[0].index)
      self.assertEqual("purge", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[0].function)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

   def testManagedPeer_152(self):
      """
      Test with actions=[ all ], extensions=[], two peers (both managed), managed=True,
      local=True
      """
      actions = [ "all", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertFalse(actionSet.actionSet is None)
      self.assertTrue(len(actionSet.actionSet) == 6)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(200, actionSet.actionSet[2].index)
      self.assertEqual("stage", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[2].function)

      self.assertEqual(300, actionSet.actionSet[3].index)
      self.assertEqual("store", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[3].function)

      self.assertEqual(400, actionSet.actionSet[4].index)
      self.assertEqual("purge", actionSet.actionSet[4].name)
      self.assertEqual(None, actionSet.actionSet[4].preHooks)
      self.assertEqual(None, actionSet.actionSet[4].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[4].function)

      self.assertEqual(400, actionSet.actionSet[5].index)
      self.assertEqual("purge", actionSet.actionSet[5].name)
      self.assertFalse(actionSet.actionSet[5].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[5].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[5].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[5].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[5].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[5].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[5].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[5].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[5].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[5].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[5].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[5].remotePeers[1].cbackCommand)

   def testManagedPeer_153(self):
      """
      Test with actions=[ rebuild ], extensions=[], two peers (both managed), managed=True,
      local=True
      """
      actions = [ "rebuild", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("rebuild", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeRebuild, actionSet.actionSet[0].function)

   def testManagedPeer_154(self):
      """
      Test with actions=[ validate ], extensions=[], two peers (both managed), managed=True,
      local=True
      """
      actions = [ "validate", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 1)

      self.assertEqual(0, actionSet.actionSet[0].index)
      self.assertEqual("validate", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeValidate, actionSet.actionSet[0].function)

   def testManagedPeer_155(self):
      """
      Test with actions=[ collect, stage ], extensions=[], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "collect", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(200, actionSet.actionSet[2].index)
      self.assertEqual("stage", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[2].function)

   def testManagedPeer_156(self):
      """
      Test with actions=[ collect, store ], extensions=[], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "collect", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)

   def testManagedPeer_157(self):
      """
      Test with actions=[ collect, purge ], extensions=[], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "collect", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 4)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(400, actionSet.actionSet[2].index)
      self.assertEqual("purge", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[2].function)

      self.assertEqual(400, actionSet.actionSet[3].index)
      self.assertEqual("purge", actionSet.actionSet[3].name)
      self.assertFalse(actionSet.actionSet[3].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[3].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[3].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[3].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[3].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[3].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[3].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[3].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[3].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[3].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[3].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[3].remotePeers[1].cbackCommand)

   def testManagedPeer_158(self):
      """
      Test with actions=[ stage, collect ], extensions=[], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "stage", "collect", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(200, actionSet.actionSet[2].index)
      self.assertEqual("stage", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[2].function)

   def testManagedPeer_159(self):
      """
      Test with actions=[ stage, stage ], extensions=[], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "stage", "stage", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

      self.assertEqual(200, actionSet.actionSet[1].index)
      self.assertEqual("stage", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[1].function)

   def testManagedPeer_160(self):
      """
      Test with actions=[ stage, store ], extensions=[], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "stage", "store", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

      self.assertEqual(300, actionSet.actionSet[1].index)
      self.assertEqual("store", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[1].function)

   def testManagedPeer_161(self):
      """
      Test with actions=[ stage, purge ], extensions=[], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "stage", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(200, actionSet.actionSet[0].index)
      self.assertEqual("stage", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[0].function)

      self.assertEqual(400, actionSet.actionSet[1].index)
      self.assertEqual("purge", actionSet.actionSet[1].name)
      self.assertEqual(None, actionSet.actionSet[1].preHooks)
      self.assertEqual(None, actionSet.actionSet[1].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[1].function)

      self.assertEqual(400, actionSet.actionSet[2].index)
      self.assertEqual("purge", actionSet.actionSet[2].name)
      self.assertFalse(actionSet.actionSet[2].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[2].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[2].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[2].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[2].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[2].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[2].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[2].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[2].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[2].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[2].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[2].remotePeers[1].cbackCommand)

   def testManagedPeer_162(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 50) ],
      two peers (both managed), managed=True, local=True
      """
      actions = [ "collect", "one",  ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 4)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

      self.assertEqual(50, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[2].index)
      self.assertEqual("collect", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[2].function)

      self.assertEqual(100, actionSet.actionSet[3].index)
      self.assertEqual("collect", actionSet.actionSet[3].name)
      self.assertFalse(actionSet.actionSet[3].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[3].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[3].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[3].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[3].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[3].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[3].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[3].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[3].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[3].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[3].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[3].remotePeers[1].cbackCommand)

   def testManagedPeer_163(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 50) ],
      two peers (both managed), managed=True, local=True
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

      self.assertEqual(50, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)

   def testManagedPeer_164(self):
      """
      Test with actions=[ collect, one ], extensions=[ (one, index 150) ],
      two peers (both managed), managed=True, local=True
      """
      actions = [ "collect", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 4)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(150, actionSet.actionSet[2].index)
      self.assertEqual("one", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[2].function)

      self.assertEqual(150, actionSet.actionSet[3].index)
      self.assertEqual("one", actionSet.actionSet[3].name)
      self.assertFalse(actionSet.actionSet[3].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[3].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[3].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[3].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[3].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[3].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[3].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[3].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[3].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[3].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[3].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[3].remotePeers[1].cbackCommand)

   def testManagedPeer_165(self):
      """
      Test with actions=[ store, one ], extensions=[ (one, index 150) ],
      two peers (both managed), managed=True, local=True
      """
      actions = [ "store", "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 150), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 3)

      self.assertEqual(150, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

      self.assertEqual(150, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(300, actionSet.actionSet[2].index)
      self.assertEqual("store", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[2].function)

   def testManagedPeer_166(self):
      """
      Test with actions=[ collect, stage, store, purge ], extensions=[],
      two peers (both managed), managed=True, local=True
      """
      actions = [ "collect", "stage", "store", "purge", ]
      extensions = ExtensionsConfig([], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 6)

      self.assertEqual(100, actionSet.actionSet[0].index)
      self.assertEqual("collect", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[0].function)

      self.assertEqual(100, actionSet.actionSet[1].index)
      self.assertEqual("collect", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(200, actionSet.actionSet[2].index)
      self.assertEqual("stage", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[2].function)

      self.assertEqual(300, actionSet.actionSet[3].index)
      self.assertEqual("store", actionSet.actionSet[3].name)
      self.assertEqual(None, actionSet.actionSet[3].preHooks)
      self.assertEqual(None, actionSet.actionSet[3].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[3].function)

      self.assertEqual(400, actionSet.actionSet[4].index)
      self.assertEqual("purge", actionSet.actionSet[4].name)
      self.assertEqual(None, actionSet.actionSet[4].preHooks)
      self.assertEqual(None, actionSet.actionSet[4].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[4].function)

      self.assertEqual(400, actionSet.actionSet[5].index)
      self.assertEqual("purge", actionSet.actionSet[5].name)
      self.assertFalse(actionSet.actionSet[5].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[5].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[5].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[5].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[5].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[5].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[5].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[5].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[5].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[5].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[5].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[5].remotePeers[1].cbackCommand)

   def testManagedPeer_167(self):
      """
      Test with actions=[ collect, stage, store, purge, one, two, three, four,
      five ], extensions=[ (index 50, 150, 250, 350, 450)], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 9)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[2].index)
      self.assertEqual("collect", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[2].function)

      self.assertEqual(100, actionSet.actionSet[3].index)
      self.assertEqual("collect", actionSet.actionSet[3].name)
      self.assertFalse(actionSet.actionSet[3].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[3].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[3].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[3].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[3].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[3].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[3].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[3].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[3].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[3].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[3].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[3].remotePeers[1].cbackCommand)

      self.assertEqual(150, actionSet.actionSet[4].index)
      self.assertEqual("two", actionSet.actionSet[4].name)
      self.assertEqual(None, actionSet.actionSet[4].preHooks)
      self.assertEqual(None, actionSet.actionSet[4].postHooks)
      self.assertEqual(isfile, actionSet.actionSet[4].function)

      self.assertEqual(200, actionSet.actionSet[5].index)
      self.assertEqual("stage", actionSet.actionSet[5].name)
      self.assertEqual(None, actionSet.actionSet[5].preHooks)
      self.assertEqual(None, actionSet.actionSet[5].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[5].function)

      self.assertEqual(300, actionSet.actionSet[6].index)
      self.assertEqual("store", actionSet.actionSet[6].name)
      self.assertEqual(None, actionSet.actionSet[6].preHooks)
      self.assertEqual(None, actionSet.actionSet[6].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[6].function)

      self.assertEqual(400, actionSet.actionSet[7].index)
      self.assertEqual("purge", actionSet.actionSet[7].name)
      self.assertEqual(None, actionSet.actionSet[7].preHooks)
      self.assertEqual(None, actionSet.actionSet[7].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[7].function)

      self.assertEqual(400, actionSet.actionSet[8].index)
      self.assertEqual("purge", actionSet.actionSet[8].name)
      self.assertFalse(actionSet.actionSet[8].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[8].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[8].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[8].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[8].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[8].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[8].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[8].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[8].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[8].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[8].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[8].remotePeers[1].cbackCommand)

   def testManagedPeer_168(self):
      """
      Test with actions=[ one ], extensions=[ (one, index 50) ], two peers (both managed),
      managed=True, local=True
      """
      actions = [ "one", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, "ruser", "rcp", "rsh", "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", "rcp2", "rsh2", "cback2", managed=True), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 2)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

      self.assertEqual(50, actionSet.actionSet[1].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 2)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("ruser", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rsh", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)
      self.assertEqual("remote2", actionSet.actionSet[1].remotePeers[1].name)
      self.assertEqual("ruser2", actionSet.actionSet[1].remotePeers[1].remoteUser)
      self.assertEqual(None, actionSet.actionSet[1].remotePeers[1].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[1].remotePeers[1].rshCommand)
      self.assertEqual("cback2", actionSet.actionSet[1].remotePeers[1].cbackCommand)

   def testManagedPeer_169(self):
      """
      Test to make sure that various options all seem to be pulled from the right places with mixed data.
      """
      actions = [ "collect", "stage", "store", "purge", "one", "two", ]
      extensions = ExtensionsConfig([ ExtendedAction("one", "os.path", "isdir", 50),
                                      ExtendedAction("two", "os.path", "isfile", 150),
                                      ExtendedAction("three", "os.path", "islink", 250),
                                      ExtendedAction("four", "os.path", "isabs", 350),
                                      ExtendedAction("five", "os.path", "exists", 450), ], None)
      options = OptionsConfig()
      options.managedActions = [ "collect", "purge", "one", ]
      options.backupUser = "userZ"
      options.rshCommand = "rshZ"
      options.cbackCommand = "cbackZ"
      peers = PeersConfig()
      peers.localPeers = [ LocalPeer("local", "/collect"), ]
      peers.remotePeers = [ RemotePeer("remote", None, None, None, None, "cback", managed=True),
                            RemotePeer("remote2", None, "ruser2", None, "rsh2", None, managed=True, managedActions=[ "stage", ]), ]
      actionSet = _ActionSet(actions, extensions, options, peers, True, True)
      self.assertTrue(len(actionSet.actionSet) == 10)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[0].name)
      self.assertEqual(None, actionSet.actionSet[0].preHooks)
      self.assertEqual(None, actionSet.actionSet[0].postHooks)
      self.assertEqual(isdir, actionSet.actionSet[0].function)

      self.assertEqual(50, actionSet.actionSet[0].index)
      self.assertEqual("one", actionSet.actionSet[1].name)
      self.assertFalse(actionSet.actionSet[1].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[1].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[1].remotePeers[0].name)
      self.assertEqual("userZ", actionSet.actionSet[1].remotePeers[0].remoteUser)
      self.assertEqual("userZ", actionSet.actionSet[1].remotePeers[0].localUser)
      self.assertEqual("rshZ", actionSet.actionSet[1].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[1].remotePeers[0].cbackCommand)

      self.assertEqual(100, actionSet.actionSet[2].index)
      self.assertEqual("collect", actionSet.actionSet[2].name)
      self.assertEqual(None, actionSet.actionSet[2].preHooks)
      self.assertEqual(None, actionSet.actionSet[2].postHooks)
      self.assertEqual(executeCollect, actionSet.actionSet[2].function)

      self.assertEqual(100, actionSet.actionSet[3].index)
      self.assertEqual("collect", actionSet.actionSet[3].name)
      self.assertFalse(actionSet.actionSet[3].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[3].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[3].remotePeers[0].name)
      self.assertEqual("userZ", actionSet.actionSet[3].remotePeers[0].remoteUser)
      self.assertEqual("userZ", actionSet.actionSet[3].remotePeers[0].localUser)
      self.assertEqual("rshZ", actionSet.actionSet[3].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[3].remotePeers[0].cbackCommand)

      self.assertEqual(150, actionSet.actionSet[4].index)
      self.assertEqual("two", actionSet.actionSet[4].name)
      self.assertEqual(None, actionSet.actionSet[4].preHooks)
      self.assertEqual(None, actionSet.actionSet[4].postHooks)
      self.assertEqual(isfile, actionSet.actionSet[4].function)

      self.assertEqual(200, actionSet.actionSet[5].index)
      self.assertEqual("stage", actionSet.actionSet[5].name)
      self.assertEqual(None, actionSet.actionSet[5].preHooks)
      self.assertEqual(None, actionSet.actionSet[5].postHooks)
      self.assertEqual(executeStage, actionSet.actionSet[5].function)

      self.assertEqual(200, actionSet.actionSet[6].index)
      self.assertEqual("stage", actionSet.actionSet[6].name)
      self.assertFalse(actionSet.actionSet[6].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[6].remotePeers) == 1)
      self.assertEqual("remote2", actionSet.actionSet[6].remotePeers[0].name)
      self.assertEqual("ruser2", actionSet.actionSet[6].remotePeers[0].remoteUser)
      self.assertEqual("userZ", actionSet.actionSet[6].remotePeers[0].localUser)
      self.assertEqual("rsh2", actionSet.actionSet[6].remotePeers[0].rshCommand)
      self.assertEqual("cbackZ", actionSet.actionSet[6].remotePeers[0].cbackCommand)

      self.assertEqual(300, actionSet.actionSet[7].index)
      self.assertEqual("store", actionSet.actionSet[7].name)
      self.assertEqual(None, actionSet.actionSet[7].preHooks)
      self.assertEqual(None, actionSet.actionSet[7].postHooks)
      self.assertEqual(executeStore, actionSet.actionSet[7].function)

      self.assertEqual(400, actionSet.actionSet[8].index)
      self.assertEqual("purge", actionSet.actionSet[8].name)
      self.assertEqual(None, actionSet.actionSet[8].preHooks)
      self.assertEqual(None, actionSet.actionSet[8].postHooks)
      self.assertEqual(executePurge, actionSet.actionSet[8].function)

      self.assertEqual(400, actionSet.actionSet[9].index)
      self.assertEqual("purge", actionSet.actionSet[9].name)
      self.assertFalse(actionSet.actionSet[9].remotePeers is None)
      self.assertTrue(len(actionSet.actionSet[9].remotePeers) == 1)
      self.assertEqual("remote", actionSet.actionSet[9].remotePeers[0].name)
      self.assertEqual("userZ", actionSet.actionSet[9].remotePeers[0].remoteUser)
      self.assertEqual("userZ", actionSet.actionSet[9].remotePeers[0].localUser)
      self.assertEqual("rshZ", actionSet.actionSet[9].remotePeers[0].rshCommand)
      self.assertEqual("cback", actionSet.actionSet[9].remotePeers[0].cbackCommand)


#######################################################################
# Suite definition
#######################################################################

def suite():
   """Returns a suite containing all the test cases in this module."""
   tests = [ ]
   tests.append(unittest.makeSuite(TestFunctions, 'test'))
   tests.append(unittest.makeSuite(TestOptions, 'test'))
   tests.append(unittest.makeSuite(TestActionSet, 'test'))
   return unittest.TestSuite(tests)

