diff --git a/TestON/lib/configobj-4.7.2/._configobj.py b/TestON/lib/configobj-4.7.2/._configobj.py
index a276d79..07fbd90 100644
--- a/TestON/lib/configobj-4.7.2/._configobj.py
+++ b/TestON/lib/configobj-4.7.2/._configobj.py
Binary files differ
diff --git a/TestON/lib/configobj-4.7.2/._setup.py b/TestON/lib/configobj-4.7.2/._setup.py
index 7fb7ea2..2ec4b3d 100644
--- a/TestON/lib/configobj-4.7.2/._setup.py
+++ b/TestON/lib/configobj-4.7.2/._setup.py
Binary files differ
diff --git a/TestON/lib/configobj-4.7.2/._validate.py b/TestON/lib/configobj-4.7.2/._validate.py
index a217e20..286fe7c 100644
--- a/TestON/lib/configobj-4.7.2/._validate.py
+++ b/TestON/lib/configobj-4.7.2/._validate.py
Binary files differ
diff --git a/TestON/lib/configobj-4.7.2/configobj.py b/TestON/lib/configobj-4.7.2/configobj.py
index c1f6e6d..eae556a 100644
--- a/TestON/lib/configobj-4.7.2/configobj.py
+++ b/TestON/lib/configobj-4.7.2/configobj.py
@@ -153,29 +153,29 @@
 
 
 class Builder(object):
-    
+
     def build(self, o):
         m = getattr(self, 'build_' + o.__class__.__name__, None)
         if m is None:
             raise UnknownType(o.__class__.__name__)
         return m(o)
-    
+
     def build_List(self, o):
         return map(self.build, o.getChildren())
-    
+
     def build_Const(self, o):
         return o.value
-    
+
     def build_Dict(self, o):
         d = {}
         i = iter(map(self.build, o.getChildren()))
         for el in i:
             d[el] = i.next()
         return d
-    
+
     def build_Tuple(self, o):
         return tuple(self.build_List(o))
-    
+
     def build_Name(self, o):
         if o.name == 'None':
             return None
@@ -183,10 +183,10 @@
             return True
         if o.name == 'False':
             return False
-        
+
         # An undefined Name
         raise UnknownType('Undefined Name')
-    
+
     def build_Add(self, o):
         real, imag = map(self.build_Const, o.getChildren())
         try:
@@ -196,14 +196,14 @@
         if not isinstance(imag, complex) or imag.real != 0.0:
             raise UnknownType('Add')
         return real+imag
-    
+
     def build_Getattr(self, o):
         parent = self.build(o.expr)
         return getattr(parent, o.attrname)
-    
+
     def build_UnarySub(self, o):
         return -self.build_Const(o.getChildren()[0])
-    
+
     def build_UnaryAdd(self, o):
         return self.build_Const(o.getChildren()[0])
 
@@ -317,7 +317,7 @@
         # short-cut
         if not self._cookie in value:
             return value
-        
+
         def recursive_interpolate(key, value, section, backtrail):
             """The function that does the actual work.
 
@@ -417,7 +417,7 @@
         (e.g., if we interpolated "$$" and returned "$").
         """
         raise NotImplementedError()
-    
+
 
 
 class ConfigParserInterpolation(InterpolationEngine):
@@ -466,27 +466,27 @@
 
 def __newobj__(cls, *args):
     # Hack for pickle
-    return cls.__new__(cls, *args) 
+    return cls.__new__(cls, *args)
 
 class Section(dict):
     """
     A dictionary-like object that represents a section in a config file.
-    
+
     It does string interpolation if the 'interpolation' attribute
     of the 'main' object is set to True.
-    
+
     Interpolation is tried first from this object, then from the 'DEFAULT'
     section of this object, next from the parent and its 'DEFAULT' section,
     and so on until the main object is reached.
-    
+
     A Section will behave like an ordered dictionary - following the
     order of the ``scalars`` and ``sections`` attributes.
     You can use this to change the order of members.
-    
+
     Iteration follows the order: scalars, then sections.
     """
 
-    
+
     def __setstate__(self, state):
         dict.update(self, state[0])
         self.__dict__.update(state[1])
@@ -494,8 +494,8 @@
     def __reduce__(self):
         state = (dict(self), self.__dict__)
         return (__newobj__, (self.__class__,), state)
-    
-    
+
+
     def __init__(self, parent, depth, main, indict=None, name=None):
         """
         * parent is the section above
@@ -520,8 +520,8 @@
         # (rather than just passing to ``dict.__init__``)
         for entry, value in indict.iteritems():
             self[entry] = value
-            
-            
+
+
     def _initialise(self):
         # the sequence of scalar values in this Section
         self.scalars = []
@@ -565,7 +565,7 @@
     def __getitem__(self, key):
         """Fetch the item and do string interpolation."""
         val = dict.__getitem__(self, key)
-        if self.main.interpolation: 
+        if self.main.interpolation:
             if isinstance(val, basestring):
                 return self._interpolate(key, val)
             if isinstance(val, list):
@@ -582,20 +582,20 @@
     def __setitem__(self, key, value, unrepr=False):
         """
         Correctly set a value.
-        
+
         Making dictionary values Section instances.
         (We have to special case 'Section' instances - which are also dicts)
-        
+
         Keys must be strings.
         Values need only be strings (or lists of strings) if
         ``main.stringify`` is set.
-        
+
         ``unrepr`` must be set when setting a value to a dictionary, without
         creating a new sub-section.
         """
         if not isinstance(key, basestring):
             raise ValueError('The key "%s" is not a string.' % key)
-        
+
         # add the comment
         if key not in self.comments:
             self.comments[key] = []
@@ -696,7 +696,7 @@
         """
         A version of clear that also affects scalars/sections
         Also clears comments and configspec.
-        
+
         Leaves other attributes alone :
             depth/main/parent are not affected
         """
@@ -770,10 +770,10 @@
     def dict(self):
         """
         Return a deepcopy of self as a dictionary.
-        
+
         All members that are ``Section`` instances are recursively turned to
         ordinary dictionaries - by calling their ``dict`` method.
-        
+
         >>> n = a.dict()
         >>> n == a
         1
@@ -798,7 +798,7 @@
     def merge(self, indict):
         """
         A recursive update - useful for merging config files.
-        
+
         >>> a = '''[section1]
         ...     option1 = True
         ...     [[subsection]]
@@ -818,17 +818,17 @@
             if (key in self and isinstance(self[key], dict) and
                                 isinstance(val, dict)):
                 self[key].merge(val)
-            else:   
+            else:
                 self[key] = val
 
 
     def rename(self, oldkey, newkey):
         """
         Change a keyname to another, without changing position in sequence.
-        
+
         Implemented so that transformations can be made on keys,
         as well as on values. (used by encode and decode)
