diff --git a/test-tc.py b/test-tc.py index 1c37d6f..ca2f4ba 100755 --- a/test-tc.py +++ b/test-tc.py @@ -3,7 +3,7 @@ # Copyright (c) 2003-2004 TundraWare Inc. All Rights Reserved. PROGNAME = "tconfpy Test Driver" -RCSID = "$Id: test-tc.py,v 1.133 2004/04/17 19:31:04 tundra Exp $" +RCSID = "$Id: test-tc.py,v 1.134 2004/04/27 02:30:43 tundra Exp $" VERSION = RCSID.split()[2] # Copyright Information @@ -35,24 +35,25 @@ #---------------------------------------------------------------------------# -# One of the options of this test driver is to initialize a test symbol -# table. We build that table here in case the user requested it. - -# Create An Empty Symbol Table -symtbl = {} +# One of the options of this test driver is to initialize a test +# symbol table. To make it easy to change the contents of this test +# symbol table, we use the following scheme: -# This test driver makes it easy to add pre-defined symbols of -# your own choosing. The first way is like this ... +# The data below is used to populate an initial symbol table. The +# init code takes care of actually reading this table and populating +# the symbol table for you. So, you just have to maintain this table +# properly and the program will do all the actual initialization work +# for you. -# The data below is used to populate an initial symbol table. You can add or -# change things here without modifying any of the following code. -# Each symbol has an entry which is a list with the following items: + +# Each symbol has an entry in the form of a Python list with the +# following items/order: # # Name, Value, Writeable, Type, Default, LegalVals, Min, Max # -# Where 'None' appears, the init code just uses the default established -# by the VarDescriptor base class. +# **** NOTE: Where 'None' appears, the init code just uses the +# ***default*** established by the VarDescriptor base class. syms = [ ["int1", 1, True, TYPE_INT, 0, [1, 2, 23], None, None ], @@ -67,18 +68,28 @@ ] -# Another way to add pre-defined symbols is to explicitly load -# them into the symbol table. The example below does this as -# well as demonstrating how to use inheritance to create -# your own types derviced from the tconfpy variable descriptor -# base class. +# We use the exact same scheme for building variable templates -# Here's a way to inherit the base symbol definition from -# the module and then derive a new object type for your -# own convenience +templs = [ ["templb", 1, True, TYPE_BOOL, False, [], None, None ], + ["templc", 4+5j, None, TYPE_COMPLEX, 0-0j, [1-1j, 1+1j], None, None ], + ["templf", 1.0, None, TYPE_FLOAT, 0.5, [3.14, 2.73], None, None ], + ["templi", 1, None, TYPE_INT, 0, [1, 2, 23], None, None ], + ["templs", "stringy", None, None, None, [r'^box$', r'^Bax', r'a+bc'], 3, 8 ] + ] + -# Note the use of 'super()' here to run each constructor in -# the inheritance tree only once. + +##### +# Deriving Your Own Types +##### + +# Here's a way to inherit the base symbol definition from the module +# and then derive a new object type for your own convenience. This is +# a way to set your own defaults, for example. + +# Note the use of 'super()' here to run each constructor in the +# inheritance tree only once. + class mycmplx(VarDescriptor): def __init__(self): @@ -87,16 +98,9 @@ self.Default = 39-4j self.Type = TYPE_COMPLEX -# Instantiate some of these -mc1 = mycmplx() -mc2 = mycmplx() -mc2.Value = 8-3.14159j -mc2.Writeable = False - -# And stuff them into the symbol table -symtbl["MyComplex1"] = mc1 -symtbl["MyComplex2"] = mc2 +# We'll use this below to manually enter additional variables into the +# initial symbol table. #---------------------------------------------------------------------------# @@ -104,33 +108,43 @@ #---------------------------------------------------------------------------# -# Fill in the symbol table with stuff defined in the table above - -for sym in syms: - - # Create and init the descriptor - des = VarDescriptor() - - pos = 1 - for attr in ("Value", "Writeable", "Type", "Default", "LegalVals", "Min", "Max"): - - val = sym[pos] - if val != None: - exec("des." + attr + "=val") - - pos += 1 - - symtbl[sym[0]] = des - - #---------------------------------------------------------------------------# # Utility And Support Functions # #---------------------------------------------------------------------------# -########## +##### +# Build A Symbol Table Using The Data Table Format Defined above +##### + +def BuildSymTbl(syms): + + symtbl ={} + + for sym in syms: + + # Create and init the descriptor + des = VarDescriptor() + + pos = 1 + for attr in ("Value", "Writeable", "Type", "Default", "LegalVals", "Min", "Max"): + + val = sym[pos] + if val != None: + exec("des." + attr + "=val") + + pos += 1 + + symtbl[sym[0]] = des + + return symtbl + +# End of 'BuildSymTbl()' + + +##### # Format and return contents of a symbol table entry -########## +##### def dumpsymbol(val, d): @@ -151,9 +165,9 @@ # End of 'dumpsymbol()' -########## +##### # Routine to dump returned values -########## +##### def dumpreturn(name, data, isdict=False): @@ -181,9 +195,9 @@ #---------------------------------------------------------------------------# -########## +##### # Beginning of test driver -########## +##### files = 1 @@ -191,17 +205,20 @@ if len(sys.argv) < 2: print BANNER - print "Usage: test-tc.py [symtbl] [nonewvar] [limitns] [litvars] [debug] file file ..." + print "Usage: test-tc.py [symtbl] [nonewvars] [template] [temponly] [limitns] [litvars] [debug] file file ..." sys.exit(1) # Process all the requested configuration files, # dumping the what tconfpy returns for each one. +ST = False ALLOWVAR = True -DEBUG = False +TEMPLATE = False +TEMPONLY = False LIMITNS = False LITVARS = False -ST = False +DEBUG = False + for fn in sys.argv[files:]: @@ -211,9 +228,15 @@ if fn == "symtbl": ST = True - elif fn == "nonewvar": + elif fn == "nonewvars": ALLOWVAR = False + elif fn == "template": + TEMPLATE = True + + elif fn == "temponly": + TEMPONLY = True + elif fn == "limitns": LIMITNS = True @@ -231,7 +254,22 @@ st = {} if ST: - st = symtbl + st = BuildSymTbl(syms) + + # Another way to add pre-defined symbols is to explicitly + # load them into the symbol table. We'll the derived + # complex type we created earlier for this. + + mc1 = mycmplx() + mc2 = mycmplx() + + mc2.Value = 8-3.14159j + mc2.Writeable = False + + # And stuff them into the symbol table + + st["MyComplex1"] = mc1 + st["MyComplex2"] = mc2 if LIMITNS: @@ -244,8 +282,21 @@ st["NAMESPACE"] = des + # Support for templating + + # Default is no templates + tl = {} + + if TEMPLATE: + tl = BuildSymTbl(templs) + + + # Call the parser and process the results + retval = ParseConfig(fn, InitialSymTable=st, AllowNewVars=ALLOWVAR, + Templates=tl, + TemplatesOnly=TEMPONLY, LiteralVars=LITVARS, Debug=DEBUG )