#!/usr/bin/env python
# test-tc.py - A Test Driver For The 'tconfpy' Configuration File Parser
# Copyright (c) 2003-2004 TundraWare Inc. All Rights Reserved.
PROGNAME = "tconfpy Test Driver"
RCSID = "$Id: test-tc.py,v 1.131 2004/04/16 05:47:29 tundra Exp $"
VERSION = RCSID.split()[2]
# Copyright Information
CPRT = chr(169)
DATE = "2004"
OWNER = "TundraWare Inc."
RIGHTS = "All Rights Reserved"
COPYRIGHT = "Copyright %s %s %s, %s." % (CPRT, DATE, OWNER, RIGHTS)
PROGINFO = PROGNAME + " " + VERSION
BANNER = "%s\n%s\n%s\n" % (PROGINFO, COPYRIGHT, RCSID)
#---------------------------------------------------------------------------#
# Imports And Other Odds-And-Ends #
#---------------------------------------------------------------------------#
from tconfpy import *
import sys
# Translation table for booleans into equivalent writeable state
TF = {True:"RW", False:"RO"}
#---------------------------------------------------------------------------#
# Build An Initial Symbol Table #
#---------------------------------------------------------------------------#
# 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 = {}
# 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. 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:
#
# Name, Value, Writeable, Type, Default, LegalVals, Min, Max
#
# 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 ],
["int2", 1, True, TYPE_INT, 0, [], 1, 30 ],
["float1", 1.0, None, TYPE_FLOAT, 0.5, [3.14, 2.73], None, None ],
["float2", 1.0, None, TYPE_FLOAT, 0.5, [], -1.2, 0.5 ],
["str1" , "stringy", None, None, None, [r'^box$', r'^Bax', r'a+bc'], 3, 8 ],
["cmplx1", 4+5j, None, TYPE_COMPLEX, 0-0j, [], None, None ],
["cmplx2", 4+5j, None, TYPE_COMPLEX, 0-0j, [1-1j, 1+1j], None, None ],
["bool1", True, None, TYPE_BOOL, None, None, None, None ],
["ro1", "ReadVar", False, None, None, None, None, None ],
]
# 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.
# Here's a way to inherit the base symbol definition from
# the module and then derive a new object type for your
# own convenience
# Note the use of 'super()' here to run each constructor in
# the inheritance tree only once.
class mycmplx(VarDescriptor):
def __init__(self):
super(mycmplx, self).__init__()
self.Value = 2-2j
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
#---------------------------------------------------------------------------#
# Nothing Else Should Need Changing Below Here
#---------------------------------------------------------------------------#
# 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 #
#---------------------------------------------------------------------------#
##########
# Format and return contents of a symbol table entry
##########
def dumpsymbol(val, d):
retval = str(val) + " " * (18 - len(val))
for v, p in ((d.Value, 20),
(TF[d.Writeable], 2),
(str(d.Type).split()[1][1:-2], 7),
(d.Default, 8),
(d.LegalVals, 8),
(d.Min, 8),
(d.Max, 8)):
retval += str(v) + (p - len(str(v)) + 2) * ' '
return retval
# End of 'dumpsymbol()'
##########
# Routine to dump returned values
##########
def dumpreturn(name, data, isdict=False):
print name
print len(name) * '=' + '\n'
items = data
if isdict:
items = data.keys()
items.sort()
for val in items:
if isdict:
print dumpsymbol(val, data[val])
else:
print val
print '\n'
# End of 'dumpreturn()'
#---------------------------------------------------------------------------#
##########
# Beginning of test driver
##########
files = 1
# Make sure we got legit arguments
if len(sys.argv) < 2:
print BANNER
print "Usage: test-tc.py [symtbl] [nonewvar] [limitns] [debug] [litvars] file file ..."
sys.exit(1)
# Process all the requested configuration files,
# dumping the what tconfpy returns for each one.
ALLOWVAR = True
DEBUG = False
LIMITNS = False
LITVARS = False
ST = False
for fn in sys.argv[files:]:
# Handle inline options
if fn == "symtbl":
ST = True
elif fn == "nonewvar":
ALLOWVAR = False
elif fn == "limitns":
LIMITNS = True
elif fn == "litvars":
LITVARS = True
elif fn == "debug":
DEBUG = True
# Everything else presumed to be a configuration file
else:
# The default is no pre-defined symbols
st = {}
if ST:
st = symtbl
if LIMITNS:
# Limit the number of namespaces the user can use
des = VarDescriptor()
des.Value = "NS0" # This is the initial namespace
des.LegalVals = [r"^NS.*", ]
des.Min = 3
des.Max = 8
st["NAMESPACE"] = des
retval = ParseConfig(fn, InitialSymTable=st,
AllowNewVars=ALLOWVAR,
LiteralVars=LITVARS,
Debug=DEBUG
)
if retval.Errors:
print "Errors Were Found In '%s'!" % fn
else:
print "No Errors Found In '%s'!" % fn
print
# Format and display the results
dumpreturn("SYMBOL TABLE", retval.SymTable, isdict=True)
dumpreturn("ERRORS", retval.Errors)
dumpreturn("WARNINGS", retval.Warnings)
if DEBUG:
dumpreturn("DEBUG", retval.Debug)
dumpreturn("LITERAL LINES", retval.Literals)
tundra