-        
+
         Also renames comments.
         """
         if oldkey in self.scalars:
@@ -856,30 +856,30 @@
             call_on_sections=False, **keywargs):
         """
         Walk every member and call a function on the keyword and value.
-        
+
         Return a dictionary of the return values
-        
+
         If the function raises an exception, raise the errror
         unless ``raise_errors=False``, in which case set the return value to
         ``False``.
-        
+
         Any unrecognised keyword arguments you pass to walk, will be pased on
         to the function you pass in.
-        
+
         Note: if ``call_on_sections`` is ``True`` then - on encountering a
         subsection, *first* the function is called for the *whole* subsection,
         and then recurses into it's members. This means your function must be
         able to handle strings, dictionaries and lists. This allows you
         to change the key of subsections as well as for ordinary members. The
         return value when called on the whole subsection has to be discarded.
-        
+
         See  the encode and decode methods for examples, including functions.
-        
+
         .. admonition:: caution
-        
+
             You can use ``walk`` to transform the names of members of a section
             but you mustn't add or delete members.
-        
+
         >>> config = '''[XXXXsection]
         ... XXXXkey = XXXXvalue'''.splitlines()
         >>> cfg = ConfigObj(config)
@@ -942,17 +942,17 @@
         Accepts a key as input. The corresponding value must be a string or
         the objects (``True`` or 1) or (``False`` or 0). We allow 0 and 1 to
         retain compatibility with Python 2.2.
-        
-        If the string is one of  ``True``, ``On``, ``Yes``, or ``1`` it returns 
+
+        If the string is one of  ``True``, ``On``, ``Yes``, or ``1`` it returns
         ``True``.
-        
-        If the string is one of  ``False``, ``Off``, ``No``, or ``0`` it returns 
+
+        If the string is one of  ``False``, ``Off``, ``No``, or ``0`` it returns
         ``False``.
-        
+
         ``as_bool`` is not case sensitive.
-        
+
         Any other input will raise a ``ValueError``.
-        
+
         >>> a = ConfigObj()
         >>> a['a'] = 'fish'
         >>> a.as_bool('a')
@@ -984,10 +984,10 @@
     def as_int(self, key):
         """
         A convenience method which coerces the specified value to an integer.
-        
+
         If the value is an invalid literal for ``int``, a ``ValueError`` will
         be raised.
-        
+
         >>> a = ConfigObj()
         >>> a['a'] = 'fish'
         >>> a.as_int('a')
@@ -1007,10 +1007,10 @@
     def as_float(self, key):
         """
         A convenience method which coerces the specified value to a float.
-        
+
         If the value is an invalid literal for ``float``, a ``ValueError`` will
         be raised.
-        
+
         >>> a = ConfigObj()
         >>> a['a'] = 'fish'
         >>> a.as_float('a')
@@ -1024,13 +1024,13 @@
         3.2000000000000002
         """
         return float(self[key])
-    
-    
+
+
     def as_list(self, key):
         """
         A convenience method which fetches the specified value, guaranteeing
         that it is a list.
-        
+
         >>> a = ConfigObj()
         >>> a['a'] = 1
         >>> a.as_list('a')
@@ -1046,15 +1046,15 @@
         if isinstance(result, (tuple, list)):
             return list(result)
         return [result]
-        
+
 
     def restore_default(self, key):
         """
         Restore (and return) default value for the specified key.
-        
+
         This method will only work for a ConfigObj that was created
         with a configspec and has been validated.
-        
+
         If there is no default value for this key, ``KeyError`` is raised.
         """
         default = self.default_values[key]
@@ -1063,20 +1063,20 @@
             self.defaults.append(key)
         return default
 
-    
+
     def restore_defaults(self):
         """
         Recursively restore default values to all members
         that have them.
-        
+
         This method will only work for a ConfigObj that was created
         with a configspec and has been validated.
-        
+
         It doesn't delete or modify entries without default values.
         """
         for key in self.default_values:
             self.restore_default(key)
-            
+
         for section in self.sections:
             self[section].restore_defaults()
 
@@ -1191,7 +1191,7 @@
                  write_empty_values=False, _inspec=False):
         """
         Parse a config file or create a config file object.
-        
+
         ``ConfigObj(infile=None, configspec=None, encoding=None,
                     interpolation=True, raise_errors=False, list_values=True,
                     create_empty=False, file_error=False, stringify=True,
@@ -1201,9 +1201,9 @@
         self._inspec = _inspec
         # init the superclass
         Section.__init__(self, self, 0, self)
-        
+
         infile = infile or []
-        
+
         _options = {'configspec': configspec,
                     'encoding': encoding, 'interpolation': interpolation,
                     'raise_errors': raise_errors, 'list_values': list_values,
@@ -1219,7 +1219,7 @@
             warnings.warn('Passing in an options dictionary to ConfigObj() is '
                           'deprecated. Use **options instead.',
                           DeprecationWarning, stacklevel=2)
-            
+
             # TODO: check the values too.
             for entry in options:
                 if entry not in OPTION_DEFAULTS:
@@ -1230,18 +1230,18 @@
                 keyword_value = _options[entry]
                 if value != keyword_value:
                     options[entry] = keyword_value
-        
+
         # XXXX this ignores an explicit list_values = True in combination
         # with _inspec. The user should *never* do that anyway, but still...
         if _inspec:
             options['list_values'] = False
-        
+
         self._initialise(options)
         configspec = options['configspec']
         self._original_configspec = configspec
         self._load(infile, configspec)
-        
-        
+
+
     def _load(self, infile, configspec):
         if isinstance(infile, basestring):
             self.filename = infile
@@ -1261,10 +1261,10 @@
                     h.write('')
                     h.close()
                 infile = []
-                
+
         elif isinstance(infile, (list, tuple)):
             infile = list(infile)
-            
+
         elif isinstance(infile, dict):
             # initialise self
             # the Section class handles creating subsections
@@ -1277,18 +1277,18 @@
                         this_section[section] = {}
                         set_section(in_section[section], this_section[section])
                 set_section(infile, self)
-                
+
             else:
                 for entry in infile:
                     self[entry] = infile[entry]
             del self._errors
-            
+
             if configspec is not None:
                 self._handle_configspec(configspec)
             else:
                 self.configspec = None
             return
-        
+
         elif getattr(infile, 'read', MISSING) is not MISSING:
             # This supports file like objects
             infile = infile.read() or []
@@ -1296,7 +1296,7 @@
             # in case it's not an 8 bit encoding
         else:
             raise TypeError('infile must be a filename, file like object, or list of lines.')
-        
+
         if infile:
             # don't do it for the empty ConfigObj
             infile = self._handle_bom(infile)
@@ -1314,7 +1314,7 @@
                 break
 
             infile = [line.rstrip('\r\n') for line in infile]
-            
+
         self._parse(infile)
         # if we had any errors, now is the time to raise them
         if self._errors:
@@ -1332,17 +1332,17 @@
             raise error
         # delete private attributes
         del self._errors
-        
+
         if configspec is None:
             self.configspec = None
         else:
             self._handle_configspec(configspec)
-    
-    
+
+
     def _initialise(self, options=None):
         if options is None:
             options = OPTION_DEFAULTS
-            
+
         # initialise a few variables
         self.filename = None
         self._errors = []
@@ -1359,48 +1359,48 @@
         self.newlines = None
         self.write_empty_values = options['write_empty_values']
         self.unrepr = options['unrepr']
-        
+
         self.initial_comment = []
         self.final_comment = []
         self.configspec = None
-        
+
         if self._inspec:
             self.list_values = False
-        
+
         # Clear section attributes as well
         Section._initialise(self)
-        
-        
+
+
     def __repr__(self):
         def _getval(key):
             try:
                 return self[key]
             except MissingInterpolationOption:
                 return dict.__getitem__(self, key)
-        return ('ConfigObj({%s})' % 
-                ', '.join([('%s: %s' % (repr(key), repr(_getval(key)))) 
+        return ('ConfigObj({%s})' %
+                ', '.join([('%s: %s' % (repr(key), repr(_getval(key))))
                 for key in (self.scalars + self.sections)]))
-    
-    
+
+
     def _handle_bom(self, infile):
         """
         Handle any BOM, and decode if necessary.
-        
+
         If an encoding is specified, that *must* be used - but the BOM should
         still be removed (and the BOM attribute set).
-        
+
         (If the encoding is wrongly specified, then a BOM for an alternative
         encoding won't be discovered or removed.)
-        
+
         If an encoding is not specified, UTF8 or UTF16 BOM will be detected and
         removed. The BOM attribute will be set. UTF16 will be decoded to
         unicode.
-        
+
         NOTE: This method must not be called with an empty ``infile``.
-        
+
         Specifying the *wrong* encoding is likely to cause a
         ``UnicodeDecodeError``.
-        
+
         ``infile`` must always be returned as a list of lines, but may be
         passed in as a single string.
         """
@@ -1410,7 +1410,7 @@
             # the encoding specified doesn't have one
             # just decode
             return self._decode(infile, self.encoding)
-        
+
         if isinstance(infile, (list, tuple)):
             line = infile[0]
         else:
@@ -1432,18 +1432,18 @@
                         ##self.BOM = True
                         # Don't need to remove BOM
                         return self._decode(infile, encoding)
-                    
+
                 # If we get this far, will *probably* raise a DecodeError
                 # As it doesn't appear to start with a BOM
                 return self._decode(infile, self.encoding)
-            
+
             # Must be UTF8
             BOM = BOM_SET[enc]
             if not line.startswith(BOM):
                 return self._decode(infile, self.encoding)
-            
+
             newline = line[len(BOM):]
-            
+
             # BOM removed
             if isinstance(infile, (list, tuple)):
                 infile[0] = newline
@@ -1451,7 +1451,7 @@
                 infile = newline
             self.BOM = True
             return self._decode(infile, self.encoding)
-        
+
         # No encoding specified - so we need to check for UTF8/UTF16
         for BOM, (encoding, final_encoding) in BOMS.items():
             if not line.startswith(BOM):
@@ -1475,7 +1475,7 @@
                         return infile
                 # UTF16 - have to decode
                 return self._decode(infile, encoding)
-            
+
         # No BOM discovered and no encoding specified, just return
         if isinstance(infile, basestring):
             # infile read from a file will be a single string
@@ -1494,7 +1494,7 @@
     def _decode(self, infile, encoding):
         """
         Decode infile to unicode. Using the specified encoding.
-        
+
         if is a string, it also needs converting to a list.
         """
         if isinstance(infile, basestring):
@@ -1535,14 +1535,14 @@
         temp_list_values = self.list_values
         if self.unrepr:
             self.list_values = False
-            
+
         comment_list = []
         done_start = False
         this_section = self
         maxline = len(infile) - 1
         cur_index = -1
         reset_comment = False
-        
+
         while cur_index < maxline:
             if reset_comment:
                 comment_list = []
@@ -1554,13 +1554,13 @@
                 reset_comment = False
                 comment_list.append(line)
                 continue
-            
+
             if not done_start:
                 # preserve initial comment
                 self.initial_comment = comment_list
                 comment_list = []
                 done_start = True
-                
+
             reset_comment = True
             # first we check if it's a section marker
             mat = self._sectionmarker.match(line)
@@ -1574,7 +1574,7 @@
                     self._handle_error("Cannot compute the section depth at line %s.",
                                        NestingError, infile, cur_index)
                     continue
-                
+
                 if cur_depth < this_section.depth:
                     # the new section is dropping back to a previous level
                     try:
@@ -1593,13 +1593,13 @@
                 else:
                     self._handle_error("Section too nested at line %s.",
                                        NestingError, infile, cur_index)
-                    
+
                 sect_name = self._unquote(sect_name)
                 if sect_name in parent:
                     self._handle_error('Duplicate section name at line %s.',
                                        DuplicateError, infile, cur_index)
                     continue
-                
+
                 # create the new section
                 this_section = Section(
                     parent,
@@ -1702,7 +1702,7 @@
         """
         Given a section and a depth level, walk back through the sections
         parents to see if the depth level matches a previous section.
-        
+
         Return a reference to the right section,
         or raise a SyntaxError.
         """
@@ -1720,7 +1720,7 @@
     def _handle_error(self, text, ErrorClass, infile, cur_index):
         """
         Handle an error according to the error settings.
-        
+
         Either raise the error or store it.
         The error will have occured at ``cur_index``
         """
@@ -1749,19 +1749,19 @@
     def _quote(self, value, multiline=True):
         """
         Return a safely quoted version of a value.
-        
+
         Raise a ConfigObjError if the value cannot be safely quoted.
         If multiline is ``True`` (default) then use triple quotes
         if necessary.
-        
+
         * Don't quote values that don't need it.
         * Recursively quote members of a list and return a comma joined list.
         * Multiline is ``False`` for lists.
         * Obey list syntax for empty and single member lists.
-        
+
         If ``list_values=False`` then the value is only quoted if it contains
         a ``\\n`` (is multiline) or '#'.
-        
+
         If ``write_empty_values`` is set, and the value is an empty string, it
         won't be quoted.
         """
@@ -1769,7 +1769,7 @@
             # Only if multiline is set, so that it is used for values not
             # keys, and not values that are part of a list
             return ''
-        
+
         if multiline and isinstance(value, (list, tuple)):
             if not value:
                 return ','
@@ -1785,12 +1785,12 @@
 
         if not value:
             return '""'
-        
+
         no_lists_no_quotes = not self.list_values and '\n' not in value and '#' not in value
         need_triple = multiline and ((("'" in value) and ('"' in value)) or ('\n' in value ))
         hash_triple_quote = multiline and not need_triple and ("'" in value) and ('"' in value) and ('#' in value)
         check_for_single = (no_lists_no_quotes or not need_triple) and not hash_triple_quote
-        
+
         if check_for_single:
             if not self.list_values:
                 # we don't quote if ``list_values=False``
@@ -1808,13 +1808,13 @@
         else:
             # if value has '\n' or "'" *and* '"', it will need triple quotes
             quot = self._get_triple_quote(value)
-        
+
         if quot == noquot and '#' in value and self.list_values:
             quot = self._get_single_quote(value)
-                
+
         return quot % value
-    
-    
+
+
     def _get_single_quote(self, value):
         if ("'" in value) and ('"' in value):
             raise ConfigObjError('Value "%s" cannot be safely quoted.' % value)
@@ -1823,15 +1823,15 @@
         else:
             quot = dquot
         return quot
-    
-    
+
+
     def _get_triple_quote(self, value):
         if (value.find('"""') != -1) and (value.find("'''") != -1):
             raise ConfigObjError('Value "%s" cannot be safely quoted.' % value)
         if value.find('"""') == -1:
             quot = tdquot
         else:
-            quot = tsquot 
+            quot = tsquot
         return quot
 
 
@@ -1921,7 +1921,7 @@
 
     def _handle_configspec(self, configspec):
         """Parse the configspec."""
-        # FIXME: Should we check that the configspec was created with the 
+        # FIXME: Should we check that the configspec was created with the
         #        correct settings ? (i.e. ``list_values=False``)
         if not isinstance(configspec, ConfigObj):
             try:
@@ -1935,11 +1935,11 @@
                 raise ConfigspecError('Parsing configspec failed: %s' % e)
             except IOError, e:
                 raise IOError('Reading configspec failed: %s' % e)
-        
-        self.configspec = configspec
-            
 
-        
+        self.configspec = configspec
+
+
+
     def _set_configspec(self, section, copy):
         """
         Called by validate. Handles setting the configspec on subsections
@@ -1951,7 +1951,7 @@
             for entry in section.sections:
                 if entry not in configspec:
                     section[entry].configspec = many
-                    
+
         for entry in configspec.sections:
             if entry == '__many__':
                 continue
@@ -1962,11 +1962,11 @@
                     # copy comments
                     section.comments[entry] = configspec.comments.get(entry, [])
                     section.inline_comments[entry] = configspec.inline_comments.get(entry, '')
-                
+
             # Could be a scalar when we expect a section
             if isinstance(section[entry], Section):
                 section[entry].configspec = configspec[entry]
-                        
+
 
     def _write_line(self, indent_string, entry, this_entry, comment):
         """Write an individual line, for the write method"""
@@ -2006,9 +2006,9 @@
     def write(self, outfile=None, section=None):
         """
         Write the current ConfigObj as a file
-        
+
         tekNico: FIXME: use StringIO instead of real files
-        
+
         >>> filename = a.filename
         >>> a.filename = 'test.ini'
         >>> a.write()
@@ -2021,7 +2021,7 @@
         if self.indent_type is None:
             # this can be true if initialised from a dictionary
             self.indent_type = DEFAULT_INDENT_TYPE
-            
+
         out = []
         cs = self._a_to_u('#')
         csp = self._a_to_u('# ')
@@ -2035,7 +2035,7 @@
                 if stripped_line and not stripped_line.startswith(cs):
                     line = csp + line
                 out.append(line)
-                
+
         indent_string = self.indent_type * section.depth
         for entry in (section.scalars + section.sections):
             if entry in section.defaults:
@@ -2048,7 +2048,7 @@
                 out.append(indent_string + comment_line)
             this_entry = section[entry]
             comment = self._handle_comment(section.inline_comments[entry])
-            
+
             if isinstance(this_entry, dict):
                 # a section
                 out.append(self._write_marker(
@@ -2063,7 +2063,7 @@
                     entry,
                     this_entry,
                     comment))
-                
+
         if section is self:
             for line in self.final_comment:
                 line = self._decode_element(line)
@@ -2072,10 +2072,10 @@
                     line = csp + line
                 out.append(line)
             self.interpolation = int_val
-            
+
         if section is not self:
             return out
-        
+
         if (self.filename is None) and (outfile is None):
             # output a list of lines
             # might need to encode
@@ -2089,7 +2089,7 @@
                     out.append('')
                 out[0] = BOM_UTF8 + out[0]
             return out
-        
+
         # Turn the list to a string, joined with correct newlines
         newline = self.newlines or os.linesep
         if (getattr(outfile, 'mode', None) is not None and outfile.mode == 'w'
@@ -2102,7 +2102,7 @@
         if self.BOM and ((self.encoding is None) or match_utf8(self.encoding)):
             # Add the UTF8 BOM
             output = BOM_UTF8 + output
-            
+
         if not output.endswith(newline):
             output += newline
         if outfile is not None:
@@ -2117,34 +2117,34 @@
                  section=None):
         """
         Test the ConfigObj against a configspec.
-        
+
         It uses the ``validator`` object from *validate.py*.
-        
+
         To run ``validate`` on the current ConfigObj, call: ::
-        
+
             test = config.validate(validator)
-        
+
         (Normally having previously passed in the configspec when the ConfigObj
         was created - you can dynamically assign a dictionary of checks to the
         ``configspec`` attribute of a section though).
-        
+
         It returns ``True`` if everything passes, or a dictionary of
         pass/fails (True/False). If every member of a subsection passes, it
         will just have the value ``True``. (It also returns ``False`` if all
         members fail).
-        
+
         In addition, it converts the values from strings to their native
         types if their checks pass (and ``stringify`` is set).
-        
+
         If ``preserve_errors`` is ``True`` (``False`` is default) then instead
         of a marking a fail with a ``False``, it will preserve the actual
         exception object. This can contain info about the reason for failure.
         For example the ``VdtValueTooSmallError`` indicates that the value
         supplied was too small. If a value (or section) is missing it will
         still be marked as ``False``.
-        
+
         You must have the validate module to use ``preserve_errors=True``.
-        
+
         You can then use the ``flatten_errors`` function to turn your nested
         results dictionary into a flattened list of failures - useful for
         displaying meaningful error messages.
@@ -2157,7 +2157,7 @@
                 # Which makes importing configobj faster
                 from validate import VdtMissingValue
                 self._vdtMissingValue = VdtMissingValue
-                
+
             section = self
 
             if copy:
@@ -2167,23 +2167,23 @@
                 section.BOM = section.configspec.BOM
                 section.newlines = section.configspec.newlines
                 section.indent_type = section.configspec.indent_type
-            
+
         #
         # section.default_values.clear() #??
         configspec = section.configspec
         self._set_configspec(section, copy)
 
-        
+
         def validate_entry(entry, spec, val, missing, ret_true, ret_false):
             section.default_values.pop(entry, None)
-                
+
             try:
                 section.default_values[entry] = validator.get_default_value(configspec[entry])
             except (KeyError, AttributeError, validator.baseErrorClass):
                 # No default, bad default or validator has no 'get_default_value'
                 # (e.g. SimpleVal)
                 pass
-            
+
             try:
                 check = validator.check(spec,
                                         val,
@@ -2217,16 +2217,16 @@
                 if not copy and missing and entry not in section.defaults:
                     section.defaults.append(entry)
             return ret_true, ret_false
-        
+
         #
         out = {}
         ret_true = True
         ret_false = True
-        
+
         unvalidated = [k for k in section.scalars if k not in configspec]
-        incorrect_sections = [k for k in configspec.sections if k in section.scalars]        
+        incorrect_sections = [k for k in configspec.sections if k in section.scalars]
         incorrect_scalars = [k for k in configspec.scalars if k in section.sections]
-        
+
         for entry in configspec.scalars:
             if entry in ('__many__', '___many___'):
                 # reserved names
@@ -2246,16 +2246,16 @@
             else:
                 missing = False
                 val = section[entry]
-            
-            ret_true, ret_false = validate_entry(entry, configspec[entry], val, 
+
+            ret_true, ret_false = validate_entry(entry, configspec[entry], val,
                                                  missing, ret_true, ret_false)
-        
+
         many = None
         if '__many__' in configspec.scalars:
             many = configspec['__many__']
         elif '___many___' in configspec.scalars:
             many = configspec['___many___']
-        
+
         if many is not None:
             for entry in unvalidated:
                 val = section[entry]
@@ -2279,7 +2279,7 @@
                 ret_false = False
                 msg = 'Section %r was provided as a single value' % entry
                 out[entry] = validator.baseErrorClass(msg)
-                
+
         # Missing sections will have been created as empty ones when the
         # configspec was read.
         for entry in section.sections:
@@ -2300,7 +2300,7 @@
                 ret_false = False
             else:
                 ret_true = False
-        
+
         section.extra_values = unvalidated
         if preserve_errors and not section._created:
             # If the section wasn't created (i.e. it wasn't missing)
@@ -2329,12 +2329,12 @@
         self.configspec = None
         # Just to be sure ;-)
         self._original_configspec = None
-        
-        
+
+
     def reload(self):
         """
         Reload a ConfigObj from file.
-        
+
         This method raises a ``ReloadError`` if the ConfigObj doesn't have
         a filename attribute pointing to a file.
         """
@@ -2347,31 +2347,31 @@
             if entry == 'configspec':
                 continue
             current_options[entry] = getattr(self, entry)
-            
+
         configspec = self._original_configspec
         current_options['configspec'] = configspec
-            
+
         self.clear()
         self._initialise(current_options)
         self._load(filename, configspec)
-        
+
 
 
 class SimpleVal(object):
     """
     A simple validator.
     Can be used to check that all members expected are present.
-    
+
     To use it, provide a configspec with all your members in (the value given
     will be ignored). Pass an instance of ``SimpleVal`` to the ``validate``
     method of your ``ConfigObj``. ``validate`` will return ``True`` if all
     members are present, or a dictionary with True/False meaning
     present/missing. (Whole missing sections will be replaced with ``False``)
     """
-    
+
     def __init__(self):
         self.baseErrorClass = ConfigObjError
-    
+
     def check(self, check, member, missing=False):
         """A dummy check method, always returns the value unchanged."""
         if missing:
@@ -2383,32 +2383,32 @@
     """
     An example function that will turn a nested dictionary of results
     (as returned by ``ConfigObj.validate``) into a flat list.
-    
+
     ``cfg`` is the ConfigObj instance being checked, ``res`` is the results
     dictionary returned by ``validate``.
-    
+
     (This is a recursive function, so you shouldn't use the ``levels`` or
     ``results`` arguments - they are used by the function.)
-    
+
     Returns a list of keys that failed. Each member of the list is a tuple::
-    
+
         ([list of sections...], key, result)
-    
+
     If ``validate`` was called with ``preserve_errors=False`` (the default)
     then ``result`` will always be ``False``.
 
     *list of sections* is a flattened list of sections that the key was found
     in.
-    
+
     If the section was missing (or a section was expected and a scalar provided
     - or vice-versa) then key will be ``None``.
-    
+
     If the value (or section) was missing then ``result`` will be ``False``.
-    
+
     If ``validate`` was called with ``preserve_errors=True`` and a value
     was present, but failed the check, then ``result`` will be the exception
     object returned. You can use this as a string that describes the failure.
-    
+
     For example *The value "3" is of the wrong type*.
     """
     if levels is None:
@@ -2443,21 +2443,21 @@
     """
     Find all the values and sections not in the configspec from a validated
     ConfigObj.
-    
+
     ``get_extra_values`` returns a list of tuples where each tuple represents
     either an extra section, or an extra value.
-    
-    The tuples contain two values, a tuple representing the section the value 
+
+    The tuples contain two values, a tuple representing the section the value
     is in and the name of the extra values. For extra values in the top level
     section the first member will be an empty tuple. For values in the 'foo'
     section the first member will be ``('foo',)``. For members in the 'bar'
     subsection of the 'foo' section the first member will be ``('foo', 'bar')``.
-    
+
     NOTE: If you call ``get_extra_values`` on a ConfigObj instance that hasn't
     been validated it will return an empty list.
     """
     out = []
-    
+
     out.extend([(_prepend, name) for name in conf.extra_values])
     for name in conf.sections:
         if name not in conf.extra_values:
diff --git a/TestON/lib/configobj-4.7.2/validate.py b/TestON/lib/configobj-4.7.2/validate.py
index 73dbdb8..9da84ac 100644
--- a/TestON/lib/configobj-4.7.2/validate.py
+++ b/TestON/lib/configobj-4.7.2/validate.py
@@ -17,114 +17,114 @@
 # Comments, suggestions and bug reports welcome.
 
 """
-    The Validator object is used to check that supplied values 
+    The Validator object is used to check that supplied values
     conform to a specification.
-    
+
     The value can be supplied as a string - e.g. from a config file.
     In this case the check will also *convert* the value to
     the required type. This allows you to add validation
     as a transparent layer to access data stored as strings.
     The validation checks that the data is correct *and*
     converts it to the expected type.
-    
+
     Some standard checks are provided for basic data types.
     Additional checks are easy to write. They can be
     provided when the ``Validator`` is instantiated or
     added afterwards.
-    
+
     The standard functions work with the following basic data types :
-    
+
     * integers
     * floats
     * booleans
     * strings
     * ip_addr
-    
+
     plus lists of these datatypes
-    
+
     Adding additional checks is done through coding simple functions.
-    
-    The full set of standard checks are : 
-    
+
+    The full set of standard checks are :
+
     * 'integer': matches integer values (including negative)
                  Takes optional 'min' and 'max' arguments : ::
-    
+
                    integer()
                    integer(3, 9)  # any value from 3 to 9
                    integer(min=0) # any positive value
                    integer(max=9)
-    
+
     * 'float': matches float values
                Has the same parameters as the integer check.
-    
+
     * 'boolean': matches boolean values - ``True`` or ``False``
                  Acceptable string values for True are :
                    true, on, yes, 1
                  Acceptable string values for False are :
                    false, off, no, 0
-    
+
                  Any other value raises an error.
-    
+
     * 'ip_addr': matches an Internet Protocol address, v.4, represented
                  by a dotted-quad string, i.e. '1.2.3.4'.
-    
+
     * 'string': matches any string.
                 Takes optional keyword args 'min' and 'max'
                 to specify min and max lengths of the string.
-    
+
     * 'list': matches any list.
               Takes optional keyword args 'min', and 'max' to specify min and
               max sizes of the list. (Always returns a list.)
-    
+
     * 'tuple': matches any tuple.
               Takes optional keyword args 'min', and 'max' to specify min and
               max sizes of the tuple. (Always returns a tuple.)
-    
+
     * 'int_list': Matches a list of integers.
                   Takes the same arguments as list.
-    
+
     * 'float_list': Matches a list of floats.
                     Takes the same arguments as list.
-    
+
     * 'bool_list': Matches a list of boolean values.
                    Takes the same arguments as list.
-    
+
     * 'ip_addr_list': Matches a list of IP addresses.
                      Takes the same arguments as list.
-    
+
     * 'string_list': Matches a list of strings.
                      Takes the same arguments as list.
-    
-    * 'mixed_list': Matches a list with different types in 
+
+    * 'mixed_list': Matches a list with different types in
                     specific positions. List size must match
                     the number of arguments.
-    
+
                     Each position can be one of :
                     'integer', 'float', 'ip_addr', 'string', 'boolean'
-    
+
                     So to specify a list with two strings followed
                     by two integers, you write the check as : ::
-    
+
                       mixed_list('string', 'string', 'integer', 'integer')
-    
+
     * 'pass': This check matches everything ! It never fails
               and the value is unchanged.
-    
+
               It is also the default if no check is specified.
-    
+
     * 'option': This check matches any from a list of options.
                 You specify this check with : ::
-    
+
                   option('option 1', 'option 2', 'option 3')
-    
+
     You can supply a default value (returned if no value is supplied)
     using the default keyword argument.
-    
+
     You specify a list argument for default using a list constructor syntax in
     the check : ::
-    
+
         checkname(arg1, arg2, default=list('val 1', 'val 2', 'val 3'))
-    
+
     A badly formatted set of arguments will raise a ``VdtParamError``.
 """
 
@@ -259,7 +259,7 @@
 def dottedQuadToNum(ip):
     """
     Convert decimal dotted quad string to long integer
-    
+
     >>> int(dottedQuadToNum('1 '))
     1
     >>> int(dottedQuadToNum(' 1.2'))
@@ -274,10 +274,10 @@
     Traceback (most recent call last):
     ValueError: Not a good dotted-quad IP: 255.255.255.256
     """
-    
+
     # import here to avoid it when ip_addr values are not used
     import socket, struct
-    
+
     try:
         return struct.unpack('!L',
             socket.inet_aton(ip.strip()))[0]
@@ -293,7 +293,7 @@
 def numToDottedQuad(num):
     """
     Convert long int to dotted quad string
-    
+
     >>> numToDottedQuad(-1L)
     Traceback (most recent call last):
     ValueError: Not a good numeric IP: -1
@@ -311,10 +311,10 @@
     Traceback (most recent call last):
     ValueError: Not a good numeric IP: 4294967296
     """
-    
+
     # import here to avoid it when ip_addr values are not used
     import socket, struct
-    
+
     # no need to intercept here, 4294967295L is fine
     if num > 4294967295L or num < 0:
         raise ValueError('Not a good numeric IP: %s' % num)
@@ -329,10 +329,10 @@
     """
     This error indicates that the check failed.
     It can be the base class for more specific errors.
-    
+
     Any check function that fails ought to raise this error.
     (or a subclass)
-    
+
     >>> raise ValidateError
     Traceback (most recent call last):
     ValidateError
@@ -381,7 +381,7 @@
 
 class VdtValueError(ValidateError):
     """The value supplied was of the correct type, but was not an allowed value."""
-    
+
     def __init__(self, value):
         """
         >>> raise VdtValueError('jedi')
@@ -445,18 +445,18 @@
     """
     Validator is an object that allows you to register a set of 'checks'.
     These checks take input and test that it conforms to the check.
-    
+
     This can also involve converting the value from a string into
     the correct datatype.
-    
+
     The ``check`` method takes an input string which configures which
     check is to be used and applies that check to a supplied value.
-    
+
     An example input string would be:
     'int_range(param1, param2)'
-    
+
     You would then provide something like:
-    
+
     >>> def int_range_check(value, min, max):
     ...     # turn min and max from strings to integers
     ...     min = int(min)
@@ -479,7 +479,7 @@
     ...     if not value <= max:
     ...          raise VdtValueTooBigError(value)
     ...     return value
-    
+
     >>> fdict = {'int_range': int_range_check}
     >>> vtr1 = Validator(fdict)
     >>> vtr1.check('int_range(20, 40)', '30')
@@ -487,25 +487,25 @@
     >>> vtr1.check('int_range(20, 40)', '60')
     Traceback (most recent call last):
     VdtValueTooBigError: the value "60" is too big.
-    
+
     New functions can be added with : ::
-    
-    >>> vtr2 = Validator()       
+
+    >>> vtr2 = Validator()
     >>> vtr2.functions['int_range'] = int_range_check
-    
-    Or by passing in a dictionary of functions when Validator 
+
+    Or by passing in a dictionary of functions when Validator
     is instantiated.
-    
+
     Your functions *can* use keyword arguments,
     but the first argument should always be 'value'.
-    
+
     If the function doesn't take additional arguments,
     the parentheses are optional in the check.
     It can be written with either of : ::
-    
+
         keyword = function_name
         keyword = function_name()
-    
+
     The first program to utilise Validator() was Michael Foord's
     ConfigObj, an alternative to ConfigParser which supports lists and
     can validate a config file using a config schema.
@@ -565,35 +565,35 @@
     def check(self, check, value, missing=False):
         """
         Usage: check(check, value)
-        
+
         Arguments:
             check: string representing check to apply (including arguments)
             value: object to be checked
         Returns value, converted to correct type if necessary
-        
+
         If the check fails, raises a ``ValidateError`` subclass.
-        
+
         >>> vtor.check('yoda', '')
         Traceback (most recent call last):
         VdtUnknownCheckError: the check "yoda" is unknown.
         >>> vtor.check('yoda()', '')
         Traceback (most recent call last):
         VdtUnknownCheckError: the check "yoda" is unknown.
-        
+
         >>> vtor.check('string(default="")', '', missing=True)
         ''
         """
         fun_name, fun_args, fun_kwargs, default = self._parse_with_caching(check)
-            
+
         if missing:
             if default is None:
                 # no information needed here - to be handled by caller
                 raise VdtMissingValue()
             value = self._handle_none(default)
-        
+
         if value is None:
             return None
-        
+
         return self._check_value(value, fun_name, fun_args, fun_kwargs)
 
 
@@ -618,8 +618,8 @@
             fun_kwargs = dict([(str(key), value) for (key, value) in fun_kwargs.items()])
             self._cache[check] = fun_name, list(fun_args), dict(fun_kwargs), default
         return fun_name, fun_args, fun_kwargs, default
-        
-        
+
+
     def _check_value(self, value, fun_name, fun_args, fun_kwargs):
         try:
             fun = self.functions[fun_name]
@@ -657,7 +657,7 @@
                         val = self._unquote(val)
                     fun_kwargs[keymatch.group(1)] = val
                     continue
-                
+
                 fun_args.append(self._unquote(arg))
         else:
             # allows for function names without (args)
@@ -689,20 +689,20 @@
     def _pass(self, value):
         """
         Dummy check that always passes
-        
+
         >>> vtor.check('', 0)
         0
         >>> vtor.check('', '0')
         '0'
         """
         return value
-    
-    
+
+
     def get_default_value(self, check):
         """
         Given a check, return the default value for the check
         (converted to the right type).
-        
+
         If the check doesn't specify a default value then a
         ``KeyError`` will be raised.
         """
@@ -718,11 +718,11 @@
 def _is_num_param(names, values, to_float=False):
     """
     Return numbers from inputs or raise VdtParamError.
-    
+
     Lets ``None`` pass through.
     Pass in keyword argument ``to_float=True`` to
     use float for the conversion rather than int.
-    
+
     >>> _is_num_param(('', ''), (0, 1.0))
     [0, 1]
     >>> _is_num_param(('', ''), (0, 1.0), to_float=True)
@@ -757,10 +757,10 @@
     A check that tests that a given value is an integer (int, or long)
     and optionally, between bounds. A negative value is accepted, while
     a float will fail.
-    
+
     If the value is a string, then the conversion is done - if possible.
     Otherwise a VdtError is raised.
-    
+
     >>> vtor.check('integer', '-1')
     -1
     >>> vtor.check('integer', '0')
@@ -812,17 +812,17 @@
     """
     A check that tests that a given value is a float
     (an integer will be accepted), and optionally - that it is between bounds.
-    
+
     If the value is a string, then the conversion is done - if possible.
     Otherwise a VdtError is raised.
-    
+
     This can accept negative values.
-    
+
     >>> vtor.check('float', '2')
     2.0
-    
+
     From now on we multiply the value to avoid comparing decimals
-    
+
     >>> vtor.check('float', '-6.8') * 10
     -68.0
     >>> vtor.check('float', '12.2') * 10
@@ -861,7 +861,7 @@
 
 
 bool_dict = {
-    True: True, 'on': True, '1': True, 'true': True, 'yes': True, 
+    True: True, 'on': True, '1': True, 'true': True, 'yes': True,
     False: False, 'off': False, '0': False, 'false': False, 'no': False,
 }
 
@@ -869,7 +869,7 @@
 def is_boolean(value):
     """
     Check if the value represents a boolean.
-    
+
     >>> vtor.check('boolean', 0)
     0
     >>> vtor.check('boolean', False)
@@ -908,7 +908,7 @@
     >>> vtor.check('boolean', 'up')
     Traceback (most recent call last):
     VdtTypeError: the value "up" is of the wrong type.
-    
+
     """
     if isinstance(value, basestring):
         try:
@@ -930,7 +930,7 @@
     """
     Check that the supplied value is an Internet Protocol address, v.4,
     represented by a dotted-quad string, i.e. '1.2.3.4'.
-    
+
     >>> vtor.check('ip_addr', '1 ')
     '1'
     >>> vtor.check('ip_addr', ' 1.2')
@@ -966,11 +966,11 @@
 def is_list(value, min=None, max=None):
     """
     Check that the value is a list of values.
-    
+
     You can optionally specify the minimum and maximum number of members.
-    
+
     It does no check on list members.
-    
+
     >>> vtor.check('list', ())
     []
     >>> vtor.check('list', [])
@@ -1011,11 +1011,11 @@
 def is_tuple(value, min=None, max=None):
     """
     Check that the value is a tuple of values.
-    
+
     You can optionally specify the minimum and maximum number of members.
-    
+
     It does no check on members.
-    
+
     >>> vtor.check('tuple', ())
     ()
     >>> vtor.check('tuple', [])
@@ -1045,9 +1045,9 @@
 def is_string(value, min=None, max=None):
     """
     Check that the supplied value is a string.
-    
+
     You can optionally specify the minimum and maximum number of members.
-    
+
     >>> vtor.check('string', '0')
     '0'
     >>> vtor.check('string', 0)
@@ -1081,11 +1081,11 @@
 def is_int_list(value, min=None, max=None):
     """
     Check that the value is a list of integers.
-    
+
     You can optionally specify the minimum and maximum number of members.
-    
+
     Each list member is checked that it is an integer.
-    
+
     >>> vtor.check('int_list', ())
     []
     >>> vtor.check('int_list', [])
@@ -1104,11 +1104,11 @@
 def is_bool_list(value, min=None, max=None):
     """
     Check that the value is a list of booleans.
-    
+
     You can optionally specify the minimum and maximum number of members.
-    
+
     Each list member is checked that it is a boolean.
-    
+
     >>> vtor.check('bool_list', ())
     []
     >>> vtor.check('bool_list', [])
@@ -1129,11 +1129,11 @@
 def is_float_list(value, min=None, max=None):
     """
     Check that the value is a list of floats.
-    
+
     You can optionally specify the minimum and maximum number of members.
-    
+
     Each list member is checked that it is a float.
-    
+
     >>> vtor.check('float_list', ())
     []
     >>> vtor.check('float_list', [])
@@ -1152,11 +1152,11 @@
 def is_string_list(value, min=None, max=None):
     """
     Check that the value is a list of strings.
-    
+
     You can optionally specify the minimum and maximum number of members.
-    
+
     Each list member is checked that it is a string.
-    
+
     >>> vtor.check('string_list', ())
     []
     >>> vtor.check('string_list', [])
@@ -1178,11 +1178,11 @@
 def is_ip_addr_list(value, min=None, max=None):
     """
     Check that the value is a list of IP addresses.
-    
+
     You can optionally specify the minimum and maximum number of members.
-    
+
     Each list member is checked that it is an IP address.
-    
+
     >>> vtor.check('ip_addr_list', ())
     []
     >>> vtor.check('ip_addr_list', [])
@@ -1201,11 +1201,11 @@
     Check that a value is a list, coercing strings into
     a list with one member. Useful where users forget the
     trailing comma that turns a single value into a list.
-    
+
     You can optionally specify the minimum and maximum number of members.
     A minumum of greater than one will fail if the user only supplies a
     string.
-    
+
     >>> vtor.check('force_list', ())
     []
     >>> vtor.check('force_list', [])
@@ -1216,8 +1216,8 @@
     if not isinstance(value, (list, tuple)):
         value = [value]
     return is_list(value, min, max)
-    
-    
+
+
 
 fun_dict = {
     'integer': is_integer,
@@ -1233,20 +1233,20 @@
     Check that the value is a list.
     Allow specifying the type of each member.
     Work on lists of specific lengths.
-    
+
     You specify each member as a positional argument specifying type
-    
+
     Each type should be one of the following strings :
       'integer', 'float', 'ip_addr', 'string', 'boolean'
-    
+
     So you can specify a list of two strings, followed by
     two integers as :
-    
+
       mixed_list('string', 'string', 'integer', 'integer')
-    
+
     The length of the list must match the number of positional
     arguments you supply.
-    
+
     >>> mix_str = "mixed_list('integer', 'float', 'ip_addr', 'string', 'boolean')"
     >>> check_res = vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a', True))
     >>> check_res == [1, 2.0, '1.2.3.4', 'a', True]
@@ -1266,10 +1266,10 @@
     >>> vtor.check(mix_str, 0)
     Traceback (most recent call last):
     VdtTypeError: the value "0" is of the wrong type.
-    
+
     This test requires an elaborate setup, because of a change in error string
     output from the interpreter between Python 2.2 and 2.3 .
-    
+
     >>> res_seq = (
     ...     'passed an incorrect value "',
     ...     'yoda',
@@ -1299,7 +1299,7 @@
 def is_option(value, *options):
     """
     This check matches the value to any of a set of options.
-    
+
     >>> vtor.check('option("yoda", "jedi")', 'yoda')
     'yoda'
     >>> vtor.check('option("yoda", "jedi")', 'jed')
@@ -1319,7 +1319,7 @@
 def _test(value, *args, **keywargs):
     """
     A function that exists for test purposes.
-    
+
     >>> checks = [
     ...     '3, 6, min=1, max=3, test=list(a, b, c)',
     ...     '3',
@@ -1353,7 +1353,7 @@
     (3, ('3',), {'test': ['a', 'b', 'c'], 'max': '3'})
     (3, ('3',), {'test': ["'a'", 'b', 'x=(c)'], 'max': '3'})
     (3, (), {'test': 'x=fish(3)'})
-    
+
     >>> v = Validator()
     >>> v.check('integer(default=6)', '3')
     3
@@ -1371,7 +1371,7 @@
     KeyError: 'Check "pass" has no default value.'
     >>> v.get_default_value('pass(default=list(1, 2, 3, 4))')
     ['1', '2', '3', '4']
-    
+
     >>> v = Validator()
     >>> v.check("pass(default=None)", None, True)
     >>> v.check("pass(default='None')", None, True)
@@ -1380,18 +1380,18 @@
     'None'
     >>> v.check('pass(default=list(1, 2, 3, 4))', None, True)
     ['1', '2', '3', '4']
-    
+
     Bug test for unicode arguments
     >>> v = Validator()
     >>> v.check(u'string(min=4)', u'test')
     u'test'
-    
+
     >>> v = Validator()
     >>> v.get_default_value(u'string(min=4, default="1234")')
     u'1234'
     >>> v.check(u'string(min=4, default="1234")', u'test')
     u'test'
-    
+
     >>> v = Validator()
     >>> default = v.get_default_value('string(default=None)')
     >>> default == None
@@ -1402,7 +1402,7 @@
 
 def _test2():
     """
-    >>> 
+    >>>
     >>> v = Validator()
     >>> v.get_default_value('string(default="#ff00dd")')
     '#ff00dd'
@@ -1436,8 +1436,8 @@
     >>> vtor.check("string_list(default=list('\n'))", '', missing=True)
     ['\n']
     """
-    
-    
+
+
 if __name__ == '__main__':
     # run the code tests in doctest format
     import sys
diff --git a/TestON/lib/pox/core.py b/TestON/lib/pox/core.py
index 8b31e7a..dc8cab6 100644
--- a/TestON/lib/pox/core.py
+++ b/TestON/lib/pox/core.py
@@ -306,26 +306,26 @@
       log.warn("Warning: Registered '%s' multipled times" % (name,))
     self.components[name] = component
     self.raiseEventNoErrors(ComponentRegistered, name, component)
-    
+
   def listenToDependencies(self, sink, components):
     """
     If a component depends on having other components
-    registered with core before it can boot, it can use this method to 
+    registered with core before it can boot, it can use this method to
     check for registration, and listen to events on those dependencies.
-    
+
     Note that event handlers named with the _handle* pattern in the sink must
     include the name of the desired source as a prefix. For example, if topology is a
     dependency, a handler for topology's SwitchJoin event must be labeled:
        def _handle_topology_SwitchJoin(...)
-    
+
     sink - the component waiting on dependencies
     components - a list of dependent component names
-    
+
     Returns whether all of the desired components are registered.
     """
     if components == None or len(components) == 0:
       return True
-  
+
     got = set()
     for c in components:
       if self.hasComponent(c):
diff --git a/TestON/lib/updatedriver/fvtadd.py b/TestON/lib/updatedriver/fvtadd.py
index bba273e..93528bc 100644
--- a/TestON/lib/updatedriver/fvtadd.py
+++ b/TestON/lib/updatedriver/fvtadd.py
@@ -1,8 +1,8 @@
 class FVTADD :
     def __init__(self):
         self.default = ''
-    
-   
+
+
     def runTest(self,self) :
         return TemplateTest.runTest(self)
 
diff --git a/TestON/lib/updatedriver/fvtdriver.py b/TestON/lib/updatedriver/fvtdriver.py
index dc6c4c0..df2bd01 100644
--- a/TestON/lib/updatedriver/fvtdriver.py
+++ b/TestON/lib/updatedriver/fvtdriver.py
@@ -1,7 +1,7 @@
 class driver :
     def __init__(self):
         self.default = ''
- 
+
 
     def runTest(self,self) :
         return TemplateTest.runTest(self)