Coverage for cogapp\__init_

From 2a711f250fd2e32e488b771e7dbca7aef0e53600 Mon Sep 17 00:00:00 2001 From: Ned Batchelder Date: Fri, 23 Sep 2011 08:23:58 -0400 Subject: Latest sample output. --- doc/sample_html/cogapp___init__.html | 194 +- doc/sample_html/cogapp_cogapp.html | 3002 +++++----- doc/sample_html/cogapp_makefiles.html | 422 +- doc/sample_html/cogapp_test_cogapp.html | 8006 +++++++++++++-------------- doc/sample_html/cogapp_test_makefiles.html | 594 +- doc/sample_html/cogapp_test_whiteutils.html | 574 +- doc/sample_html/cogapp_whiteutils.html | 418 +- doc/sample_html/index.html | 346 +- doc/sample_html/status.dat | 12 +- 9 files changed, 6784 insertions(+), 6784 deletions(-) (limited to 'doc/sample_html') diff --git a/doc/sample_html/cogapp___init__.html b/doc/sample_html/cogapp___init__.html index 86b7680c..67058bfe 100644 --- a/doc/sample_html/cogapp___init__.html +++ b/doc/sample_html/cogapp___init__.html @@ -1,97 +1,97 @@ - - - - - - - - Coverage for cogapp\__init__: 0% - - - - - - - - - - - -

Hot-keys on this page

- r - m - x - p toggle line displays -

- j - k next/prev highlighted chunk -

- 0 (zero) top of page -

- 1 (one) first highlighted chunk -

- -

- - - - - -

- -

""" Cog code generation tool.

http://nedbatchelder.com/code/cog

"""

from cogapp import *

- -

- - - - - + + + + + + + + Coverage for cogapp\__init__: 0% + + + + + + + + + + + +

Hot-keys on this page

+ r + m + x + p toggle line displays +

+ j + k next/prev highlighted chunk +

+ 0 (zero) top of page +

+ 1 (one) first highlighted chunk +

+ +

+ + + + + +

+ +

""" Cog code generation tool.

http://nedbatchelder.com/code/cog

"""

from cogapp import *

+ +

+ + + + + diff --git a/doc/sample_html/cogapp_cogapp.html b/doc/sample_html/cogapp_cogapp.html index 7812c5b0..e80b413a 100644 --- a/doc/sample_html/cogapp_cogapp.html +++ b/doc/sample_html/cogapp_cogapp.html @@ -1,1501 +1,1501 @@ - - - - - - - - Coverage for cogapp\cogapp: 51% - - - - - - - - - - - -

Hot-keys on this page

- r - m - x - p toggle line displays -

- j - k next/prev highlighted chunk -

- 0 (zero) top of page -

- 1 (one) first highlighted chunk -

- -

- - - - - -

- -

""" Cog code generation tool.

http://nedbatchelder.com/code/cog

"""

import copy, getopt, imp, os, re, shlex, string, sys, traceback

from cStringIO import StringIO

# The recommended way to compute md5's changed in Python 2.5

try:

import hashlib

hash_factory = hashlib.md5

except ImportError:

import md5

hash_factory = md5.new

__all__ = ['Cog', 'CogUsageError']

__version__ = '2.2' # History at the end of the file.

usage = """\

cog - generate code with inlined Python code.

cog [OPTIONS] [INFILE | @FILELIST] ...

INFILE is the name of an input file.

FILELIST is the name of a text file containing file names or

other @FILELISTs.

OPTIONS:

-c Checksum the output to protect it against accidental change.

-d Delete the generator code from the output file.

-D name=val Define a global string available to your generator code.

-e Warn if a file has no cog code in it.

-I PATH Add PATH to the list of directories for data files and modules.

-o OUTNAME Write the output to OUTNAME.

-r Replace the input file with the output.

-s STRING Suffix all generated output lines with STRING.

-U Write the output with Unix newlines (only LF line-endings).

-w CMD Use CMD if the output file needs to be made writable.

A %s in the CMD will be filled with the filename.

-x Excise all the generated output without running the generators.

-z The [[[end]]] marker can be omitted, and is assumed at eof.

-v Print the version of cog and exit.

-h Print this help.

"""

# Other package modules

from whiteutils import *

class CogError(Exception):

""" Any exception raised by Cog.

"""

def __init__(self, msg, file='', line=0):

59 if file:

Exception.__init__(self, "%s(%d): %s" % (file, line, msg))

else:

Exception.__init__(self, msg)

class CogUsageError(CogError):

""" An error in usage of command-line arguments in cog.

"""

pass #pragma: no cover

class CogInternalError(CogError):

""" An error in the coding of Cog. Should never happen.

"""

pass #pragma: no cover

class CogGeneratedError(CogError):

""" An error raised by a user's cog generator.

"""

pass #pragma: no cover

class Redirectable:

""" An object with its own stdout and stderr files.

"""

def __init__(self):

self.stdout = sys.stdout

self.stderr = sys.stderr

def setOutput(self, stdout=None, stderr=None):

""" Assign new files for standard out and/or standard error.

"""

88 if stdout:

self.stdout = stdout

89 if stderr:

self.stderr = stderr

class CogGenerator(Redirectable):

""" A generator pulled from a source file.

"""

def __init__(self):

Redirectable.__init__(self)

self.markers = []

self.lines = []

def parseMarker(self, l):

self.markers.append(l)

def parseLine(self, l):

self.lines.append(l.strip('\n'))

def getCode(self):

""" Extract the executable Python code from the generator.

"""

# If the markers and lines all have the same prefix

# (end-of-line comment chars, for example),

# then remove it from all the lines.

prefIn = commonPrefix(self.markers + self.lines)

if prefIn:

self.markers = [ l.replace(prefIn, '', 1) for l in self.markers ]

self.lines = [ l.replace(prefIn, '', 1) for l in self.lines ]

return reindentBlock(self.lines, '')

def evaluate(self, cog, globals, fname='cog generator'):

# figure out the right whitespace prefix for the output

prefOut = whitePrefix(self.markers)

intext = self.getCode()

if not intext:

return ''

# In Python 2.2, the last line has to end in a newline.

intext = "import cog\n" + intext + "\n"

code = compile(intext, str(fname), 'exec')

# Make sure the "cog" module has our state.

cog.cogmodule.msg = self.msg

cog.cogmodule.out = self.out

cog.cogmodule.outl = self.outl

cog.cogmodule.error = self.error

self.outstring = ''

eval(code, globals)

# We need to make sure that the last line in the output

# ends with a newline, or it will be joined to the

# end-output line, ruining cog's idempotency.

if self.outstring and self.outstring[-1] != '\n':

self.outstring += '\n'

return reindentBlock(self.outstring, prefOut)

def msg(self, s):

print >>self.stdout, "Message: "+s

def out(self, sOut='', dedent=False, trimblanklines=False):

""" The cog.out function.

"""

if trimblanklines and ('\n' in sOut):

lines = sOut.split('\n')

if lines[0].strip() == '':

del lines[0]

159 if lines and lines[-1].strip() == '':

del lines[-1]

sOut = '\n'.join(lines)+'\n'

if dedent:

sOut = reindentBlock(sOut)

self.outstring += sOut

def outl(self, sOut='', **kw):

""" The cog.outl function.

"""

self.out(sOut, **kw)

self.out('\n')

def error(self, msg='Error raised by cog generator.'):

""" The cog.error function.

Instead of raising standard python errors, cog generators can use

this function. It will display the error without a scary Python

traceback.

"""

raise CogGeneratedError(msg)

class NumberedFileReader:

""" A decorator for files that counts the readline()'s called.

"""

def __init__(self, f):

self.f = f

self.n = 0

def readline(self):

l = self.f.readline()

if l:

self.n += 1

return l

def linenumber(self):

return self.n

class CogOptions:

""" Options for a run of cog.

"""

def __init__(self):

# Defaults for argument values.

self.args = []

self.includePath = []

self.defines = {}

self.bShowVersion = False

self.sMakeWritableCmd = None

self.bReplace = False

self.bNoGenerate = False

self.sOutputName = None

self.bWarnEmpty = False

self.bHashOutput = False

self.bDeleteCode = False

self.bEofCanBeEnd = False

self.sSuffix = None

self.bNewlines = False

def __cmp__(self, other):

""" Comparison operator for tests to use.

"""

return self.__dict__.__cmp__(other.__dict__)

def clone(self):

""" Make a clone of these options, for further refinement.

"""

return copy.deepcopy(self)

def addToIncludePath(self, dirs):

""" Add directories to the include path.

"""

dirs = dirs.split(os.pathsep)

self.includePath.extend(dirs)

def parseArgs(self, argv):

# Parse the command line arguments.

try:

opts, self.args = getopt.getopt(argv, 'cdD:eI:o:rs:Uvw:xz')

except getopt.error, msg:

raise CogUsageError(msg)

# Handle the command line arguments.

for o, a in opts:

if o == '-c':

self.bHashOutput = True

elif o == '-d':

self.bDeleteCode = True

elif o == '-D':

if a.count('=') < 1:

raise CogUsageError("-D takes a name=value argument")

name, value = a.split('=', 1)

self.defines[name] = value

elif o == '-e':

self.bWarnEmpty = True

elif o == '-I':

self.addToIncludePath(a)

elif o == '-o':

self.sOutputName = a

elif o == '-r':

self.bReplace = True

elif o == '-s':

self.sSuffix = a

elif o == '-U':

self.bNewlines = True

elif o == '-v':

self.bShowVersion = True

elif o == '-w':

self.sMakeWritableCmd = a

elif o == '-x':

self.bNoGenerate = True

elif o == '-z':

self.bEofCanBeEnd = True

else:

# Since getopt.getopt is given a list of possible flags,

# this is an internal error.

raise CogInternalError("Don't understand argument %s" % o)

def validate(self):

""" Does nothing if everything is OK, raises CogError's if it's not.

"""

if self.bReplace and self.bDeleteCode:

raise CogUsageError("Can't use -d with -r (or you would delete all your source!)")

if self.bReplace and self.sOutputName:

raise CogUsageError("Can't use -o with -r (they are opposites)")

class Cog(Redirectable):

""" The Cog engine.

"""

def __init__(self):

Redirectable.__init__(self)

self.sBeginSpec = '[[[cog'

self.sEndSpec = ']]]'

self.sEndOutput = '[[[end]]]'

self.reEndOutput = re.compile(r'\[\[\[end]]](?P<hashsect> *$checksum: (?P<hash>[a-f0-9]+)$)')

self.sEndFormat = '[[[end]]] (checksum: %s)'

self.options = CogOptions()

self.sOutputMode = 'w'

self.installCogModule()

def showWarning(self, msg):

print >>self.stdout, "Warning:", msg

def isBeginSpecLine(self, s):

return string.find(s, self.sBeginSpec) >= 0

def isEndSpecLine(self, s):

return string.find(s, self.sEndSpec) >= 0 and \

not self.isEndOutputLine(s)

def isEndOutputLine(self, s):

return string.find(s, self.sEndOutput) >= 0

def installCogModule(self):

""" Magic mumbo-jumbo so that imported Python modules

can say "import cog" and get our state.

"""

self.cogmodule = imp.new_module('cog')

self.cogmodule.path = []

sys.modules['cog'] = self.cogmodule

def processFile(self, fIn, fOut, fname=None, globals=None):

""" Process an input file object to an output file object.

fIn and fOut can be file objects, or file names.

"""

sFileIn = fname or ''

sFileOut = fname or ''

fInToClose = fOutToClose = None

# Convert filenames to files.

333 if isinstance(fIn, basestring):

# Open the input file.

sFileIn = fIn

fIn = fInToClose = open(fIn, 'r')

337 if isinstance(fOut, basestring):

# Open the output file.

sFileOut = fOut

fOut = fOutToClose = open(fOut, self.sOutputMode)

try:

fIn = NumberedFileReader(fIn)

bSawCog = False

self.cogmodule.inFile = sFileIn

self.cogmodule.outFile = sFileOut

# The globals dict we'll use for this file.

353 if globals is None:

globals = {}

# If there are any global defines, put them in the globals.

globals.update(self.options.defines)

# loop over generator chunks

l = fIn.readline()

while l:

# Find the next spec begin

while l and not self.isBeginSpecLine(l):

361 if self.isEndSpecLine(l):

raise CogError("Unexpected '%s'" % self.sEndSpec,

file=sFileIn, line=fIn.linenumber())

364 if self.isEndOutputLine(l):

raise CogError("Unexpected '%s'" % self.sEndOutput,

file=sFileIn, line=fIn.linenumber())

fOut.write(l)

l = fIn.readline()

if not l:

break

374 if not self.options.bDeleteCode:

fOut.write(l)

# l is the begin spec

gen = CogGenerator()

gen.setOutput(stdout=self.stdout)

gen.parseMarker(l)

firstLineNum = fIn.linenumber()

self.cogmodule.firstLineNum = firstLineNum

# If the spec begin is also a spec end, then process the single

# line of code inside.

if self.isEndSpecLine(l):

beg = string.find(l, self.sBeginSpec)

end = string.find(l, self.sEndSpec)

if beg > end:

raise CogError("Cog code markers inverted",

file=sFileIn, line=firstLineNum)

else:

sCode = l[beg+len(self.sBeginSpec):end].strip()

gen.parseLine(sCode)

else:

# Deal with an ordinary code block.

l = fIn.readline()

# Get all the lines in the spec

while l and not self.isEndSpecLine(l):

398 if self.isBeginSpecLine(l):

raise CogError("Unexpected '%s'" % self.sBeginSpec,

file=sFileIn, line=fIn.linenumber())

401 if self.isEndOutputLine(l):

raise CogError("Unexpected '%s'" % self.sEndOutput,

file=sFileIn, line=fIn.linenumber())

405 if not self.options.bDeleteCode:

fOut.write(l)

gen.parseLine(l)

l = fIn.readline()

408 if not l:

raise CogError(

"Cog block begun but never ended.",

file=sFileIn, line=firstLineNum)

414 if not self.options.bDeleteCode:

fOut.write(l)

gen.parseMarker(l)

l = fIn.readline()

# Eat all the lines in the output section. While reading past

# them, compute the md5 hash of the old output.

hasher = hash_factory()

while l and not self.isEndOutputLine(l):

423 if self.isBeginSpecLine(l):

raise CogError("Unexpected '%s'" % self.sBeginSpec,

file=sFileIn, line=fIn.linenumber())

426 if self.isEndSpecLine(l):

raise CogError("Unexpected '%s'" % self.sEndSpec,

file=sFileIn, line=fIn.linenumber())

hasher.update(l)

l = fIn.readline()

curHash = hasher.hexdigest()

434 if not l and not self.options.bEofCanBeEnd:

# We reached end of file before we found the end output line.

raise CogError("Missing '%s' before end of file." % self.sEndOutput,

file=sFileIn, line=fIn.linenumber())

# Write the output of the spec to be the new output if we're

# supposed to generate code.

hasher = hash_factory()

446 if not self.options.bNoGenerate:

sFile = "%s+%d" % (sFileIn, firstLineNum)

sGen = gen.evaluate(cog=self, globals=globals, fname=sFile)

sGen = self.suffixLines(sGen)

hasher.update(sGen)

fOut.write(sGen)

newHash = hasher.hexdigest()

bSawCog = True

# Write the ending output line

hashMatch = self.reEndOutput.search(l)

453 if self.options.bHashOutput:

if hashMatch:

oldHash = hashMatch.groupdict()['hash']

if oldHash != curHash:

raise CogError("Output has been edited! Delete old checksum to unprotect.",

file=sFileIn, line=fIn.linenumber())

# Create a new end line with the correct hash.

endpieces = l.split(hashMatch.group(0), 1)

else:

# There was no old hash, but we want a new hash.

endpieces = l.split(self.sEndOutput, 1)

l = (self.sEndFormat % newHash).join(endpieces)

else:

# We don't want hashes output, so if there was one, get rid of

# it.

468 if hashMatch:

l = l.replace(hashMatch.groupdict()['hashsect'], '', 1)

472 if not self.options.bDeleteCode:

fOut.write(l)

l = fIn.readline()

475 if not bSawCog and self.options.bWarnEmpty:

self.showWarning("no cog code found in %s" % sFileIn)

finally:

478 if fInToClose:

fInToClose.close()

480 if fOutToClose:

fOutToClose.close()

# A regex for non-empty lines, used by suffixLines.

reNonEmptyLines = re.compile("^\s*\S+.*$", re.MULTILINE)

def suffixLines(self, text):

""" Add suffixes to the lines in text, if our options desire it.

text is many lines, as a single string.

"""

492 if self.options.sSuffix:

# Find all non-blank lines, and add the suffix to the end.

repl = r"\g<0>" + self.options.sSuffix.replace('\\', '\\\\')

text = self.reNonEmptyLines.sub(repl, text)

return text

def processString(self, sInput, fname=None):

""" Process sInput as the text to cog.

Return the cogged output as a string.

"""

fOld = StringIO(sInput)

fNew = StringIO()

self.processFile(fOld, fNew, fname=fname)

return fNew.getvalue()

def replaceFile(self, sOldPath, sNewText):

""" Replace file sOldPath with the contents sNewText

"""

if not os.access(sOldPath, os.W_OK):

# Need to ensure we can write.

if self.options.sMakeWritableCmd:

# Use an external command to make the file writable.

cmd = self.options.sMakeWritableCmd.replace('%s', sOldPath)

self.stdout.write(os.popen(cmd).read())

if not os.access(sOldPath, os.W_OK):

raise CogError("Couldn't make %s writable" % sOldPath)

else:

# Can't write!

raise CogError("Can't overwrite %s" % sOldPath)

f = open(sOldPath, self.sOutputMode)

f.write(sNewText)

f.close()

def saveIncludePath(self):

self.savedInclude = self.options.includePath[:]

self.savedSysPath = sys.path[:]

def restoreIncludePath(self):

self.options.includePath = self.savedInclude

self.cogmodule.path = self.options.includePath

sys.path = self.savedSysPath

def addToIncludePath(self, includePath):

self.cogmodule.path.extend(includePath)

sys.path.extend(includePath)

def processOneFile(self, sFile):

""" Process one filename through cog.

"""

self.saveIncludePath()

try:

self.addToIncludePath(self.options.includePath)

# Since we know where the input file came from,

# push its directory onto the include path.

self.addToIncludePath([os.path.dirname(sFile)])

# Set the file output mode based on whether we want \n or native

# line endings.

self.sOutputMode = 'w'

if self.options.bNewlines:

self.sOutputMode = 'wb'

# How we process the file depends on where the output is going.

if self.options.sOutputName:

self.processFile(sFile, self.options.sOutputName, sFile)

elif self.options.bReplace:

# We want to replace the cog file with the output,

# but only if they differ.

print >>self.stdout, "Cogging %s" % sFile,

bNeedNewline = True

try:

fOldFile = open(sFile)

sOldText = fOldFile.read()

fOldFile.close()

sNewText = self.processString(sOldText, fname=sFile)

if sOldText != sNewText:

print >>self.stdout, " (changed)"

bNeedNewline = False

self.replaceFile(sFile, sNewText)

finally:

# The try-finally block is so we can print a partial line

# with the name of the file, and print (changed) on the

# same line, but also make sure to break the line before

# any traceback.

if bNeedNewline:

print >>self.stdout

else:

self.processFile(sFile, self.stdout, sFile)

finally:

self.restoreIncludePath()

def processFileList(self, sFileList):

""" Process the files in a file list.

"""

flist = open(sFileList)

lines = flist.readlines()

flist.close()

for l in lines:

# Use shlex to parse the line like a shell.

lex = shlex.shlex(l, posix=True)

lex.whitespace_split = True

lex.commenters = '#'

# No escapes, so that backslash can be part of the path

lex.escape = ''

args = list(lex)

if args:

self.processArguments(args)

def processArguments(self, args):

""" Process one command-line.

"""

saved_options = self.options

self.options = self.options.clone()

self.options.parseArgs(args[1:])

self.options.validate()

if args[0][0] == '@':

if self.options.sOutputName:

raise CogUsageError("Can't use -o with @file")

self.processFileList(args[0][1:])

else:

self.processOneFile(args[0])

self.options = saved_options

def callableMain(self, argv):

""" All of command-line cog, but in a callable form.

This is used by main.

argv is the equivalent of sys.argv.

"""

argv0 = argv.pop(0)

# Provide help if asked for anywhere in the command line.

if '-?' in argv or '-h' in argv:

print >>self.stderr, usage,

return

self.options.parseArgs(argv)

self.options.validate()

if self.options.bShowVersion:

print >>self.stdout, "Cog version %s" % __version__

return

if self.options.args:

for a in self.options.args:

self.processArguments([a])

else:

raise CogUsageError("No files to process")

def main(self, argv):

""" Handle the command-line execution for cog.

"""

try:

self.callableMain(argv)

return 0

except CogUsageError, err:

print >>self.stderr, err

print >>self.stderr, "(for help use -?)"

return 2

except CogGeneratedError, err:

print >>self.stderr, "Error: %s" % err

return 3

except CogError, err:

print >>self.stderr, err

return 1

except:

traceback.print_exc(None, self.stderr)

return 1

# History:

# 20040210: First public version.

# 20040220: Text preceding the start and end marker are removed from Python lines.

# -v option on the command line shows the version.

# 20040311: Make sure the last line of output is properly ended with a newline.

# 20040605: Fixed some blank line handling in cog.

# Fixed problems with assigning to xml elements in handyxml.

# 20040621: Changed all line-ends to LF from CRLF.

# 20041002: Refactor some option handling to simplify unittesting the options.

# 20041118: cog.out and cog.outl have optional string arguments.

# 20041119: File names weren't being properly passed around for warnings, etc.

# 20041122: Added cog.firstLineNum: a property with the line number of the [[[cog line.

# Added cog.inFile and cog.outFile: the names of the input and output file.

# 20041218: Single-line cog generators, with start marker and end marker on

# the same line.

# 20041230: Keep a single globals dict for all the code fragments in a single

# file so they can share state.

# 20050206: Added the -x switch to remove all generated output.

# 20050218: Now code can be on the marker lines as well.

# 20050219: Added -c switch to checksum the output so that edits can be

# detected before they are obliterated.

# 20050521: Added cog.error, contributed by Alexander Belchenko.

# 20050720: Added code deletion and settable globals contributed by Blake Winton.

# 20050724: Many tweaks to improve code coverage.

# 20050726: Error messages are now printed with no traceback.

# Code can no longer appear on the marker lines,

# except for single-line style.

# -z allows omission of the [[[end]]] marker, and it will be assumed

# at the end of the file.

# 20050729: Refactor option parsing into a separate class, in preparation for

# future features.

# 20050805: The cogmodule.path wasn't being properly maintained.

# 20050808: Added the -D option to define a global value.

# 20050810: The %s in the -w command is dealt with more robustly.

# Added the -s option to suffix output lines with a marker.

# 20050817: Now @files can have arguments on each line to change the cog's

# behavior for that line.

# 20051006: Version 2.0

# 20080521: -U options lets you create Unix newlines on Windows. Thanks,

# Alexander Belchenko.

# 20080522: It's now ok to have -d with output to stdout, and now we validate

# the args after each line of an @file.

# 20090520: Use hashlib where it's available, to avoid a warning.

# Use the builtin compile() instead of compiler, for Jython.

# Explicitly close files we opened, Jython likes this.

- -

- - - - - + + + + + + + + Coverage for cogapp\cogapp: 64% + + + + + + + + + + + +

Hot-keys on this page

+ r + m + x + p toggle line displays +

+ j + k next/prev highlighted chunk +

+ 0 (zero) top of page +

+ 1 (one) first highlighted chunk +

+ +

+ + + + + +

+ +

""" Cog code generation tool.

http://nedbatchelder.com/code/cog

"""

import copy, getopt, imp, os, re, shlex, string, sys, traceback

from cStringIO import StringIO

# The recommended way to compute md5's changed in Python 2.5

try:

import hashlib

hash_factory = hashlib.md5

except ImportError:

import md5

hash_factory = md5.new

__all__ = ['Cog', 'CogUsageError']

__version__ = '2.2' # History at the end of the file.

usage = """\

cog - generate code with inlined Python code.

cog [OPTIONS] [INFILE | @FILELIST] ...

INFILE is the name of an input file.

FILELIST is the name of a text file containing file names or

other @FILELISTs.

OPTIONS:

-c Checksum the output to protect it against accidental change.

-d Delete the generator code from the output file.

-D name=val Define a global string available to your generator code.

-e Warn if a file has no cog code in it.

-I PATH Add PATH to the list of directories for data files and modules.

-o OUTNAME Write the output to OUTNAME.

-r Replace the input file with the output.

-s STRING Suffix all generated output lines with STRING.

-U Write the output with Unix newlines (only LF line-endings).

-w CMD Use CMD if the output file needs to be made writable.

A %s in the CMD will be filled with the filename.

-x Excise all the generated output without running the generators.

-z The [[[end]]] marker can be omitted, and is assumed at eof.

-v Print the version of cog and exit.

-h Print this help.

"""

# Other package modules

from whiteutils import *

class CogError(Exception):

""" Any exception raised by Cog.

"""

def __init__(self, msg, file='', line=0):

59 if file:

Exception.__init__(self, "%s(%d): %s" % (file, line, msg))

else:

Exception.__init__(self, msg)

class CogUsageError(CogError):

""" An error in usage of command-line arguments in cog.

"""

pass #pragma: no cover

class CogInternalError(CogError):

""" An error in the coding of Cog. Should never happen.

"""

pass #pragma: no cover

class CogGeneratedError(CogError):

""" An error raised by a user's cog generator.

"""

pass #pragma: no cover

class Redirectable:

""" An object with its own stdout and stderr files.

"""

def __init__(self):

self.stdout = sys.stdout

self.stderr = sys.stderr

def setOutput(self, stdout=None, stderr=None):

""" Assign new files for standard out and/or standard error.

"""

88 if stdout:

self.stdout = stdout

89 if stderr:

self.stderr = stderr

class CogGenerator(Redirectable):

""" A generator pulled from a source file.

"""

def __init__(self):

Redirectable.__init__(self)

self.markers = []

self.lines = []

def parseMarker(self, l):

self.markers.append(l)

def parseLine(self, l):

self.lines.append(l.strip('\n'))

def getCode(self):

""" Extract the executable Python code from the generator.

"""

# If the markers and lines all have the same prefix

# (end-of-line comment chars, for example),

# then remove it from all the lines.

prefIn = commonPrefix(self.markers + self.lines)

if prefIn:

self.markers = [ l.replace(prefIn, '', 1) for l in self.markers ]

self.lines = [ l.replace(prefIn, '', 1) for l in self.lines ]

return reindentBlock(self.lines, '')

def evaluate(self, cog, globals, fname='cog generator'):

# figure out the right whitespace prefix for the output

prefOut = whitePrefix(self.markers)

intext = self.getCode()

if not intext:

return ''

# In Python 2.2, the last line has to end in a newline.

intext = "import cog\n" + intext + "\n"

code = compile(intext, str(fname), 'exec')

# Make sure the "cog" module has our state.

cog.cogmodule.msg = self.msg

cog.cogmodule.out = self.out

cog.cogmodule.outl = self.outl

cog.cogmodule.error = self.error

self.outstring = ''

eval(code, globals)

# We need to make sure that the last line in the output

# ends with a newline, or it will be joined to the

# end-output line, ruining cog's idempotency.

if self.outstring and self.outstring[-1] != '\n':

self.outstring += '\n'

return reindentBlock(self.outstring, prefOut)

def msg(self, s):

print >>self.stdout, "Message: "+s

def out(self, sOut='', dedent=False, trimblanklines=False):

""" The cog.out function.

"""

if trimblanklines and ('\n' in sOut):

lines = sOut.split('\n')

if lines[0].strip() == '':

del lines[0]

159 if lines and lines[-1].strip() == '':

del lines[-1]

sOut = '\n'.join(lines)+'\n'

if dedent:

sOut = reindentBlock(sOut)

self.outstring += sOut

def outl(self, sOut='', **kw):

""" The cog.outl function.

"""

self.out(sOut, **kw)

self.out('\n')

def error(self, msg='Error raised by cog generator.'):

""" The cog.error function.

Instead of raising standard python errors, cog generators can use

this function. It will display the error without a scary Python

traceback.

"""

raise CogGeneratedError(msg)

class NumberedFileReader:

""" A decorator for files that counts the readline()'s called.

"""

def __init__(self, f):

self.f = f

self.n = 0

def readline(self):

l = self.f.readline()

if l:

self.n += 1

return l

def linenumber(self):

return self.n

class CogOptions:

""" Options for a run of cog.

"""

def __init__(self):

# Defaults for argument values.

self.args = []

self.includePath = []

self.defines = {}

self.bShowVersion = False

self.sMakeWritableCmd = None

self.bReplace = False

self.bNoGenerate = False

self.sOutputName = None

self.bWarnEmpty = False

self.bHashOutput = False

self.bDeleteCode = False

self.bEofCanBeEnd = False

self.sSuffix = None

self.bNewlines = False

def __cmp__(self, other):

""" Comparison operator for tests to use.

"""

return self.__dict__.__cmp__(other.__dict__)

def clone(self):

""" Make a clone of these options, for further refinement.

"""

return copy.deepcopy(self)

def addToIncludePath(self, dirs):

""" Add directories to the include path.

"""

dirs = dirs.split(os.pathsep)

self.includePath.extend(dirs)

def parseArgs(self, argv):

# Parse the command line arguments.

try:

opts, self.args = getopt.getopt(argv, 'cdD:eI:o:rs:Uvw:xz')

except getopt.error, msg:

raise CogUsageError(msg)

# Handle the command line arguments.

for o, a in opts:

if o == '-c':

self.bHashOutput = True

elif o == '-d':

self.bDeleteCode = True

elif o == '-D':

if a.count('=') < 1:

raise CogUsageError("-D takes a name=value argument")

name, value = a.split('=', 1)

self.defines[name] = value

elif o == '-e':

self.bWarnEmpty = True

elif o == '-I':

self.addToIncludePath(a)

elif o == '-o':

self.sOutputName = a

elif o == '-r':

self.bReplace = True

elif o == '-s':

self.sSuffix = a

elif o == '-U':

self.bNewlines = True

elif o == '-v':

self.bShowVersion = True

elif o == '-w':

self.sMakeWritableCmd = a

elif o == '-x':

self.bNoGenerate = True

elif o == '-z':

self.bEofCanBeEnd = True

else:

# Since getopt.getopt is given a list of possible flags,

# this is an internal error.

raise CogInternalError("Don't understand argument %s" % o)

def validate(self):

""" Does nothing if everything is OK, raises CogError's if it's not.

"""

if self.bReplace and self.bDeleteCode:

raise CogUsageError("Can't use -d with -r (or you would delete all your source!)")

if self.bReplace and self.sOutputName:

raise CogUsageError("Can't use -o with -r (they are opposites)")

class Cog(Redirectable):

""" The Cog engine.

"""

def __init__(self):

Redirectable.__init__(self)

self.sBeginSpec = '[[[cog'

self.sEndSpec = ']]]'

self.sEndOutput = '[[[end]]]'

self.reEndOutput = re.compile(r'\[\[\[end]]](?P<hashsect> *$checksum: (?P<hash>[a-f0-9]+)$)')

self.sEndFormat = '[[[end]]] (checksum: %s)'

self.options = CogOptions()

self.sOutputMode = 'w'

self.installCogModule()

def showWarning(self, msg):

print >>self.stdout, "Warning:", msg

def isBeginSpecLine(self, s):

return string.find(s, self.sBeginSpec) >= 0

def isEndSpecLine(self, s):

return string.find(s, self.sEndSpec) >= 0 and \

not self.isEndOutputLine(s)

def isEndOutputLine(self, s):

return string.find(s, self.sEndOutput) >= 0

def installCogModule(self):

""" Magic mumbo-jumbo so that imported Python modules

can say "import cog" and get our state.

"""

self.cogmodule = imp.new_module('cog')

self.cogmodule.path = []

sys.modules['cog'] = self.cogmodule

def processFile(self, fIn, fOut, fname=None, globals=None):

""" Process an input file object to an output file object.

fIn and fOut can be file objects, or file names.

"""

sFileIn = fname or ''

sFileOut = fname or ''

fInToClose = fOutToClose = None

# Convert filenames to files.

333 if isinstance(fIn, basestring):

# Open the input file.

sFileIn = fIn

fIn = fInToClose = open(fIn, 'r')

337 if isinstance(fOut, basestring):

# Open the output file.

sFileOut = fOut

fOut = fOutToClose = open(fOut, self.sOutputMode)

try:

fIn = NumberedFileReader(fIn)

bSawCog = False

self.cogmodule.inFile = sFileIn

self.cogmodule.outFile = sFileOut

# The globals dict we'll use for this file.

353 if globals is None:

globals = {}

# If there are any global defines, put them in the globals.

globals.update(self.options.defines)

# loop over generator chunks

l = fIn.readline()

while l:

# Find the next spec begin

while l and not self.isBeginSpecLine(l):

361 if self.isEndSpecLine(l):

raise CogError("Unexpected '%s'" % self.sEndSpec,

file=sFileIn, line=fIn.linenumber())

364 if self.isEndOutputLine(l):

raise CogError("Unexpected '%s'" % self.sEndOutput,

file=sFileIn, line=fIn.linenumber())

fOut.write(l)

l = fIn.readline()

if not l:

break

374 if not self.options.bDeleteCode:

fOut.write(l)

# l is the begin spec

gen = CogGenerator()

gen.setOutput(stdout=self.stdout)

gen.parseMarker(l)

firstLineNum = fIn.linenumber()

self.cogmodule.firstLineNum = firstLineNum

# If the spec begin is also a spec end, then process the single

# line of code inside.

if self.isEndSpecLine(l):

beg = string.find(l, self.sBeginSpec)

end = string.find(l, self.sEndSpec)

if beg > end:

raise CogError("Cog code markers inverted",

file=sFileIn, line=firstLineNum)

else:

sCode = l[beg+len(self.sBeginSpec):end].strip()

gen.parseLine(sCode)

else:

# Deal with an ordinary code block.

l = fIn.readline()

# Get all the lines in the spec

while l and not self.isEndSpecLine(l):

398 if self.isBeginSpecLine(l):

raise CogError("Unexpected '%s'" % self.sBeginSpec,

file=sFileIn, line=fIn.linenumber())

401 if self.isEndOutputLine(l):

raise CogError("Unexpected '%s'" % self.sEndOutput,

file=sFileIn, line=fIn.linenumber())

405 if not self.options.bDeleteCode:

fOut.write(l)

gen.parseLine(l)

l = fIn.readline()

408 if not l:

raise CogError(

"Cog block begun but never ended.",

file=sFileIn, line=firstLineNum)

414 if not self.options.bDeleteCode:

fOut.write(l)

gen.parseMarker(l)

l = fIn.readline()

# Eat all the lines in the output section. While reading past

# them, compute the md5 hash of the old output.

hasher = hash_factory()

while l and not self.isEndOutputLine(l):

423 if self.isBeginSpecLine(l):

raise CogError("Unexpected '%s'" % self.sBeginSpec,

file=sFileIn, line=fIn.linenumber())

426 if self.isEndSpecLine(l):

raise CogError("Unexpected '%s'" % self.sEndSpec,

file=sFileIn, line=fIn.linenumber())

hasher.update(l)

l = fIn.readline()

curHash = hasher.hexdigest()

434 if not l and not self.options.bEofCanBeEnd:

# We reached end of file before we found the end output line.

raise CogError("Missing '%s' before end of file." % self.sEndOutput,

file=sFileIn, line=fIn.linenumber())

# Write the output of the spec to be the new output if we're

# supposed to generate code.

hasher = hash_factory()

446 if not self.options.bNoGenerate:

sFile = "%s+%d" % (sFileIn, firstLineNum)

sGen = gen.evaluate(cog=self, globals=globals, fname=sFile)

sGen = self.suffixLines(sGen)

hasher.update(sGen)

fOut.write(sGen)

newHash = hasher.hexdigest()

bSawCog = True

# Write the ending output line

hashMatch = self.reEndOutput.search(l)

453 if self.options.bHashOutput:

if hashMatch:

oldHash = hashMatch.groupdict()['hash']

if oldHash != curHash:

raise CogError("Output has been edited! Delete old checksum to unprotect.",

file=sFileIn, line=fIn.linenumber())

# Create a new end line with the correct hash.

endpieces = l.split(hashMatch.group(0), 1)

else:

# There was no old hash, but we want a new hash.

endpieces = l.split(self.sEndOutput, 1)

l = (self.sEndFormat % newHash).join(endpieces)

else:

# We don't want hashes output, so if there was one, get rid of

# it.

468 if hashMatch:

l = l.replace(hashMatch.groupdict()['hashsect'], '', 1)

472 if not self.options.bDeleteCode:

fOut.write(l)

l = fIn.readline()

475 if not bSawCog and self.options.bWarnEmpty:

self.showWarning("no cog code found in %s" % sFileIn)

finally:

478 if fInToClose:

fInToClose.close()

480 if fOutToClose:

fOutToClose.close()

# A regex for non-empty lines, used by suffixLines.

reNonEmptyLines = re.compile("^\s*\S+.*$", re.MULTILINE)

def suffixLines(self, text):

""" Add suffixes to the lines in text, if our options desire it.

text is many lines, as a single string.

"""

492 if self.options.sSuffix:

# Find all non-blank lines, and add the suffix to the end.

repl = r"\g<0>" + self.options.sSuffix.replace('\\', '\\\\')

text = self.reNonEmptyLines.sub(repl, text)

return text

def processString(self, sInput, fname=None):

""" Process sInput as the text to cog.

Return the cogged output as a string.

"""

fOld = StringIO(sInput)

fNew = StringIO()

self.processFile(fOld, fNew, fname=fname)

return fNew.getvalue()

def replaceFile(self, sOldPath, sNewText):

""" Replace file sOldPath with the contents sNewText

"""

if not os.access(sOldPath, os.W_OK):

# Need to ensure we can write.

if self.options.sMakeWritableCmd:

# Use an external command to make the file writable.

cmd = self.options.sMakeWritableCmd.replace('%s', sOldPath)

self.stdout.write(os.popen(cmd).read())

if not os.access(sOldPath, os.W_OK):

raise CogError("Couldn't make %s writable" % sOldPath)

else:

# Can't write!

raise CogError("Can't overwrite %s" % sOldPath)

f = open(sOldPath, self.sOutputMode)

f.write(sNewText)

f.close()

def saveIncludePath(self):

self.savedInclude = self.options.includePath[:]

self.savedSysPath = sys.path[:]

def restoreIncludePath(self):

self.options.includePath = self.savedInclude

self.cogmodule.path = self.options.includePath

sys.path = self.savedSysPath

def addToIncludePath(self, includePath):

self.cogmodule.path.extend(includePath)

sys.path.extend(includePath)

def processOneFile(self, sFile):

""" Process one filename through cog.

"""

self.saveIncludePath()

try:

self.addToIncludePath(self.options.includePath)

# Since we know where the input file came from,

# push its directory onto the include path.

self.addToIncludePath([os.path.dirname(sFile)])

# Set the file output mode based on whether we want \n or native

# line endings.

self.sOutputMode = 'w'

if self.options.bNewlines:

self.sOutputMode = 'wb'

# How we process the file depends on where the output is going.

if self.options.sOutputName:

self.processFile(sFile, self.options.sOutputName, sFile)

elif self.options.bReplace:

# We want to replace the cog file with the output,

# but only if they differ.

print >>self.stdout, "Cogging %s" % sFile,

bNeedNewline = True

try:

fOldFile = open(sFile)

sOldText = fOldFile.read()

fOldFile.close()

sNewText = self.processString(sOldText, fname=sFile)

if sOldText != sNewText:

print >>self.stdout, " (changed)"

bNeedNewline = False

self.replaceFile(sFile, sNewText)

finally:

# The try-finally block is so we can print a partial line

# with the name of the file, and print (changed) on the

# same line, but also make sure to break the line before

# any traceback.

if bNeedNewline:

print >>self.stdout

else:

self.processFile(sFile, self.stdout, sFile)

finally:

self.restoreIncludePath()

def processFileList(self, sFileList):

""" Process the files in a file list.

"""

flist = open(sFileList)

lines = flist.readlines()

flist.close()

for l in lines:

# Use shlex to parse the line like a shell.

lex = shlex.shlex(l, posix=True)

lex.whitespace_split = True

lex.commenters = '#'

# No escapes, so that backslash can be part of the path

lex.escape = ''

args = list(lex)

if args:

self.processArguments(args)

def processArguments(self, args):

""" Process one command-line.

"""

saved_options = self.options

self.options = self.options.clone()

self.options.parseArgs(args[1:])

self.options.validate()

if args[0][0] == '@':

if self.options.sOutputName:

raise CogUsageError("Can't use -o with @file")

self.processFileList(args[0][1:])

else:

self.processOneFile(args[0])

self.options = saved_options

def callableMain(self, argv):

""" All of command-line cog, but in a callable form.

This is used by main.

argv is the equivalent of sys.argv.

"""

argv0 = argv.pop(0)

# Provide help if asked for anywhere in the command line.

if '-?' in argv or '-h' in argv:

print >>self.stderr, usage,

return

self.options.parseArgs(argv)

self.options.validate()

if self.options.bShowVersion:

print >>self.stdout, "Cog version %s" % __version__

return

if self.options.args:

for a in self.options.args:

self.processArguments([a])

else:

raise CogUsageError("No files to process")

def main(self, argv):

""" Handle the command-line execution for cog.

"""

try:

self.callableMain(argv)

return 0

except CogUsageError, err:

print >>self.stderr, err

print >>self.stderr, "(for help use -?)"

return 2

except CogGeneratedError, err:

print >>self.stderr, "Error: %s" % err

return 3

except CogError, err:

print >>self.stderr, err

return 1

except:

traceback.print_exc(None, self.stderr)

return 1

# History:

# 20040210: First public version.

# 20040220: Text preceding the start and end marker are removed from Python lines.

# -v option on the command line shows the version.

# 20040311: Make sure the last line of output is properly ended with a newline.

# 20040605: Fixed some blank line handling in cog.

# Fixed problems with assigning to xml elements in handyxml.

# 20040621: Changed all line-ends to LF from CRLF.

# 20041002: Refactor some option handling to simplify unittesting the options.

# 20041118: cog.out and cog.outl have optional string arguments.

# 20041119: File names weren't being properly passed around for warnings, etc.

# 20041122: Added cog.firstLineNum: a property with the line number of the [[[cog line.

# Added cog.inFile and cog.outFile: the names of the input and output file.

# 20041218: Single-line cog generators, with start marker and end marker on

# the same line.

# 20041230: Keep a single globals dict for all the code fragments in a single

# file so they can share state.

# 20050206: Added the -x switch to remove all generated output.

# 20050218: Now code can be on the marker lines as well.

# 20050219: Added -c switch to checksum the output so that edits can be

# detected before they are obliterated.

# 20050521: Added cog.error, contributed by Alexander Belchenko.

# 20050720: Added code deletion and settable globals contributed by Blake Winton.

# 20050724: Many tweaks to improve code coverage.

# 20050726: Error messages are now printed with no traceback.

# Code can no longer appear on the marker lines,

# except for single-line style.

# -z allows omission of the [[[end]]] marker, and it will be assumed

# at the end of the file.

# 20050729: Refactor option parsing into a separate class, in preparation for

# future features.

# 20050805: The cogmodule.path wasn't being properly maintained.

# 20050808: Added the -D option to define a global value.

# 20050810: The %s in the -w command is dealt with more robustly.

# Added the -s option to suffix output lines with a marker.

# 20050817: Now @files can have arguments on each line to change the cog's

# behavior for that line.

# 20051006: Version 2.0

# 20080521: -U options lets you create Unix newlines on Windows. Thanks,

# Alexander Belchenko.

# 20080522: It's now ok to have -d with output to stdout, and now we validate

# the args after each line of an @file.

# 20090520: Use hashlib where it's available, to avoid a warning.

# Use the builtin compile() instead of compiler, for Jython.

# Explicitly close files we opened, Jython likes this.

+ +

+ + + + + diff --git a/doc/sample_html/cogapp_makefiles.html b/doc/sample_html/cogapp_makefiles.html index 81e26b1b..fde4f36d 100644 --- a/doc/sample_html/cogapp_makefiles.html +++ b/doc/sample_html/cogapp_makefiles.html @@ -1,211 +1,211 @@ - - - - - - - - Coverage for cogapp\makefiles: 13% - - - - - - - - - - - -

Hot-keys on this page

- r - m - x - p toggle line displays -

- j - k next/prev highlighted chunk -

- 0 (zero) top of page -

- 1 (one) first highlighted chunk -

- -

- - - - - -

- -

""" Dictionary-to-filetree functions, to create test files for testing.

http://nedbatchelder.com/code/cog

"""

import path # Non-standard, from http://www.jorendorff.com/articles/python/path

from whiteutils import reindentBlock

__version__ = '1.0.20040126'

__all__ = ['makeFiles', 'removeFiles']

def makeFiles(d, basedir='.', raw=False):

""" Create files from the dictionary d, in the directory named by dirpath.

"""

dirpath = path.path(basedir)

for name, contents in d.items():

child = dirpath / name

if isinstance(contents, basestring):

mode = 'w'

if raw:

mode = 'wb'

f = open(child, mode)

if not raw:

contents = reindentBlock(contents)

f.write(contents)

f.close()

else:

if not child.exists():

child.mkdir()

makeFiles(contents, child, raw=raw)

def removeFiles(d, basedir='.'):

""" Remove the files created by makeFiles.

Directories are removed if they are empty.

"""

dirpath = path.path(basedir)

for name, contents in d.items():

child = dirpath / name

if isinstance(contents, basestring):

child.remove()

else:

removeFiles(contents, child)

if not child.files() and not child.dirs():

child.rmdir()

if __name__ == '__main__': #pragma: no cover

# Try it a little.

d = {

'test_makefiles': {

'hey.txt': """\

This is hey.txt.

It's very simple.

""",

'subdir': {

'fooey': """\

# Fooey

Kablooey

Ew.

"""

}

makeFiles(d)

- -

- - - - - + + + + + + + + Coverage for cogapp\makefiles: 49% + + + + + + + + + + + +

Hot-keys on this page

+ r + m + x + p toggle line displays +

+ j + k next/prev highlighted chunk +

+ 0 (zero) top of page +

+ 1 (one) first highlighted chunk +

+ +

+ + + + + +

+ +

""" Dictionary-to-filetree functions, to create test files for testing.

http://nedbatchelder.com/code/cog

"""

import path # Non-standard, from http://www.jorendorff.com/articles/python/path

from whiteutils import reindentBlock

__version__ = '1.0.20040126'

__all__ = ['makeFiles', 'removeFiles']

def makeFiles(d, basedir='.', raw=False):

""" Create files from the dictionary d, in the directory named by dirpath.

"""

dirpath = path.path(basedir)

for name, contents in d.items():

child = dirpath / name

if isinstance(contents, basestring):

mode = 'w'

if raw:

mode = 'wb'

f = open(child, mode)

if not raw:

contents = reindentBlock(contents)

f.write(contents)

f.close()

else:

if not child.exists():

child.mkdir()

makeFiles(contents, child, raw=raw)

def removeFiles(d, basedir='.'):

""" Remove the files created by makeFiles.

Directories are removed if they are empty.

"""

dirpath = path.path(basedir)

for name, contents in d.items():

child = dirpath / name

if isinstance(contents, basestring):

child.remove()

else:

removeFiles(contents, child)

if not child.files() and not child.dirs():

child.rmdir()

if __name__ == '__main__': #pragma: no cover

# Try it a little.

d = {

'test_makefiles': {

'hey.txt': """\

This is hey.txt.

It's very simple.

""",

'subdir': {

'fooey': """\

# Fooey

Kablooey

Ew.

"""

}

makeFiles(d)

+ +

+ + + + + diff --git a/doc/sample_html/cogapp_test_cogapp.html b/doc/sample_html/cogapp_test_cogapp.html index 74a37185..0f5d2011 100644 --- a/doc/sample_html/cogapp_test_cogapp.html +++ b/doc/sample_html/cogapp_test_cogapp.html @@ -1,4003 +1,4003 @@ - - - - - - - - Coverage for cogapp\test_cogapp: 33% - - - - - - - - - - - -

Hot-keys on this page

- r - m - x - p toggle line displays -

- j - k next/prev highlighted chunk -

- 0 (zero) top of page -

- 1 (one) first highlighted chunk -

- -

- - - - - -

- -

""" Test cogapp.

http://nedbatchelder.com/code/cog

"""

import unittest

import os, random, re, StringIO, stat, sys, tempfile

import path # Non-standard, from http://www.jorendorff.com/articles/python/path

from cogapp import Cog, CogOptions, CogGenerator

from cogapp import CogError, CogUsageError, CogGeneratedError

from cogapp import usage, __version__

from whiteutils import reindentBlock

from makefiles import *

class TestCase(unittest.TestCase):

""" Base class for all Cog test cases. Adds utility methods I like.

"""

def assertRaisesMsg(self, excClass, msg, callableObj, *args, **kwargs):

""" Just like unittest.TestCase.assertRaises,

but checks that the message is right too.

"""

try:

callableObj(*args, **kwargs)

except excClass, exc:

excMsg = str(exc)

if not msg:

# No message provided: it passes.

return #pragma: no cover

elif excMsg == msg:

# Message provided, and we got the right message: it passes.

return

else: #pragma: no cover

# Message provided, and it didn't match: fail!

raise self.failureException("Right exception, wrong message: got '%s' expected '%s'" % (excMsg, msg))

else: #pragma: no cover

if hasattr(excClass,'__name__'):

excName = excClass.__name__

else:

excName = str(excClass)

raise self.failureException("Expected to raise %s, didn't get an exception at all" % excName)

class CogTestsInMemory(TestCase):

""" Test cases for cogapp.Cog()

"""

def testNoCog(self):

strings = [

'',

' ',

' \t \t \tx',

'hello',

'the cat\nin the\nhat.',

'Horton\n\tHears A\n\t\tWho'

]

for s in strings:

self.assertEqual(Cog().processString(s), s)

def testSimple(self):

infile = """\

Some text.

//[[[cog

import cog

cog.outl("This is line one\\n")

cog.outl("This is line two")

//]]]

gobbledegook.

//[[[end]]]

epilogue.

"""

outfile = """\

Some text.

//[[[cog

import cog

cog.outl("This is line one\\n")

cog.outl("This is line two")

//]]]

This is line one

This is line two

//[[[end]]]

epilogue.

"""

self.assertEqual(Cog().processString(infile), outfile)

def testEmptyCog(self):

# The cog clause can be totally empty. Not sure why you'd want it,

# but it works.

infile = """\

hello

//[[[cog

//]]]

//[[[end]]]

goodbye

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testMultipleCogs(self):

# One file can have many cog chunks, even abutting each other.

infile = """\

//[[[cog

cog.out("chunk1")

//]]]

chunk1

//[[[end]]]

//[[[cog

cog.out("chunk2")

//]]]

chunk2

//[[[end]]]

between chunks

//[[[cog

cog.out("chunk3")

//]]]

chunk3

//[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testTrimBlankLines(self):

infile = """\

//[[[cog

cog.out("This is line one\\n", trimblanklines=True)

cog.out('''

This is line two

''', dedent=True, trimblanklines=True)

cog.outl("This is line three", trimblanklines=True)

//]]]

This is line one

This is line two

This is line three

//[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testTrimEmptyBlankLines(self):

infile = """\

//[[[cog

cog.out("This is line one\\n", trimblanklines=True)

cog.out('''

This is line two

''', dedent=True, trimblanklines=True)

cog.out('', dedent=True, trimblanklines=True)

cog.outl("This is line three", trimblanklines=True)

//]]]

This is line one

This is line two

This is line three

//[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def test22EndOfLine(self):

# In Python 2.2, this cog file was not parsing because the

# last line is indented but didn't end with a newline.

infile = """\

//[[[cog

import cog

for i in range(3):

cog.out("%d\\n" % i)

//]]]

//[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testIndentedCode(self):

infile = """\

first line

[[[cog

import cog

for i in range(3):

cog.out("xx%d\\n" % i)

]]]

xx0

xx1

xx2

[[[end]]]

last line

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testPrefixedCode(self):

infile = """\

--[[[cog

--import cog

--for i in range(3):

-- cog.out("xx%d\\n" % i)

--]]]

xx0

xx1

xx2

--[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testPrefixedIndentedCode(self):

infile = """\

prologue

--[[[cog

-- import cog

-- for i in range(3):

-- cog.out("xy%d\\n" % i)

--]]]

xy0

xy1

xy2

--[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testBogusPrefixMatch(self):

infile = """\

prologue

#[[[cog

import cog

# This comment should not be clobbered by removing the pound sign.

for i in range(3):

cog.out("xy%d\\n" % i)

#]]]

xy0

xy1

xy2

#[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testNoFinalNewline(self):

# If the cog'ed output has no final newline,

# it shouldn't eat up the cog terminator.

infile = """\

prologue

[[[cog

import cog

for i in range(3):

cog.out("%d" % i)

]]]

012

[[[end]]]

epilogue

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testNoOutputAtAll(self):

# If there is absolutely no cog output, that's ok.

infile = """\

prologue

[[[cog

i = 1

]]]

[[[end]]]

epilogue

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testPurelyBlankLine(self):

# If there is a blank line in the cog code with no whitespace

# prefix, that should be OK.

infile = """\

prologue

[[[cog

import sys

cog.out("Hello")

cog.out("There")

]]]

HelloThere

[[[end]]]

epilogue

"""

infile = reindentBlock(infile.replace('$', ''))

self.assertEqual(Cog().processString(infile), infile)

def testEmptyOutl(self):

# Alexander Belchenko suggested the string argument to outl should

# be optional. Does it work?

infile = """\

prologue

[[[cog

cog.outl("x")

cog.outl()

cog.outl("y")

cog.outl(trimblanklines=True)

cog.outl("z")

]]]

[[[end]]]

epilogue

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testFirstLineNum(self):

infile = """\

fooey

[[[cog

cog.outl("started at line number %d" % cog.firstLineNum)

]]]

started at line number 2

[[[end]]]

blah blah

[[[cog

cog.outl("and again at line %d" % cog.firstLineNum)

]]]

and again at line 8

[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testCompactOneLineCode(self):

infile = """\

first line

hey: [[[cog cog.outl("hello %d" % (3*3*3*3)) ]]] looky!

get rid of this!

[[[end]]]

last line

"""

outfile = """\

first line

hey: [[[cog cog.outl("hello %d" % (3*3*3*3)) ]]] looky!

hello 81

[[[end]]]

last line

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), reindentBlock(outfile))

def testInsideOutCompact(self):

infile = """\

first line

hey?: ]]] what is this? [[[cog strange!

get rid of this!

[[[end]]]

last line

"""

self.assertRaisesMsg(CogError,

"infile.txt(2): Cog code markers inverted",

Cog().processString,

reindentBlock(infile), "infile.txt")

def testSharingGlobals(self):

infile = """\

first line

hey: [[[cog s="hey there" ]]] looky!

[[[end]]]

more literal junk.

[[[cog cog.outl(s) ]]]

[[[end]]]

last line

"""

outfile = """\

first line

hey: [[[cog s="hey there" ]]] looky!

[[[end]]]

more literal junk.

[[[cog cog.outl(s) ]]]

hey there

[[[end]]]

last line

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), reindentBlock(outfile))

class CogOptionsTests(TestCase):

""" Test the CogOptions class.

"""

def testEquality(self):

o = CogOptions()

p = CogOptions()

self.assertEqual(o, p)

o.parseArgs(['-r'])

self.assertNotEqual(o, p)

p.parseArgs(['-r'])

self.assertEqual(o, p)

def testCloning(self):

o = CogOptions()

o.parseArgs(['-I', 'fooey', '-I', 'booey', '-s', ' /*x*/'])

p = o.clone()

self.assertEqual(o, p)

p.parseArgs(['-I', 'huey', '-D', 'foo=quux'])

self.assertNotEqual(o, p)

q = CogOptions()

q.parseArgs(['-I', 'fooey', '-I', 'booey', '-s', ' /*x*/', '-I', 'huey', '-D', 'foo=quux'])

self.assertEqual(p, q)

def testCombiningFlags(self):

# Single-character flags can be combined.

o = CogOptions()

o.parseArgs(['-e', '-r', '-z'])

p = CogOptions()

p.parseArgs(['-erz'])

self.assertEqual(o, p)

class FileStructureTests(TestCase):

""" Test cases to check that we're properly strict about the structure

of files.

"""

def isBad(self, infile, msg=None):

infile = reindentBlock(infile)

self.assertRaisesMsg(CogError,

msg,

Cog().processString, (infile), 'infile.txt')

def testBeginNoEnd(self):

infile = """\

Fooey

#[[[cog

cog.outl('hello')

"""

self.isBad(infile, "infile.txt(2): Cog block begun but never ended.")

def testNoEoo(self):

infile = """\

Fooey

#[[[cog

cog.outl('hello')

#]]]

"""

self.isBad(infile, "infile.txt(4): Missing '[[[end]]]' before end of file.")

infile2 = """\

Fooey

#[[[cog

cog.outl('hello')

#]]]

#[[[cog

cog.outl('goodbye')

#]]]

"""

self.isBad(infile2, "infile.txt(5): Unexpected '[[[cog'")

def testStartWithEnd(self):

infile = """\

#]]]

"""

self.isBad(infile, "infile.txt(1): Unexpected ']]]'")

infile2 = """\

#[[[cog

cog.outl('hello')

#]]]

#[[[end]]]

#]]]

"""

self.isBad(infile2, "infile.txt(5): Unexpected ']]]'")

def testStartWithEoo(self):

infile = """\

#[[[end]]]

"""

self.isBad(infile, "infile.txt(1): Unexpected '[[[end]]]'")

infile2 = """\

#[[[cog

cog.outl('hello')

#]]]

#[[[end]]]

"""

self.isBad(infile2, "infile.txt(5): Unexpected '[[[end]]]'")

def testNoEnd(self):

infile = """\

#[[[cog

cog.outl("hello")

#[[[end]]]

"""

self.isBad(infile, "infile.txt(3): Unexpected '[[[end]]]'")

infile2 = """\

#[[[cog

cog.outl('hello')

#]]]

#[[[end]]]

#[[[cog

cog.outl("hello")

#[[[end]]]

"""

self.isBad(infile2, "infile.txt(7): Unexpected '[[[end]]]'")

def testTwoBegins(self):

infile = """\

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

"""

self.isBad(infile, "infile.txt(2): Unexpected '[[[cog'")

infile2 = """\

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

"""

self.isBad(infile2, "infile.txt(6): Unexpected '[[[cog'")

def testTwoEnds(self):

infile = """\

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

"""

self.isBad(infile, "infile.txt(4): Unexpected ']]]'")

infile2 = """\

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

"""

self.isBad(infile2, "infile.txt(8): Unexpected ']]]'")

class CogErrorTests(TestCase):

""" Test cases for cog.error().

"""

def testErrorMsg(self):

infile = """\

[[[cog cog.error("This ain't right!")]]]

[[[end]]]

"""

infile = reindentBlock(infile)

self.assertRaisesMsg(CogGeneratedError,

"This ain't right!",

Cog().processString, (infile))

def testErrorNoMsg(self):

infile = """\

[[[cog cog.error()]]]

[[[end]]]

"""

infile = reindentBlock(infile)

self.assertRaisesMsg(CogGeneratedError,

"Error raised by cog generator.",

Cog().processString, (infile))

def testNoErrorIfErrorNotCalled(self):

infile = """\

--[[[cog

--import cog

--for i in range(3):

-- if i > 10:

-- cog.error("Something is amiss!")

-- cog.out("xx%d\\n" % i)

--]]]

xx0

xx1

xx2

--[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

class CogGeneratorGetCodeTests(TestCase):

""" Unit tests against CogGenerator to see if its getCode() method works

properly.

"""

def setUp(self):

""" All tests get a generator to use, and short same-length names for

the functions we're going to use.

"""

self.gen = CogGenerator()

self.m = self.gen.parseMarker

self.l = self.gen.parseLine

def testEmpty(self):

self.m('// [[[cog')

self.m('// ]]]')

self.assertEqual(self.gen.getCode(), '')

def testSimple(self):

self.m('// [[[cog')

self.l(' print "hello"')

self.l(' print "bye"')

self.m('// ]]]')

self.assertEqual(self.gen.getCode(), 'print "hello"\nprint "bye"')

def testCompressed1(self):

# For a while, I supported compressed code blocks, but no longer.

self.m('// [[[cog: print """')

self.l('// hello')

self.l('// bye')

self.m('// """)]]]')

self.assertEqual(self.gen.getCode(), 'hello\nbye')

def testCompressed2(self):

# For a while, I supported compressed code blocks, but no longer.

self.m('// [[[cog: print """')

self.l('hello')

self.l('bye')

self.m('// """)]]]')

self.assertEqual(self.gen.getCode(), 'hello\nbye')

def testCompressed3(self):

# For a while, I supported compressed code blocks, but no longer.

self.m('// [[[cog')

self.l('print """hello')

self.l('bye')

self.m('// """)]]]')

self.assertEqual(self.gen.getCode(), 'print """hello\nbye')

def testCompressed4(self):

# For a while, I supported compressed code blocks, but no longer.

self.m('// [[[cog: print """')

self.l('hello')

self.l('bye""")')

self.m('// ]]]')

self.assertEqual(self.gen.getCode(), 'hello\nbye""")')

def testNoCommonPrefixForMarkers(self):

# It's important to be able to use #if 0 to hide lines from a

# C++ compiler.

self.m('#if 0 //[[[cog')

self.l('\timport cog, sys')

self.l('')

self.l('\tprint sys.argv')

self.m('#endif //]]]')

self.assertEqual(self.gen.getCode(), 'import cog, sys\n\nprint sys.argv')

class TestCaseWithTempDir(TestCase):

def newCog(self):

""" Initialize the cog members for another run.

"""

# Create a cog engine, and catch its output.

self.cog = Cog()

self.output = StringIO.StringIO()

self.cog.setOutput(stdout=self.output, stderr=self.output)

def setUp(self):

# Create a temporary directory.

self.tempdir = path.path(tempfile.gettempdir()) / ('testcog_tempdir_' + str(random.random())[2:])

self.tempdir.mkdir()

self.olddir = os.getcwd()

os.chdir(self.tempdir)

self.newCog()

def tearDown(self):

os.chdir(self.olddir)

# Get rid of the temporary directory.

self.tempdir.rmtree()

def assertFilesSame(self, sFName1, sFName2):

self.assertEqual((self.tempdir / sFName1).text(), (self.tempdir / sFName2).text())

def assertFileContent(self, sFName, sContent):

sAbsName = self.tempdir / sFName

f = open(sAbsName, 'rb')

try:

sFileContent = f.read()

finally:

f.close()

self.assertEqual(sFileContent, sContent)

class ArgumentHandlingTests(TestCaseWithTempDir):

def testArgumentFailure(self):

# Return value 2 means usage problem.

assert(self.cog.main(['argv0', '-j']) == 2)

output = self.output.getvalue()

assert(output.find("option -j not recognized") >= 0)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0']))

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-j']))

def testNoDashOAndAtFile(self):

d = {

'cogfiles.txt': """\

# Please run cog

"""

}

makeFiles(d)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-o', 'foo', '@cogfiles.txt']))

def testDashV(self):

assert(self.cog.main(['argv0', '-v']) == 0)

output = self.output.getvalue()

self.assertEqual('Cog version %s\n' % __version__, output)

def producesHelp(self, args):

self.newCog()

argv = ['argv0'] + args.split()

assert(self.cog.main(argv) == 0)

self.assertEquals(usage, self.output.getvalue())

def testDashH(self):

# -h or -? anywhere on the command line should just print help.

self.producesHelp("-h")

self.producesHelp("-?")

self.producesHelp("fooey.txt -h")

self.producesHelp("-o -r @fooey.txt -? @booey.txt")

def testDashOAndDashR(self):

d = {

'cogfile.txt': """\

# Please run cog

"""

}

makeFiles(d)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-o', 'foo', '-r', 'cogfile.txt']))

def testDashZ(self):

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

""",

'test.out': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

void DoSomething();

void DoAnotherThing();

void DoLastThing();

""",

}

makeFiles(d)

self.assertRaisesMsg(

CogError, "test.cog(6): Missing '[[[end]]]' before end of file.",

self.cog.callableMain, (['argv0', '-r', 'test.cog']))

self.newCog()

self.cog.callableMain(['argv0', '-r', '-z', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testBadDashD(self):

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-Dfooey', 'cog.txt']))

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-D', 'fooey', 'cog.txt']))

class TestFileHandling(TestCaseWithTempDir):

def testSimple(self):

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

//[[[end]]]

""",

'test.out': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

void DoSomething();

void DoAnotherThing();

void DoLastThing();

//[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

output = self.output.getvalue()

assert(output.find("(changed)") >= 0)

def testOutputFile(self):

# -o sets the output file.

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

//[[[end]]]

""",

'test.out': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

void DoSomething();

void DoAnotherThing();

void DoLastThing();

//[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-o', 'test.cogged', 'test.cog'])

self.assertFilesSame('test.cogged', 'test.out')

def testAtFile(self):

d = {

'one.cog': """\

//[[[cog

cog.outl("hello world")

//]]]

//[[[end]]]

""",

'one.out': """\

//[[[cog

cog.outl("hello world")

//]]]

hello world

//[[[end]]]

""",

'two.cog': """\

//[[[cog

cog.outl("goodbye cruel world")

//]]]

//[[[end]]]

""",

'two.out': """\

//[[[cog

cog.outl("goodbye cruel world")

//]]]

goodbye cruel world

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

one.cog

two.cog

"""

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])

self.assertFilesSame('one.cog', 'one.out')

self.assertFilesSame('two.cog', 'two.out')

output = self.output.getvalue()

assert(output.find("(changed)") >= 0)

def testNestedAtFile(self):

d = {

'one.cog': """\

//[[[cog

cog.outl("hello world")

//]]]

//[[[end]]]

""",

'one.out': """\

//[[[cog

cog.outl("hello world")

//]]]

hello world

//[[[end]]]

""",

'two.cog': """\

//[[[cog

cog.outl("goodbye cruel world")

//]]]

//[[[end]]]

""",

'two.out': """\

//[[[cog

cog.outl("goodbye cruel world")

//]]]

goodbye cruel world

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

one.cog

@cogfiles2.txt

""",

'cogfiles2.txt': """\

# This one too, please.

two.cog

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])

self.assertFilesSame('one.cog', 'one.out')

self.assertFilesSame('two.cog', 'two.out')

output = self.output.getvalue()

assert(output.find("(changed)") >= 0)

def testAtFileWithArgs(self):

d = {

'both.cog': """\

//[[[cog

cog.outl("one: %s" % globals().has_key('one'))

cog.outl("two: %s" % globals().has_key('two'))

//]]]

//[[[end]]]

""",

'one.out': """\

//[[[cog

cog.outl("one: %s" % globals().has_key('one'))

cog.outl("two: %s" % globals().has_key('two'))

//]]]

one: True // ONE

two: False // ONE

//[[[end]]]

""",

'two.out': """\

//[[[cog

cog.outl("one: %s" % globals().has_key('one'))

cog.outl("two: %s" % globals().has_key('two'))

//]]]

one: False // TWO

two: True // TWO

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

both.cog -o both.one -s ' // ONE' -D one=x

both.cog -o both.two -s ' // TWO' -D two=x

"""

}

makeFiles(d)

self.cog.callableMain(['argv0', '@cogfiles.txt'])

self.assertFilesSame('both.one', 'one.out')

self.assertFilesSame('both.two', 'two.out')

def testAtFileWithBadArgCombo(self):

d = {

'both.cog': """\

//[[[cog

cog.outl("one: %s" % globals().has_key('one'))

cog.outl("two: %s" % globals().has_key('two'))

//]]]

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

both.cog

both.cog -d # This is bad: -r and -d

"""

}

makeFiles(d)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-r', '@cogfiles.txt']))

def testAtFileWithTrickyFilenames(self):

d = {

'one 1.cog': """\

//[[[cog cog.outl("hello world") ]]]

""",

'one.out': """\

//[[[cog cog.outl("hello world") ]]]

hello world //xxx

""",

'subdir': {

'subback.cog': """\

//[[[cog cog.outl("down deep with backslashes") ]]]

""",

'subfwd.cog': """\

//[[[cog cog.outl("down deep with slashes") ]]]

""",

'subback.out': """\

//[[[cog cog.outl("down deep with backslashes") ]]]

down deep with backslashes //yyy

""",

'subfwd.out': """\

//[[[cog cog.outl("down deep with slashes") ]]]

down deep with slashes //zzz

""",

'cogfiles.txt': """\

# Please run cog

'one 1.cog' -s ' //xxx'

subdir\subback.cog -s ' //yyy'

subdir/subfwd.cog -s ' //zzz'

"""

}

makeFiles(d)

self.cog.callableMain(['argv0', '-z', '-r', '@cogfiles.txt'])

self.assertFilesSame('one 1.cog', 'one.out')

self.assertFilesSame('subdir/subback.cog', 'subback.out')

self.assertFilesSame('subdir/subfwd.cog', 'subfwd.out')

class CogTestLineEndings(TestCaseWithTempDir):

"""Tests for -U option (force LF line-endings in output)."""

lines_in = ['Some text.',

'//[[[cog',

'cog.outl("Cog text")',

'//]]]',

'gobbledegook.',

'//[[[end]]]',

'epilogue.',

'']

lines_out = ['Some text.',

'//[[[cog',

'cog.outl("Cog text")',

'//]]]',

'Cog text',

'//[[[end]]]',

'epilogue.',

'']

def testOutputNativeEol(self):

makeFiles({'infile': '\n'.join(self.lines_in)})

self.cog.callableMain(['argv0', '-o', 'outfile', 'infile'])

self.assertFileContent('outfile', os.linesep.join(self.lines_out))

def testOutputLfEol(self):

makeFiles({'infile': '\n'.join(self.lines_in)})

self.cog.callableMain(['argv0', '-U', '-o', 'outfile', 'infile'])

self.assertFileContent('outfile', '\n'.join(self.lines_out))

def testReplaceNativeEol(self):

makeFiles({'test.cog': '\n'.join(self.lines_in)})

self.cog.callableMain(['argv0', '-r', 'test.cog'])

self.assertFileContent('test.cog', os.linesep.join(self.lines_out))

def testReplaceLfEol(self):

makeFiles({'test.cog': '\n'.join(self.lines_in)})

self.cog.callableMain(['argv0', '-U', '-r', 'test.cog'])

self.assertFileContent('test.cog', '\n'.join(self.lines_out))

class TestCaseWithImports(TestCaseWithTempDir):

""" When running tests which import modules, the sys.modules list

leaks from one test to the next. This test case class scrubs

the list after each run to keep the tests isolated from each other.

"""

def setUp(self):

TestCaseWithTempDir.setUp(self)

self.sysmodulekeys = list(sys.modules)

def tearDown(self):

modstoscrub = [

modname

for modname in sys.modules

if modname not in self.sysmodulekeys

]

for modname in modstoscrub:

del sys.modules[modname]

TestCaseWithTempDir.tearDown(self)

class CogIncludeTests(TestCaseWithImports):

dincludes = {

'test.cog': """\

//[[[cog

import mymodule

//]]]

//[[[end]]]

""",

'test.out': """\

//[[[cog

import mymodule

//]]]

Hello from mymodule

//[[[end]]]

""",

'test2.out': """\

//[[[cog

import mymodule

//]]]

Hello from mymodule in inc2

//[[[end]]]

""",

'include': {

'mymodule.py': """\

import cog

cog.outl("Hello from mymodule")

"""

'inc2': {

'mymodule.py': """\

import cog

cog.outl("Hello from mymodule in inc2")

"""

'inc3': {

'someothermodule.py': """\

import cog

cog.outl("This is some other module.")

"""

}

def testNeedIncludePath(self):

# Try it without the -I, to see that an ImportError happens.

makeFiles(self.dincludes)

self.assertRaises(ImportError, self.cog.callableMain, (['argv0', '-r', 'test.cog']))

def testIncludePath(self):

# Test that -I adds include directories properly.

makeFiles(self.dincludes)

self.cog.callableMain(['argv0', '-r', '-I', 'include', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testTwoIncludePaths(self):

# Test that two -I's add include directories properly.

makeFiles(self.dincludes)

self.cog.callableMain(['argv0', '-r', '-I', 'include', '-I', 'inc2', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testTwoIncludePaths2(self):

# Test that two -I's add include directories properly.

makeFiles(self.dincludes)

self.cog.callableMain(['argv0', '-r', '-I', 'inc2', '-I', 'include', 'test.cog'])

self.assertFilesSame('test.cog', 'test2.out')

def testUselessIncludePath(self):

# Test that the search will continue past the first directory.

makeFiles(self.dincludes)

self.cog.callableMain(['argv0', '-r', '-I', 'inc3', '-I', 'include', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testSysPathIsUnchanged(self):

d = {

'bad.cog': """\

//[[[cog cog.error("Oh no!") ]]]

//[[[end]]]

""",

'good.cog': """\

//[[[cog cog.outl("Oh yes!") ]]]

//[[[end]]]

""",

}

makeFiles(d)

# Is it unchanged just by creating a cog engine?

oldsyspath = sys.path[:]

self.newCog()

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a successful run?

self.newCog()

self.cog.callableMain(['argv0', '-r', 'good.cog'])

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a successful run with includes?

self.newCog()

self.cog.callableMain(['argv0', '-r', '-I', 'xyzzy', 'good.cog'])

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a successful run with two includes?

self.newCog()

self.cog.callableMain(['argv0', '-r', '-I', 'xyzzy', '-I', 'quux', 'good.cog'])

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a failed run?

self.newCog()

self.assertRaises(CogError, self.cog.callableMain, (['argv0', '-r', 'bad.cog']))

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a failed run with includes?

self.newCog()

self.assertRaises(CogError, self.cog.callableMain, (['argv0', '-r', '-I', 'xyzzy', 'bad.cog']))

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a failed run with two includes?

self.newCog()

self.assertRaises(CogError, self.cog.callableMain, (['argv0', '-r', '-I', 'xyzzy', '-I', 'quux', 'bad.cog']))

self.assertEqual(oldsyspath, sys.path)

def testSubDirectories(self):

# Test that relative paths on the command line work, with includes.

d = {

'code': {

'test.cog': """\

//[[[cog

import mysubmodule

//]]]

//[[[end]]]

""",

'test.out': """\

//[[[cog

import mysubmodule

//]]]

Hello from mysubmodule

//[[[end]]]

""",

'mysubmodule.py': """\

import cog

cog.outl("Hello from mysubmodule")

"""

}

makeFiles(d)

# We should be able to invoke cog without the -I switch, and it will

# auto-include the current directory

self.cog.callableMain(['argv0', '-r', 'code/test.cog'])

self.assertFilesSame('code/test.cog', 'code/test.out')

class CogTestsInFiles(TestCaseWithTempDir):

def testWarnIfNoCogCode(self):

# Test that the -e switch warns if there is no Cog code.

d = {

'with.cog': """\

//[[[cog

cog.outl("hello world")

//]]]

hello world

//[[[end]]]

""",

'without.cog': """\

There's no cog

code in this file.

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-e', 'with.cog'])

output = self.output.getvalue()

assert(output.find("Warning") < 0)

self.newCog()

self.cog.callableMain(['argv0', '-e', 'without.cog'])

output = self.output.getvalue()

assert(output.find("Warning: no cog code found in without.cog") >= 0)

self.newCog()

self.cog.callableMain(['argv0', 'without.cog'])

output = self.output.getvalue()

assert(output.find("Warning") < 0)

def testFileNameProps(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))

//]]]

this is cog1.txt in, cog1.txt out

[[[end]]]

""",

'cog1.out': """\

//[[[cog

cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))

//]]]

This is cog1.txt in, cog1.txt out

[[[end]]]

""",

'cog1out.out': """\

//[[[cog

cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))

//]]]

This is cog1.txt in, cog1out.txt out

[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

self.newCog()

self.cog.callableMain(['argv0', '-o', 'cog1out.txt', 'cog1.txt'])

self.assertFilesSame('cog1out.txt', 'cog1out.out')

def testGlobalsDontCrossFiles(self):

# Make sure that global values don't get shared between files.

d = {

'one.cog': """\

//[[[cog s = "This was set in one.cog" ]]]

//[[[end]]]

//[[[cog cog.outl(s) ]]]

//[[[end]]]

""",

'one.out': """\

//[[[cog s = "This was set in one.cog" ]]]

//[[[end]]]

//[[[cog cog.outl(s) ]]]

This was set in one.cog

//[[[end]]]

""",

'two.cog': """\

//[[[cog

try:

cog.outl(s)

except NameError:

cog.outl("s isn't set!")

//]]]

//[[[end]]]

""",

'two.out': """\

//[[[cog

try:

cog.outl(s)

except NameError:

cog.outl("s isn't set!")

//]]]

s isn't set!

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

one.cog

two.cog

"""

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])

self.assertFilesSame('one.cog', 'one.out')

self.assertFilesSame('two.cog', 'two.out')

output = self.output.getvalue()

assert(output.find("(changed)") >= 0)

def testRemoveGeneratedOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

This line was generated.

//[[[end]]]

This line was not.

""",

'cog1.out': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

//[[[end]]]

This line was not.

""",

'cog1.out2': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

This line was generated.

//[[[end]]]

This line was not.

""",

}

makeFiles(d)

# Remove generated output.

self.cog.callableMain(['argv0', '-r', '-x', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

self.newCog()

# Regenerate the generated output.

self.cog.callableMain(['argv0', '-r', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out2')

self.newCog()

# Remove the generated output again.

self.cog.callableMain(['argv0', '-r', '-x', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

def testMsgCall(self):

infile = """\

#[[[cog

cog.msg("Hello there!")

#]]]

#[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(self.cog.processString(infile), infile)

output = self.output.getvalue()

self.assertEqual(output, "Message: Hello there!\n")

def testErrorMessageHasNoTraceback(self):

# Test that a Cog error is printed to stderr with no traceback.

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

Xhis line was newly

generated by cog

blah blah.

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

}

makeFiles(d)

stderr = StringIO.StringIO()

self.cog.setOutput(stderr=stderr)

self.cog.main(['argv0', '-c', '-r', "cog1.txt"])

output = self.output.getvalue()

self.assertEqual(self.output.getvalue(), "Cogging cog1.txt\n")

self.assertEqual(stderr.getvalue(), "cog1.txt(9): Output has been edited! Delete old checksum to unprotect.\n")

def testDashD(self):

d = {

'test.cog': """\

--[[[cog cog.outl("Defined fooey as " + fooey) ]]]

--[[[end]]]

""",

'test.kablooey': """\

--[[[cog cog.outl("Defined fooey as " + fooey) ]]]

Defined fooey as kablooey

--[[[end]]]

""",

'test.einstein': """\

--[[[cog cog.outl("Defined fooey as " + fooey) ]]]

Defined fooey as e=mc2

--[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-D', 'fooey=kablooey', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dfooey=kablooey', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dfooey=e=mc2', 'test.cog'])

self.assertFilesSame('test.cog', 'test.einstein')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dbar=quux', '-Dfooey=kablooey', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dfooey=kablooey', '-Dbar=quux', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dfooey=gooey', '-Dfooey=kablooey', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

def testOutputToStdout(self):

d = {

'test.cog': """\

--[[[cog cog.outl('Hey there!') ]]]

--[[[end]]]

"""

}

makeFiles(d)

stderr = StringIO.StringIO()

self.cog.setOutput(stderr=stderr)

self.cog.callableMain(['argv0', 'test.cog'])

output = self.output.getvalue()

outerr = stderr.getvalue()

self.assertEqual(output, "--[[[cog cog.outl('Hey there!') ]]]\nHey there!\n--[[[end]]]\n")

self.assertEqual(outerr, "")

def testSuffixOutputLines(self):

d = {

'test.cog': """\

Hey there.

;[[[cog cog.outl('a\\nb\\n \\nc') ]]]

;[[[end]]]

Good bye.

""",

'test.out': """\

Hey there.

;[[[cog cog.outl('a\\nb\\n \\nc') ]]]

a (foo)

b (foo)

c (foo)

;[[[end]]]

Good bye.

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-s', ' (foo)', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testEmptySuffix(self):

d = {

'test.cog': """\

;[[[cog cog.outl('a\\nb\\nc') ]]]

;[[[end]]]

""",

'test.out': """\

;[[[cog cog.outl('a\\nb\\nc') ]]]

;[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-s', '', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testHellishSuffix(self):

d = {

'test.cog': """\

;[[[cog cog.outl('a\\n\\nb') ]]]

""",

'test.out': """\

;[[[cog cog.outl('a\\n\\nb') ]]]

a /\\n*+([)]><

b /\\n*+([)]><

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-z', '-r', '-s', r' /\n*+([)]><', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

class WritabilityTests(TestCaseWithTempDir):

d = {

'test.cog': """\

//[[[cog

for fn in ['DoSomething', 'DoAnotherThing', 'DoLastThing']:

cog.outl("void %s();" % fn)

//]]]

//[[[end]]]

""",

'test.out': """\

//[[[cog

for fn in ['DoSomething', 'DoAnotherThing', 'DoLastThing']:

cog.outl("void %s();" % fn)

//]]]

void DoSomething();

void DoAnotherThing();

void DoLastThing();

//[[[end]]]

""",

}

if os.name == 'nt': # pragma: no cover

# for Windows

cmd_w_args = 'attrib -R %s'

cmd_w_asterisk = 'attrib -R *'

else: # pragma: no cover

# for unix-like

cmd_w_args = 'chmod +w %s'

cmd_w_asterisk = 'chmod +w *'

def setUp(self):

TestCaseWithTempDir.setUp(self)

makeFiles(self.d)

self.testcog = self.tempdir / 'test.cog'

self.testcog.chmod(stat.S_IREAD) # Make the file readonly.

assert not os.access(self.testcog, os.W_OK)

def tearDown(self):

self.testcog.chmod(stat.S_IWRITE) # Make the file writable again.

TestCaseWithTempDir.tearDown(self)

def testReadonlyNoCommand(self):

self.assertRaisesMsg(

CogError, "Can't overwrite test.cog",

self.cog.callableMain, (['argv0', '-r', 'test.cog']))

assert not os.access(self.testcog, os.W_OK)

def testReadonlyWithCommand(self):

self.cog.callableMain(['argv0', '-r', '-w', self.cmd_w_args, 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

assert os.access(self.testcog, os.W_OK)

def testReadonlyWithCommandWithNoSlot(self):

self.cog.callableMain(['argv0', '-r', '-w', self.cmd_w_asterisk, 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

assert os.access(self.testcog, os.W_OK)

def testReadonlyWithIneffectualCommand(self):

self.assertRaisesMsg(

CogError, "Couldn't make test.cog writable",

self.cog.callableMain, (['argv0', '-r', '-w', 'echo %s', 'test.cog']))

assert not os.access(self.testcog, os.W_OK)

class ChecksumTests(TestCaseWithTempDir):

def testCreateChecksumOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

This line was generated.

//[[[end]]]

This line was not.

""",

'cog1.out': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

This line was generated.

//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893)

This line was not.

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-c', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

def testCheckChecksumOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was generated.

//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893)

""",

'cog1.out': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah.

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-c', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

def testRemoveChecksumOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was generated.

//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893) fooey

""",

'cog1.out': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah.

//[[[end]]] fooey

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

def testTamperedChecksumOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

Xhis line was newly

generated by cog

blah blah.

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog2.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah!

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog3.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah.

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog4.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah..

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog5.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah.

extra

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog6.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

}

makeFiles(d)

self.assertRaisesMsg(CogError,

"cog1.txt(9): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog1.txt"]))

self.assertRaisesMsg(CogError,

"cog2.txt(9): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog2.txt"]))

self.assertRaisesMsg(CogError,

"cog3.txt(10): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog3.txt"]))

self.assertRaisesMsg(CogError,

"cog4.txt(9): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog4.txt"]))

self.assertRaisesMsg(CogError,

"cog5.txt(10): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog5.txt"]))

self.assertRaisesMsg(CogError,

"cog6.txt(6): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog6.txt"]))

class BlakeTests(TestCaseWithTempDir):

# Blake Winton's contributions.

def testDeleteCode(self):

# -o sets the output file.

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

Some Sample Code Here

//[[[end]]]Data Data

And Some More

""",

'test.out': """\

// This is my C++ file.

void DoSomething();

void DoAnotherThing();

void DoLastThing();

And Some More

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-d', '-o', 'test.cogged', 'test.cog'])

self.assertFilesSame('test.cogged', 'test.out')

def testDeleteCodeWithDashRFails(self):

d = {

'test.cog': """\

// This is my C++ file.

"""

}

makeFiles(d)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-r', '-d', 'test.cog']))

def testSettingGlobals(self):

# Blake Winton contributed a way to set the globals that will be used in

# processFile().

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

Some Sample Code Here

//[[[end]]]""",

'test.out': """\

// This is my C++ file.

void DoBlake();

void DoWinton();

void DoContribution();

""",

}

makeFiles(d)

globals = {}

globals['fnames'] = ['DoBlake', 'DoWinton', 'DoContribution']

self.cog.options.bDeleteCode = True

self.cog.processFile('test.cog', 'test.cogged', globals=globals)

self.assertFilesSame('test.cogged', 'test.out')

class ErrorCallTests(TestCaseWithTempDir):

def testErrorCallHasNoTraceback(self):

# Test that cog.error() doesn't show a traceback.

d = {

'error.cog': """\

//[[[cog

cog.error("Something Bad!")

//]]]

//[[[end]]]

""",

}

makeFiles(d)

self.cog.main(['argv0', '-r', 'error.cog'])

output = self.output.getvalue()

self.assertEqual(output, "Cogging error.cog\nError: Something Bad!\n")

def testRealErrorHasTraceback(self):

# Test that a genuine error does show a traceback.

d = {

'error.cog': """\

//[[[cog

raise RuntimeError("Hey!")

//]]]

//[[[end]]]

""",

}

makeFiles(d)

self.cog.main(['argv0', '-r', 'error.cog'])

output = self.output.getvalue()

msg = 'Actual output:\n' + output

self.assert_(output.startswith("Cogging error.cog\nTraceback (most recent"), msg)

self.assert_(output.find("RuntimeError: Hey!") > 0, msg)

if __name__ == '__main__': #pragma: no cover

unittest.main()

# Things not yet tested:

# - A bad -w command (currently fails silently).

- -

- - - - - + + + + + + + + Coverage for cogapp\test_cogapp: 34% + + + + + + + + + + + +

Hot-keys on this page

+ r + m + x + p toggle line displays +

+ j + k next/prev highlighted chunk +

+ 0 (zero) top of page +

+ 1 (one) first highlighted chunk +

+ +

+ + + + + +

+ +

""" Test cogapp.

http://nedbatchelder.com/code/cog

"""

import unittest

import os, random, re, StringIO, stat, sys, tempfile

import path # Non-standard, from http://www.jorendorff.com/articles/python/path

from cogapp import Cog, CogOptions, CogGenerator

from cogapp import CogError, CogUsageError, CogGeneratedError

from cogapp import usage, __version__

from whiteutils import reindentBlock

from makefiles import *

class TestCase(unittest.TestCase):

""" Base class for all Cog test cases. Adds utility methods I like.

"""

def assertRaisesMsg(self, excClass, msg, callableObj, *args, **kwargs):

""" Just like unittest.TestCase.assertRaises,

but checks that the message is right too.

"""

try:

callableObj(*args, **kwargs)

except excClass, exc:

excMsg = str(exc)

if not msg:

# No message provided: it passes.

return #pragma: no cover

elif excMsg == msg:

# Message provided, and we got the right message: it passes.

return

else: #pragma: no cover

# Message provided, and it didn't match: fail!

raise self.failureException("Right exception, wrong message: got '%s' expected '%s'" % (excMsg, msg))

else: #pragma: no cover

if hasattr(excClass,'__name__'):

excName = excClass.__name__

else:

excName = str(excClass)

raise self.failureException("Expected to raise %s, didn't get an exception at all" % excName)

class CogTestsInMemory(TestCase):

""" Test cases for cogapp.Cog()

"""

def testNoCog(self):

strings = [

'',

' ',

' \t \t \tx',

'hello',

'the cat\nin the\nhat.',

'Horton\n\tHears A\n\t\tWho'

]

for s in strings:

self.assertEqual(Cog().processString(s), s)

def testSimple(self):

infile = """\

Some text.

//[[[cog

import cog

cog.outl("This is line one\\n")

cog.outl("This is line two")

//]]]

gobbledegook.

//[[[end]]]

epilogue.

"""

outfile = """\

Some text.

//[[[cog

import cog

cog.outl("This is line one\\n")

cog.outl("This is line two")

//]]]

This is line one

This is line two

//[[[end]]]

epilogue.

"""

self.assertEqual(Cog().processString(infile), outfile)

def testEmptyCog(self):

# The cog clause can be totally empty. Not sure why you'd want it,

# but it works.

infile = """\

hello

//[[[cog

//]]]

//[[[end]]]

goodbye

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testMultipleCogs(self):

# One file can have many cog chunks, even abutting each other.

infile = """\

//[[[cog

cog.out("chunk1")

//]]]

chunk1

//[[[end]]]

//[[[cog

cog.out("chunk2")

//]]]

chunk2

//[[[end]]]

between chunks

//[[[cog

cog.out("chunk3")

//]]]

chunk3

//[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testTrimBlankLines(self):

infile = """\

//[[[cog

cog.out("This is line one\\n", trimblanklines=True)

cog.out('''

This is line two

''', dedent=True, trimblanklines=True)

cog.outl("This is line three", trimblanklines=True)

//]]]

This is line one

This is line two

This is line three

//[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testTrimEmptyBlankLines(self):

infile = """\

//[[[cog

cog.out("This is line one\\n", trimblanklines=True)

cog.out('''

This is line two

''', dedent=True, trimblanklines=True)

cog.out('', dedent=True, trimblanklines=True)

cog.outl("This is line three", trimblanklines=True)

//]]]

This is line one

This is line two

This is line three

//[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def test22EndOfLine(self):

# In Python 2.2, this cog file was not parsing because the

# last line is indented but didn't end with a newline.

infile = """\

//[[[cog

import cog

for i in range(3):

cog.out("%d\\n" % i)

//]]]

//[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testIndentedCode(self):

infile = """\

first line

[[[cog

import cog

for i in range(3):

cog.out("xx%d\\n" % i)

]]]

xx0

xx1

xx2

[[[end]]]

last line

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testPrefixedCode(self):

infile = """\

--[[[cog

--import cog

--for i in range(3):

-- cog.out("xx%d\\n" % i)

--]]]

xx0

xx1

xx2

--[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testPrefixedIndentedCode(self):

infile = """\

prologue

--[[[cog

-- import cog

-- for i in range(3):

-- cog.out("xy%d\\n" % i)

--]]]

xy0

xy1

xy2

--[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testBogusPrefixMatch(self):

infile = """\

prologue

#[[[cog

import cog

# This comment should not be clobbered by removing the pound sign.

for i in range(3):

cog.out("xy%d\\n" % i)

#]]]

xy0

xy1

xy2

#[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testNoFinalNewline(self):

# If the cog'ed output has no final newline,

# it shouldn't eat up the cog terminator.

infile = """\

prologue

[[[cog

import cog

for i in range(3):

cog.out("%d" % i)

]]]

012

[[[end]]]

epilogue

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testNoOutputAtAll(self):

# If there is absolutely no cog output, that's ok.

infile = """\

prologue

[[[cog

i = 1

]]]

[[[end]]]

epilogue

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testPurelyBlankLine(self):

# If there is a blank line in the cog code with no whitespace

# prefix, that should be OK.

infile = """\

prologue

[[[cog

import sys

cog.out("Hello")

cog.out("There")

]]]

HelloThere

[[[end]]]

epilogue

"""

infile = reindentBlock(infile.replace('$', ''))

self.assertEqual(Cog().processString(infile), infile)

def testEmptyOutl(self):

# Alexander Belchenko suggested the string argument to outl should

# be optional. Does it work?

infile = """\

prologue

[[[cog

cog.outl("x")

cog.outl()

cog.outl("y")

cog.outl(trimblanklines=True)

cog.outl("z")

]]]

[[[end]]]

epilogue

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testFirstLineNum(self):

infile = """\

fooey

[[[cog

cog.outl("started at line number %d" % cog.firstLineNum)

]]]

started at line number 2

[[[end]]]

blah blah

[[[cog

cog.outl("and again at line %d" % cog.firstLineNum)

]]]

and again at line 8

[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

def testCompactOneLineCode(self):

infile = """\

first line

hey: [[[cog cog.outl("hello %d" % (3*3*3*3)) ]]] looky!

get rid of this!

[[[end]]]

last line

"""

outfile = """\

first line

hey: [[[cog cog.outl("hello %d" % (3*3*3*3)) ]]] looky!

hello 81

[[[end]]]

last line

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), reindentBlock(outfile))

def testInsideOutCompact(self):

infile = """\

first line

hey?: ]]] what is this? [[[cog strange!

get rid of this!

[[[end]]]

last line

"""

self.assertRaisesMsg(CogError,

"infile.txt(2): Cog code markers inverted",

Cog().processString,

reindentBlock(infile), "infile.txt")

def testSharingGlobals(self):

infile = """\

first line

hey: [[[cog s="hey there" ]]] looky!

[[[end]]]

more literal junk.

[[[cog cog.outl(s) ]]]

[[[end]]]

last line

"""

outfile = """\

first line

hey: [[[cog s="hey there" ]]] looky!

[[[end]]]

more literal junk.

[[[cog cog.outl(s) ]]]

hey there

[[[end]]]

last line

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), reindentBlock(outfile))

class CogOptionsTests(TestCase):

""" Test the CogOptions class.

"""

def testEquality(self):

o = CogOptions()

p = CogOptions()

self.assertEqual(o, p)

o.parseArgs(['-r'])

self.assertNotEqual(o, p)

p.parseArgs(['-r'])

self.assertEqual(o, p)

def testCloning(self):

o = CogOptions()

o.parseArgs(['-I', 'fooey', '-I', 'booey', '-s', ' /*x*/'])

p = o.clone()

self.assertEqual(o, p)

p.parseArgs(['-I', 'huey', '-D', 'foo=quux'])

self.assertNotEqual(o, p)

q = CogOptions()

q.parseArgs(['-I', 'fooey', '-I', 'booey', '-s', ' /*x*/', '-I', 'huey', '-D', 'foo=quux'])

self.assertEqual(p, q)

def testCombiningFlags(self):

# Single-character flags can be combined.

o = CogOptions()

o.parseArgs(['-e', '-r', '-z'])

p = CogOptions()

p.parseArgs(['-erz'])

self.assertEqual(o, p)

class FileStructureTests(TestCase):

""" Test cases to check that we're properly strict about the structure

of files.

"""

def isBad(self, infile, msg=None):

infile = reindentBlock(infile)

self.assertRaisesMsg(CogError,

msg,

Cog().processString, (infile), 'infile.txt')

def testBeginNoEnd(self):

infile = """\

Fooey

#[[[cog

cog.outl('hello')

"""

self.isBad(infile, "infile.txt(2): Cog block begun but never ended.")

def testNoEoo(self):

infile = """\

Fooey

#[[[cog

cog.outl('hello')

#]]]

"""

self.isBad(infile, "infile.txt(4): Missing '[[[end]]]' before end of file.")

infile2 = """\

Fooey

#[[[cog

cog.outl('hello')

#]]]

#[[[cog

cog.outl('goodbye')

#]]]

"""

self.isBad(infile2, "infile.txt(5): Unexpected '[[[cog'")

def testStartWithEnd(self):

infile = """\

#]]]

"""

self.isBad(infile, "infile.txt(1): Unexpected ']]]'")

infile2 = """\

#[[[cog

cog.outl('hello')

#]]]

#[[[end]]]

#]]]

"""

self.isBad(infile2, "infile.txt(5): Unexpected ']]]'")

def testStartWithEoo(self):

infile = """\

#[[[end]]]

"""

self.isBad(infile, "infile.txt(1): Unexpected '[[[end]]]'")

infile2 = """\

#[[[cog

cog.outl('hello')

#]]]

#[[[end]]]

"""

self.isBad(infile2, "infile.txt(5): Unexpected '[[[end]]]'")

def testNoEnd(self):

infile = """\

#[[[cog

cog.outl("hello")

#[[[end]]]

"""

self.isBad(infile, "infile.txt(3): Unexpected '[[[end]]]'")

infile2 = """\

#[[[cog

cog.outl('hello')

#]]]

#[[[end]]]

#[[[cog

cog.outl("hello")

#[[[end]]]

"""

self.isBad(infile2, "infile.txt(7): Unexpected '[[[end]]]'")

def testTwoBegins(self):

infile = """\

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

"""

self.isBad(infile, "infile.txt(2): Unexpected '[[[cog'")

infile2 = """\

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

"""

self.isBad(infile2, "infile.txt(6): Unexpected '[[[cog'")

def testTwoEnds(self):

infile = """\

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

"""

self.isBad(infile, "infile.txt(4): Unexpected ']]]'")

infile2 = """\

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

#[[[cog

cog.outl("hello")

#]]]

#[[[end]]]

"""

self.isBad(infile2, "infile.txt(8): Unexpected ']]]'")

class CogErrorTests(TestCase):

""" Test cases for cog.error().

"""

def testErrorMsg(self):

infile = """\

[[[cog cog.error("This ain't right!")]]]

[[[end]]]

"""

infile = reindentBlock(infile)

self.assertRaisesMsg(CogGeneratedError,

"This ain't right!",

Cog().processString, (infile))

def testErrorNoMsg(self):

infile = """\

[[[cog cog.error()]]]

[[[end]]]

"""

infile = reindentBlock(infile)

self.assertRaisesMsg(CogGeneratedError,

"Error raised by cog generator.",

Cog().processString, (infile))

def testNoErrorIfErrorNotCalled(self):

infile = """\

--[[[cog

--import cog

--for i in range(3):

-- if i > 10:

-- cog.error("Something is amiss!")

-- cog.out("xx%d\\n" % i)

--]]]

xx0

xx1

xx2

--[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(Cog().processString(infile), infile)

class CogGeneratorGetCodeTests(TestCase):

""" Unit tests against CogGenerator to see if its getCode() method works

properly.

"""

def setUp(self):

""" All tests get a generator to use, and short same-length names for

the functions we're going to use.

"""

self.gen = CogGenerator()

self.m = self.gen.parseMarker

self.l = self.gen.parseLine

def testEmpty(self):

self.m('// [[[cog')

self.m('// ]]]')

self.assertEqual(self.gen.getCode(), '')

def testSimple(self):

self.m('// [[[cog')

self.l(' print "hello"')

self.l(' print "bye"')

self.m('// ]]]')

self.assertEqual(self.gen.getCode(), 'print "hello"\nprint "bye"')

def testCompressed1(self):

# For a while, I supported compressed code blocks, but no longer.

self.m('// [[[cog: print """')

self.l('// hello')

self.l('// bye')

self.m('// """)]]]')

self.assertEqual(self.gen.getCode(), 'hello\nbye')

def testCompressed2(self):

# For a while, I supported compressed code blocks, but no longer.

self.m('// [[[cog: print """')

self.l('hello')

self.l('bye')

self.m('// """)]]]')

self.assertEqual(self.gen.getCode(), 'hello\nbye')

def testCompressed3(self):

# For a while, I supported compressed code blocks, but no longer.

self.m('// [[[cog')

self.l('print """hello')

self.l('bye')

self.m('// """)]]]')

self.assertEqual(self.gen.getCode(), 'print """hello\nbye')

def testCompressed4(self):

# For a while, I supported compressed code blocks, but no longer.

self.m('// [[[cog: print """')

self.l('hello')

self.l('bye""")')

self.m('// ]]]')

self.assertEqual(self.gen.getCode(), 'hello\nbye""")')

def testNoCommonPrefixForMarkers(self):

# It's important to be able to use #if 0 to hide lines from a

# C++ compiler.

self.m('#if 0 //[[[cog')

self.l('\timport cog, sys')

self.l('')

self.l('\tprint sys.argv')

self.m('#endif //]]]')

self.assertEqual(self.gen.getCode(), 'import cog, sys\n\nprint sys.argv')

class TestCaseWithTempDir(TestCase):

def newCog(self):

""" Initialize the cog members for another run.

"""

# Create a cog engine, and catch its output.

self.cog = Cog()

self.output = StringIO.StringIO()

self.cog.setOutput(stdout=self.output, stderr=self.output)

def setUp(self):

# Create a temporary directory.

self.tempdir = path.path(tempfile.gettempdir()) / ('testcog_tempdir_' + str(random.random())[2:])

self.tempdir.mkdir()

self.olddir = os.getcwd()

os.chdir(self.tempdir)

self.newCog()

def tearDown(self):

os.chdir(self.olddir)

# Get rid of the temporary directory.

self.tempdir.rmtree()

def assertFilesSame(self, sFName1, sFName2):

self.assertEqual((self.tempdir / sFName1).text(), (self.tempdir / sFName2).text())

def assertFileContent(self, sFName, sContent):

sAbsName = self.tempdir / sFName

f = open(sAbsName, 'rb')

try:

sFileContent = f.read()

finally:

f.close()

self.assertEqual(sFileContent, sContent)

class ArgumentHandlingTests(TestCaseWithTempDir):

def testArgumentFailure(self):

# Return value 2 means usage problem.

assert(self.cog.main(['argv0', '-j']) == 2)

output = self.output.getvalue()

assert(output.find("option -j not recognized") >= 0)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0']))

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-j']))

def testNoDashOAndAtFile(self):

d = {

'cogfiles.txt': """\

# Please run cog

"""

}

makeFiles(d)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-o', 'foo', '@cogfiles.txt']))

def testDashV(self):

assert(self.cog.main(['argv0', '-v']) == 0)

output = self.output.getvalue()

self.assertEqual('Cog version %s\n' % __version__, output)

def producesHelp(self, args):

self.newCog()

argv = ['argv0'] + args.split()

assert(self.cog.main(argv) == 0)

self.assertEquals(usage, self.output.getvalue())

def testDashH(self):

# -h or -? anywhere on the command line should just print help.

self.producesHelp("-h")

self.producesHelp("-?")

self.producesHelp("fooey.txt -h")

self.producesHelp("-o -r @fooey.txt -? @booey.txt")

def testDashOAndDashR(self):

d = {

'cogfile.txt': """\

# Please run cog

"""

}

makeFiles(d)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-o', 'foo', '-r', 'cogfile.txt']))

def testDashZ(self):

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

""",

'test.out': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

void DoSomething();

void DoAnotherThing();

void DoLastThing();

""",

}

makeFiles(d)

self.assertRaisesMsg(

CogError, "test.cog(6): Missing '[[[end]]]' before end of file.",

self.cog.callableMain, (['argv0', '-r', 'test.cog']))

self.newCog()

self.cog.callableMain(['argv0', '-r', '-z', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testBadDashD(self):

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-Dfooey', 'cog.txt']))

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-D', 'fooey', 'cog.txt']))

class TestFileHandling(TestCaseWithTempDir):

def testSimple(self):

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

//[[[end]]]

""",

'test.out': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

void DoSomething();

void DoAnotherThing();

void DoLastThing();

//[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

output = self.output.getvalue()

assert(output.find("(changed)") >= 0)

def testOutputFile(self):

# -o sets the output file.

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

//[[[end]]]

""",

'test.out': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

void DoSomething();

void DoAnotherThing();

void DoLastThing();

//[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-o', 'test.cogged', 'test.cog'])

self.assertFilesSame('test.cogged', 'test.out')

def testAtFile(self):

d = {

'one.cog': """\

//[[[cog

cog.outl("hello world")

//]]]

//[[[end]]]

""",

'one.out': """\

//[[[cog

cog.outl("hello world")

//]]]

hello world

//[[[end]]]

""",

'two.cog': """\

//[[[cog

cog.outl("goodbye cruel world")

//]]]

//[[[end]]]

""",

'two.out': """\

//[[[cog

cog.outl("goodbye cruel world")

//]]]

goodbye cruel world

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

one.cog

two.cog

"""

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])

self.assertFilesSame('one.cog', 'one.out')

self.assertFilesSame('two.cog', 'two.out')

output = self.output.getvalue()

assert(output.find("(changed)") >= 0)

def testNestedAtFile(self):

d = {

'one.cog': """\

//[[[cog

cog.outl("hello world")

//]]]

//[[[end]]]

""",

'one.out': """\

//[[[cog

cog.outl("hello world")

//]]]

hello world

//[[[end]]]

""",

'two.cog': """\

//[[[cog

cog.outl("goodbye cruel world")

//]]]

//[[[end]]]

""",

'two.out': """\

//[[[cog

cog.outl("goodbye cruel world")

//]]]

goodbye cruel world

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

one.cog

@cogfiles2.txt

""",

'cogfiles2.txt': """\

# This one too, please.

two.cog

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])

self.assertFilesSame('one.cog', 'one.out')

self.assertFilesSame('two.cog', 'two.out')

output = self.output.getvalue()

assert(output.find("(changed)") >= 0)

def testAtFileWithArgs(self):

d = {

'both.cog': """\

//[[[cog

cog.outl("one: %s" % globals().has_key('one'))

cog.outl("two: %s" % globals().has_key('two'))

//]]]

//[[[end]]]

""",

'one.out': """\

//[[[cog

cog.outl("one: %s" % globals().has_key('one'))

cog.outl("two: %s" % globals().has_key('two'))

//]]]

one: True // ONE

two: False // ONE

//[[[end]]]

""",

'two.out': """\

//[[[cog

cog.outl("one: %s" % globals().has_key('one'))

cog.outl("two: %s" % globals().has_key('two'))

//]]]

one: False // TWO

two: True // TWO

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

both.cog -o both.one -s ' // ONE' -D one=x

both.cog -o both.two -s ' // TWO' -D two=x

"""

}

makeFiles(d)

self.cog.callableMain(['argv0', '@cogfiles.txt'])

self.assertFilesSame('both.one', 'one.out')

self.assertFilesSame('both.two', 'two.out')

def testAtFileWithBadArgCombo(self):

d = {

'both.cog': """\

//[[[cog

cog.outl("one: %s" % globals().has_key('one'))

cog.outl("two: %s" % globals().has_key('two'))

//]]]

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

both.cog

both.cog -d # This is bad: -r and -d

"""

}

makeFiles(d)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-r', '@cogfiles.txt']))

def testAtFileWithTrickyFilenames(self):

d = {

'one 1.cog': """\

//[[[cog cog.outl("hello world") ]]]

""",

'one.out': """\

//[[[cog cog.outl("hello world") ]]]

hello world //xxx

""",

'subdir': {

'subback.cog': """\

//[[[cog cog.outl("down deep with backslashes") ]]]

""",

'subfwd.cog': """\

//[[[cog cog.outl("down deep with slashes") ]]]

""",

'subback.out': """\

//[[[cog cog.outl("down deep with backslashes") ]]]

down deep with backslashes //yyy

""",

'subfwd.out': """\

//[[[cog cog.outl("down deep with slashes") ]]]

down deep with slashes //zzz

""",

'cogfiles.txt': """\

# Please run cog

'one 1.cog' -s ' //xxx'

subdir\subback.cog -s ' //yyy'

subdir/subfwd.cog -s ' //zzz'

"""

}

makeFiles(d)

self.cog.callableMain(['argv0', '-z', '-r', '@cogfiles.txt'])

self.assertFilesSame('one 1.cog', 'one.out')

self.assertFilesSame('subdir/subback.cog', 'subback.out')

self.assertFilesSame('subdir/subfwd.cog', 'subfwd.out')

class CogTestLineEndings(TestCaseWithTempDir):

"""Tests for -U option (force LF line-endings in output)."""

lines_in = ['Some text.',

'//[[[cog',

'cog.outl("Cog text")',

'//]]]',

'gobbledegook.',

'//[[[end]]]',

'epilogue.',

'']

lines_out = ['Some text.',

'//[[[cog',

'cog.outl("Cog text")',

'//]]]',

'Cog text',

'//[[[end]]]',

'epilogue.',

'']

def testOutputNativeEol(self):

makeFiles({'infile': '\n'.join(self.lines_in)})

self.cog.callableMain(['argv0', '-o', 'outfile', 'infile'])

self.assertFileContent('outfile', os.linesep.join(self.lines_out))

def testOutputLfEol(self):

makeFiles({'infile': '\n'.join(self.lines_in)})

self.cog.callableMain(['argv0', '-U', '-o', 'outfile', 'infile'])

self.assertFileContent('outfile', '\n'.join(self.lines_out))

def testReplaceNativeEol(self):

makeFiles({'test.cog': '\n'.join(self.lines_in)})

self.cog.callableMain(['argv0', '-r', 'test.cog'])

self.assertFileContent('test.cog', os.linesep.join(self.lines_out))

def testReplaceLfEol(self):

makeFiles({'test.cog': '\n'.join(self.lines_in)})

self.cog.callableMain(['argv0', '-U', '-r', 'test.cog'])

self.assertFileContent('test.cog', '\n'.join(self.lines_out))

class TestCaseWithImports(TestCaseWithTempDir):

""" When running tests which import modules, the sys.modules list

leaks from one test to the next. This test case class scrubs

the list after each run to keep the tests isolated from each other.

"""

def setUp(self):

TestCaseWithTempDir.setUp(self)

self.sysmodulekeys = list(sys.modules)

def tearDown(self):

modstoscrub = [

modname

for modname in sys.modules

if modname not in self.sysmodulekeys

]

for modname in modstoscrub:

del sys.modules[modname]

TestCaseWithTempDir.tearDown(self)

class CogIncludeTests(TestCaseWithImports):

dincludes = {

'test.cog': """\

//[[[cog

import mymodule

//]]]

//[[[end]]]

""",

'test.out': """\

//[[[cog

import mymodule

//]]]

Hello from mymodule

//[[[end]]]

""",

'test2.out': """\

//[[[cog

import mymodule

//]]]

Hello from mymodule in inc2

//[[[end]]]

""",

'include': {

'mymodule.py': """\

import cog

cog.outl("Hello from mymodule")

"""

'inc2': {

'mymodule.py': """\

import cog

cog.outl("Hello from mymodule in inc2")

"""

'inc3': {

'someothermodule.py': """\

import cog

cog.outl("This is some other module.")

"""

}

def testNeedIncludePath(self):

# Try it without the -I, to see that an ImportError happens.

makeFiles(self.dincludes)

self.assertRaises(ImportError, self.cog.callableMain, (['argv0', '-r', 'test.cog']))

def testIncludePath(self):

# Test that -I adds include directories properly.

makeFiles(self.dincludes)

self.cog.callableMain(['argv0', '-r', '-I', 'include', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testTwoIncludePaths(self):

# Test that two -I's add include directories properly.

makeFiles(self.dincludes)

self.cog.callableMain(['argv0', '-r', '-I', 'include', '-I', 'inc2', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testTwoIncludePaths2(self):

# Test that two -I's add include directories properly.

makeFiles(self.dincludes)

self.cog.callableMain(['argv0', '-r', '-I', 'inc2', '-I', 'include', 'test.cog'])

self.assertFilesSame('test.cog', 'test2.out')

def testUselessIncludePath(self):

# Test that the search will continue past the first directory.

makeFiles(self.dincludes)

self.cog.callableMain(['argv0', '-r', '-I', 'inc3', '-I', 'include', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testSysPathIsUnchanged(self):

d = {

'bad.cog': """\

//[[[cog cog.error("Oh no!") ]]]

//[[[end]]]

""",

'good.cog': """\

//[[[cog cog.outl("Oh yes!") ]]]

//[[[end]]]

""",

}

makeFiles(d)

# Is it unchanged just by creating a cog engine?

oldsyspath = sys.path[:]

self.newCog()

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a successful run?

self.newCog()

self.cog.callableMain(['argv0', '-r', 'good.cog'])

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a successful run with includes?

self.newCog()

self.cog.callableMain(['argv0', '-r', '-I', 'xyzzy', 'good.cog'])

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a successful run with two includes?

self.newCog()

self.cog.callableMain(['argv0', '-r', '-I', 'xyzzy', '-I', 'quux', 'good.cog'])

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a failed run?

self.newCog()

self.assertRaises(CogError, self.cog.callableMain, (['argv0', '-r', 'bad.cog']))

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a failed run with includes?

self.newCog()

self.assertRaises(CogError, self.cog.callableMain, (['argv0', '-r', '-I', 'xyzzy', 'bad.cog']))

self.assertEqual(oldsyspath, sys.path)

# Is it unchanged for a failed run with two includes?

self.newCog()

self.assertRaises(CogError, self.cog.callableMain, (['argv0', '-r', '-I', 'xyzzy', '-I', 'quux', 'bad.cog']))

self.assertEqual(oldsyspath, sys.path)

def testSubDirectories(self):

# Test that relative paths on the command line work, with includes.

d = {

'code': {

'test.cog': """\

//[[[cog

import mysubmodule

//]]]

//[[[end]]]

""",

'test.out': """\

//[[[cog

import mysubmodule

//]]]

Hello from mysubmodule

//[[[end]]]

""",

'mysubmodule.py': """\

import cog

cog.outl("Hello from mysubmodule")

"""

}

makeFiles(d)

# We should be able to invoke cog without the -I switch, and it will

# auto-include the current directory

self.cog.callableMain(['argv0', '-r', 'code/test.cog'])

self.assertFilesSame('code/test.cog', 'code/test.out')

class CogTestsInFiles(TestCaseWithTempDir):

def testWarnIfNoCogCode(self):

# Test that the -e switch warns if there is no Cog code.

d = {

'with.cog': """\

//[[[cog

cog.outl("hello world")

//]]]

hello world

//[[[end]]]

""",

'without.cog': """\

There's no cog

code in this file.

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-e', 'with.cog'])

output = self.output.getvalue()

assert(output.find("Warning") < 0)

self.newCog()

self.cog.callableMain(['argv0', '-e', 'without.cog'])

output = self.output.getvalue()

assert(output.find("Warning: no cog code found in without.cog") >= 0)

self.newCog()

self.cog.callableMain(['argv0', 'without.cog'])

output = self.output.getvalue()

assert(output.find("Warning") < 0)

def testFileNameProps(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))

//]]]

this is cog1.txt in, cog1.txt out

[[[end]]]

""",

'cog1.out': """\

//[[[cog

cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))

//]]]

This is cog1.txt in, cog1.txt out

[[[end]]]

""",

'cog1out.out': """\

//[[[cog

cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))

//]]]

This is cog1.txt in, cog1out.txt out

[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

self.newCog()

self.cog.callableMain(['argv0', '-o', 'cog1out.txt', 'cog1.txt'])

self.assertFilesSame('cog1out.txt', 'cog1out.out')

def testGlobalsDontCrossFiles(self):

# Make sure that global values don't get shared between files.

d = {

'one.cog': """\

//[[[cog s = "This was set in one.cog" ]]]

//[[[end]]]

//[[[cog cog.outl(s) ]]]

//[[[end]]]

""",

'one.out': """\

//[[[cog s = "This was set in one.cog" ]]]

//[[[end]]]

//[[[cog cog.outl(s) ]]]

This was set in one.cog

//[[[end]]]

""",

'two.cog': """\

//[[[cog

try:

cog.outl(s)

except NameError:

cog.outl("s isn't set!")

//]]]

//[[[end]]]

""",

'two.out': """\

//[[[cog

try:

cog.outl(s)

except NameError:

cog.outl("s isn't set!")

//]]]

s isn't set!

//[[[end]]]

""",

'cogfiles.txt': """\

# Please run cog

one.cog

two.cog

"""

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])

self.assertFilesSame('one.cog', 'one.out')

self.assertFilesSame('two.cog', 'two.out')

output = self.output.getvalue()

assert(output.find("(changed)") >= 0)

def testRemoveGeneratedOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

This line was generated.

//[[[end]]]

This line was not.

""",

'cog1.out': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

//[[[end]]]

This line was not.

""",

'cog1.out2': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

This line was generated.

//[[[end]]]

This line was not.

""",

}

makeFiles(d)

# Remove generated output.

self.cog.callableMain(['argv0', '-r', '-x', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

self.newCog()

# Regenerate the generated output.

self.cog.callableMain(['argv0', '-r', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out2')

self.newCog()

# Remove the generated output again.

self.cog.callableMain(['argv0', '-r', '-x', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

def testMsgCall(self):

infile = """\

#[[[cog

cog.msg("Hello there!")

#]]]

#[[[end]]]

"""

infile = reindentBlock(infile)

self.assertEqual(self.cog.processString(infile), infile)

output = self.output.getvalue()

self.assertEqual(output, "Message: Hello there!\n")

def testErrorMessageHasNoTraceback(self):

# Test that a Cog error is printed to stderr with no traceback.

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

Xhis line was newly

generated by cog

blah blah.

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

}

makeFiles(d)

stderr = StringIO.StringIO()

self.cog.setOutput(stderr=stderr)

self.cog.main(['argv0', '-c', '-r', "cog1.txt"])

output = self.output.getvalue()

self.assertEqual(self.output.getvalue(), "Cogging cog1.txt\n")

self.assertEqual(stderr.getvalue(), "cog1.txt(9): Output has been edited! Delete old checksum to unprotect.\n")

def testDashD(self):

d = {

'test.cog': """\

--[[[cog cog.outl("Defined fooey as " + fooey) ]]]

--[[[end]]]

""",

'test.kablooey': """\

--[[[cog cog.outl("Defined fooey as " + fooey) ]]]

Defined fooey as kablooey

--[[[end]]]

""",

'test.einstein': """\

--[[[cog cog.outl("Defined fooey as " + fooey) ]]]

Defined fooey as e=mc2

--[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-D', 'fooey=kablooey', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dfooey=kablooey', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dfooey=e=mc2', 'test.cog'])

self.assertFilesSame('test.cog', 'test.einstein')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dbar=quux', '-Dfooey=kablooey', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dfooey=kablooey', '-Dbar=quux', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-Dfooey=gooey', '-Dfooey=kablooey', 'test.cog'])

self.assertFilesSame('test.cog', 'test.kablooey')

def testOutputToStdout(self):

d = {

'test.cog': """\

--[[[cog cog.outl('Hey there!') ]]]

--[[[end]]]

"""

}

makeFiles(d)

stderr = StringIO.StringIO()

self.cog.setOutput(stderr=stderr)

self.cog.callableMain(['argv0', 'test.cog'])

output = self.output.getvalue()

outerr = stderr.getvalue()

self.assertEqual(output, "--[[[cog cog.outl('Hey there!') ]]]\nHey there!\n--[[[end]]]\n")

self.assertEqual(outerr, "")

def testSuffixOutputLines(self):

d = {

'test.cog': """\

Hey there.

;[[[cog cog.outl('a\\nb\\n \\nc') ]]]

;[[[end]]]

Good bye.

""",

'test.out': """\

Hey there.

;[[[cog cog.outl('a\\nb\\n \\nc') ]]]

a (foo)

b (foo)

c (foo)

;[[[end]]]

Good bye.

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-s', ' (foo)', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testEmptySuffix(self):

d = {

'test.cog': """\

;[[[cog cog.outl('a\\nb\\nc') ]]]

;[[[end]]]

""",

'test.out': """\

;[[[cog cog.outl('a\\nb\\nc') ]]]

;[[[end]]]

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-s', '', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

def testHellishSuffix(self):

d = {

'test.cog': """\

;[[[cog cog.outl('a\\n\\nb') ]]]

""",

'test.out': """\

;[[[cog cog.outl('a\\n\\nb') ]]]

a /\\n*+([)]><

b /\\n*+([)]><

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-z', '-r', '-s', r' /\n*+([)]><', 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

class WritabilityTests(TestCaseWithTempDir):

d = {

'test.cog': """\

//[[[cog

for fn in ['DoSomething', 'DoAnotherThing', 'DoLastThing']:

cog.outl("void %s();" % fn)

//]]]

//[[[end]]]

""",

'test.out': """\

//[[[cog

for fn in ['DoSomething', 'DoAnotherThing', 'DoLastThing']:

cog.outl("void %s();" % fn)

//]]]

void DoSomething();

void DoAnotherThing();

void DoLastThing();

//[[[end]]]

""",

}

if os.name == 'nt': # pragma: no cover

# for Windows

cmd_w_args = 'attrib -R %s'

cmd_w_asterisk = 'attrib -R *'

else: # pragma: no cover

# for unix-like

cmd_w_args = 'chmod +w %s'

cmd_w_asterisk = 'chmod +w *'

def setUp(self):

TestCaseWithTempDir.setUp(self)

makeFiles(self.d)

self.testcog = self.tempdir / 'test.cog'

self.testcog.chmod(stat.S_IREAD) # Make the file readonly.

assert not os.access(self.testcog, os.W_OK)

def tearDown(self):

self.testcog.chmod(stat.S_IWRITE) # Make the file writable again.

TestCaseWithTempDir.tearDown(self)

def testReadonlyNoCommand(self):

self.assertRaisesMsg(

CogError, "Can't overwrite test.cog",

self.cog.callableMain, (['argv0', '-r', 'test.cog']))

assert not os.access(self.testcog, os.W_OK)

def testReadonlyWithCommand(self):

self.cog.callableMain(['argv0', '-r', '-w', self.cmd_w_args, 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

assert os.access(self.testcog, os.W_OK)

def testReadonlyWithCommandWithNoSlot(self):

self.cog.callableMain(['argv0', '-r', '-w', self.cmd_w_asterisk, 'test.cog'])

self.assertFilesSame('test.cog', 'test.out')

assert os.access(self.testcog, os.W_OK)

def testReadonlyWithIneffectualCommand(self):

self.assertRaisesMsg(

CogError, "Couldn't make test.cog writable",

self.cog.callableMain, (['argv0', '-r', '-w', 'echo %s', 'test.cog']))

assert not os.access(self.testcog, os.W_OK)

class ChecksumTests(TestCaseWithTempDir):

def testCreateChecksumOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

This line was generated.

//[[[end]]]

This line was not.

""",

'cog1.out': """\

//[[[cog

cog.outl("This line was generated.")

//]]]

This line was generated.

//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893)

This line was not.

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-c', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

def testCheckChecksumOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was generated.

//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893)

""",

'cog1.out': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah.

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', '-c', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

def testRemoveChecksumOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was generated.

//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893) fooey

""",

'cog1.out': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah.

//[[[end]]] fooey

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-r', 'cog1.txt'])

self.assertFilesSame('cog1.txt', 'cog1.out')

def testTamperedChecksumOutput(self):

d = {

'cog1.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

Xhis line was newly

generated by cog

blah blah.

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog2.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah!

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog3.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah.

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog4.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah..

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog5.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

This line was newly

generated by cog

blah blah.

extra

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

'cog6.txt': """\

//[[[cog

cog.outl("This line was newly")

cog.outl("generated by cog")

cog.outl("blah blah.")

//]]]

//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)

""",

}

makeFiles(d)

self.assertRaisesMsg(CogError,

"cog1.txt(9): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog1.txt"]))

self.assertRaisesMsg(CogError,

"cog2.txt(9): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog2.txt"]))

self.assertRaisesMsg(CogError,

"cog3.txt(10): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog3.txt"]))

self.assertRaisesMsg(CogError,

"cog4.txt(9): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog4.txt"]))

self.assertRaisesMsg(CogError,

"cog5.txt(10): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog5.txt"]))

self.assertRaisesMsg(CogError,

"cog6.txt(6): Output has been edited! Delete old checksum to unprotect.",

self.cog.callableMain, (['argv0', '-c', "cog6.txt"]))

class BlakeTests(TestCaseWithTempDir):

# Blake Winton's contributions.

def testDeleteCode(self):

# -o sets the output file.

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

Some Sample Code Here

//[[[end]]]Data Data

And Some More

""",

'test.out': """\

// This is my C++ file.

void DoSomething();

void DoAnotherThing();

void DoLastThing();

And Some More

""",

}

makeFiles(d)

self.cog.callableMain(['argv0', '-d', '-o', 'test.cogged', 'test.cog'])

self.assertFilesSame('test.cogged', 'test.out')

def testDeleteCodeWithDashRFails(self):

d = {

'test.cog': """\

// This is my C++ file.

"""

}

makeFiles(d)

self.assertRaises(CogUsageError, self.cog.callableMain, (['argv0', '-r', '-d', 'test.cog']))

def testSettingGlobals(self):

# Blake Winton contributed a way to set the globals that will be used in

# processFile().

d = {

'test.cog': """\

// This is my C++ file.

//[[[cog

for fn in fnames:

cog.outl("void %s();" % fn)

//]]]

Some Sample Code Here

//[[[end]]]""",

'test.out': """\

// This is my C++ file.

void DoBlake();

void DoWinton();

void DoContribution();

""",

}

makeFiles(d)

globals = {}

globals['fnames'] = ['DoBlake', 'DoWinton', 'DoContribution']

self.cog.options.bDeleteCode = True

self.cog.processFile('test.cog', 'test.cogged', globals=globals)

self.assertFilesSame('test.cogged', 'test.out')

class ErrorCallTests(TestCaseWithTempDir):

def testErrorCallHasNoTraceback(self):

# Test that cog.error() doesn't show a traceback.

d = {

'error.cog': """\

//[[[cog

cog.error("Something Bad!")

//]]]

//[[[end]]]

""",

}

makeFiles(d)

self.cog.main(['argv0', '-r', 'error.cog'])

output = self.output.getvalue()

self.assertEqual(output, "Cogging error.cog\nError: Something Bad!\n")

def testRealErrorHasTraceback(self):

# Test that a genuine error does show a traceback.

d = {

'error.cog': """\

//[[[cog

raise RuntimeError("Hey!")

//]]]

//[[[end]]]

""",

}

makeFiles(d)

self.cog.main(['argv0', '-r', 'error.cog'])

output = self.output.getvalue()

msg = 'Actual output:\n' + output

self.assert_(output.startswith("Cogging error.cog\nTraceback (most recent"), msg)

self.assert_(output.find("RuntimeError: Hey!") > 0, msg)

if __name__ == '__main__': #pragma: no cover

unittest.main()

# Things not yet tested:

# - A bad -w command (currently fails silently).

+ +

+ + + + + diff --git a/doc/sample_html/cogapp_test_makefiles.html b/doc/sample_html/cogapp_test_makefiles.html index c7aa388a..bb37f908 100644 --- a/doc/sample_html/cogapp_test_makefiles.html +++ b/doc/sample_html/cogapp_test_makefiles.html @@ -1,297 +1,297 @@ - - - - - - - - Coverage for cogapp\test_makefiles: 0% - - - - - - - - - - - -

Hot-keys on this page

- r - m - x - p toggle line displays -

- j - k next/prev highlighted chunk -

- 0 (zero) top of page -

- 1 (one) first highlighted chunk -

- -

- - - - - -

- -

""" Test the cogapp.makefiles modules

http://nedbatchelder.com/code/cog

"""

import unittest # This is a unittest, so this is fundamental.

import StringIO, shutil, os, random, types, tempfile # We need these modules to write the tests.

import makefiles

class SimpleTests(unittest.TestCase):

def setUp(self):

# Create a temporary directory.

my_dir = 'testmakefiles_tempdir_' + str(random.random())[2:]

self.tempdir = os.path.join(tempfile.gettempdir(), my_dir)

os.mkdir(self.tempdir)

def tearDown(self):

# Get rid of the temporary directory.

shutil.rmtree(self.tempdir)

def exists(self, dname, fname):

return os.path.exists(os.path.join(dname, fname))

def checkFilesExist(self, d, dname):

for fname in d.keys():

assert(self.exists(dname, fname))

if type(d[fname]) == type({}):

self.checkFilesExist(d[fname], os.path.join(dname, fname))

def checkFilesDontExist(self, d, dname):

for fname in d.keys():

assert(not self.exists(dname, fname))

def testOneFile(self):

fname = 'foo.txt'

notfname = 'not_here.txt'

d = { fname: "howdy" }

assert(not self.exists(self.tempdir, fname))

assert(not self.exists(self.tempdir, notfname))

makefiles.makeFiles(d, self.tempdir)

assert(self.exists(self.tempdir, fname))

assert(not self.exists(self.tempdir, notfname))

makefiles.removeFiles(d, self.tempdir)

assert(not self.exists(self.tempdir, fname))

assert(not self.exists(self.tempdir, notfname))

def testManyFiles(self):

d = {

'top1.txt': "howdy",

'top2.txt': "hello",

'sub': {

'sub1.txt': "inside",

'sub2.txt': "inside2"

}

self.checkFilesDontExist(d, self.tempdir)

makefiles.makeFiles(d, self.tempdir)

self.checkFilesExist(d, self.tempdir)

makefiles.removeFiles(d, self.tempdir)

self.checkFilesDontExist(d, self.tempdir)

def testContents(self):

fname = 'bar.txt'

cont0 = "I am bar.txt"

d = { fname: cont0 }

makefiles.makeFiles(d, self.tempdir)

fcont1 = file(os.path.join(self.tempdir, fname))

assert(fcont1.read() == cont0)

fcont1.close()

def testDedent(self):

fname = 'dedent.txt'

d = { fname: """\

This is dedent.txt

\tTabbed in.

spaced in.

OK.

"""

}

makefiles.makeFiles(d, self.tempdir)

fcont = file(os.path.join(self.tempdir, fname))

assert(fcont.read() == "This is dedent.txt\n\tTabbed in.\n spaced in.\nOK.\n")

fcont.close()

def testRawContents(self):

fname = 'bar.txt'

cont0 = "I am bar.txt\r\nNewlines are different\nEven mixed up."

d = { fname: cont0 }

# Making them regular doesn't keep the contents identical.

makefiles.makeFiles(d, self.tempdir, raw=False)

fcont1 = file(os.path.join(self.tempdir, fname), "rb")

assert(fcont1.read() != cont0)

fcont1.close()

# Making them raw keeps all the bytes identical.

makefiles.makeFiles(d, self.tempdir, raw=True)

fcont2 = file(os.path.join(self.tempdir, fname), "rb")

assert(fcont2.read() == cont0)

fcont2.close()

if __name__ == '__main__': #pragma: no cover

unittest.main()

- -

- - - - - + + + + + + + + Coverage for cogapp\test_makefiles: 8% + + + + + + + + + + + +

Hot-keys on this page

+ r + m + x + p toggle line displays +

+ j + k next/prev highlighted chunk +

+ 0 (zero) top of page +

+ 1 (one) first highlighted chunk +

+ +

+ + + + + +

+ +

""" Test the cogapp.makefiles modules

http://nedbatchelder.com/code/cog

"""

import unittest # This is a unittest, so this is fundamental.

import StringIO, shutil, os, random, types, tempfile # We need these modules to write the tests.

import makefiles

class SimpleTests(unittest.TestCase):

def setUp(self):

# Create a temporary directory.

my_dir = 'testmakefiles_tempdir_' + str(random.random())[2:]

self.tempdir = os.path.join(tempfile.gettempdir(), my_dir)

os.mkdir(self.tempdir)

def tearDown(self):

# Get rid of the temporary directory.

shutil.rmtree(self.tempdir)

def exists(self, dname, fname):

return os.path.exists(os.path.join(dname, fname))

def checkFilesExist(self, d, dname):

for fname in d.keys():

assert(self.exists(dname, fname))

if type(d[fname]) == type({}):

self.checkFilesExist(d[fname], os.path.join(dname, fname))

def checkFilesDontExist(self, d, dname):

for fname in d.keys():

assert(not self.exists(dname, fname))

def testOneFile(self):

fname = 'foo.txt'

notfname = 'not_here.txt'

d = { fname: "howdy" }

assert(not self.exists(self.tempdir, fname))

assert(not self.exists(self.tempdir, notfname))

makefiles.makeFiles(d, self.tempdir)

assert(self.exists(self.tempdir, fname))

assert(not self.exists(self.tempdir, notfname))

makefiles.removeFiles(d, self.tempdir)

assert(not self.exists(self.tempdir, fname))

assert(not self.exists(self.tempdir, notfname))

def testManyFiles(self):

d = {

'top1.txt': "howdy",

'top2.txt': "hello",

'sub': {

'sub1.txt': "inside",

'sub2.txt': "inside2"

}

self.checkFilesDontExist(d, self.tempdir)

makefiles.makeFiles(d, self.tempdir)

self.checkFilesExist(d, self.tempdir)

makefiles.removeFiles(d, self.tempdir)

self.checkFilesDontExist(d, self.tempdir)

def testContents(self):

fname = 'bar.txt'

cont0 = "I am bar.txt"

d = { fname: cont0 }

makefiles.makeFiles(d, self.tempdir)

fcont1 = file(os.path.join(self.tempdir, fname))

assert(fcont1.read() == cont0)

fcont1.close()

def testDedent(self):

fname = 'dedent.txt'

d = { fname: """\

This is dedent.txt

\tTabbed in.

spaced in.

OK.

"""

}

makefiles.makeFiles(d, self.tempdir)

fcont = file(os.path.join(self.tempdir, fname))

assert(fcont.read() == "This is dedent.txt\n\tTabbed in.\n spaced in.\nOK.\n")

fcont.close()

def testRawContents(self):

fname = 'bar.txt'

cont0 = "I am bar.txt\r\nNewlines are different\nEven mixed up."

d = { fname: cont0 }

# Making them regular doesn't keep the contents identical.

makefiles.makeFiles(d, self.tempdir, raw=False)

fcont1 = file(os.path.join(self.tempdir, fname), "rb")

assert(fcont1.read() != cont0)

fcont1.close()

# Making them raw keeps all the bytes identical.

makefiles.makeFiles(d, self.tempdir, raw=True)

fcont2 = file(os.path.join(self.tempdir, fname), "rb")

assert(fcont2.read() == cont0)

fcont2.close()

if __name__ == '__main__': #pragma: no cover

unittest.main()

+ +

+ + + + + diff --git a/doc/sample_html/cogapp_test_whiteutils.html b/doc/sample_html/cogapp_test_whiteutils.html index c4bf2d20..3129e103 100644 --- a/doc/sample_html/cogapp_test_whiteutils.html +++ b/doc/sample_html/cogapp_test_whiteutils.html @@ -1,287 +1,287 @@ - - - - - - - - Coverage for cogapp\test_whiteutils: 0% - - - - - - - - - - - -

Hot-keys on this page

- r - m - x - p toggle line displays -

- j - k next/prev highlighted chunk -

- 0 (zero) top of page -

- 1 (one) first highlighted chunk -

- -

- - - - - -

100

101

102

- -

""" Test the cogapp.whiteutils module.

http://nedbatchelder.com/code/cog

"""

import unittest

from whiteutils import *

class WhitePrefixTests(unittest.TestCase):

""" Test cases for cogapp.whiteutils.

"""

def testSingleLine(self):

self.assertEqual(whitePrefix(['']), '')

self.assertEqual(whitePrefix([' ']), '')

self.assertEqual(whitePrefix(['x']), '')

self.assertEqual(whitePrefix([' x']), ' ')

self.assertEqual(whitePrefix(['\tx']), '\t')

self.assertEqual(whitePrefix([' x']), ' ')

self.assertEqual(whitePrefix([' \t \tx ']), ' \t \t')

def testMultiLine(self):

self.assertEqual(whitePrefix([' x',' x',' x']), ' ')

self.assertEqual(whitePrefix([' y',' y',' y']), ' ')

def testBlankLinesAreIgnored(self):

self.assertEqual(whitePrefix([' x',' x','',' x']), ' ')

self.assertEqual(whitePrefix(['',' x',' x',' x']), ' ')

self.assertEqual(whitePrefix([' x',' x',' x','']), ' ')

self.assertEqual(whitePrefix([' x',' x',' ',' x']), ' ')

def testTabCharacters(self):

self.assertEqual(whitePrefix(['\timport sys', '', '\tprint sys.argv']), '\t')

def testDecreasingLengths(self):

self.assertEqual(whitePrefix([' x',' x',' x']), ' ')

class ReindentBlockTests(unittest.TestCase):

""" Test cases for cogapp.reindentBlock.

"""

def testNonTermLine(self):

self.assertEqual(reindentBlock(''), '')

self.assertEqual(reindentBlock('x'), 'x')

self.assertEqual(reindentBlock(' x'), 'x')

self.assertEqual(reindentBlock('\tx'), 'x')

self.assertEqual(reindentBlock('x', ' '), ' x')

self.assertEqual(reindentBlock('x', '\t'), '\tx')

self.assertEqual(reindentBlock(' x', ' '), ' x')

self.assertEqual(reindentBlock(' x', '\t'), '\tx')

self.assertEqual(reindentBlock(' x', ' '), ' x')

def testSingleLine(self):

self.assertEqual(reindentBlock('\n'), '\n')

self.assertEqual(reindentBlock('x\n'), 'x\n')

self.assertEqual(reindentBlock(' x\n'), 'x\n')

self.assertEqual(reindentBlock('\tx\n'), 'x\n')

self.assertEqual(reindentBlock('x\n', ' '), ' x\n')

self.assertEqual(reindentBlock('x\n', '\t'), '\tx\n')

self.assertEqual(reindentBlock(' x\n', ' '), ' x\n')

self.assertEqual(reindentBlock(' x\n', '\t'), '\tx\n')

self.assertEqual(reindentBlock(' x\n', ' '), ' x\n')

def testRealBlock(self):

self.assertEqual(

reindentBlock('\timport sys\n\n\tprint sys.argv\n'),

'import sys\n\nprint sys.argv\n'

)

class CommonPrefixTests(unittest.TestCase):

""" Test cases for cogapp.commonPrefix.

"""

def testDegenerateCases(self):

self.assertEqual(commonPrefix([]), '')

self.assertEqual(commonPrefix(['']), '')

self.assertEqual(commonPrefix(['','','','','']), '')

self.assertEqual(commonPrefix(['cat in the hat']), 'cat in the hat')

def testNoCommonPrefix(self):

self.assertEqual(commonPrefix(['a','b']), '')

self.assertEqual(commonPrefix(['a','b','c','d','e','f']), '')

self.assertEqual(commonPrefix(['a','a','a','a','a','x']), '')

def testUsualCases(self):

self.assertEqual(commonPrefix(['ab', 'ac']), 'a')

self.assertEqual(commonPrefix(['aab', 'aac']), 'aa')

self.assertEqual(commonPrefix(['aab', 'aab', 'aab', 'aac']), 'aa')

def testBlankLine(self):

self.assertEqual(commonPrefix(['abc', 'abx', '', 'aby']), '')

def testDecreasingLengths(self):

self.assertEqual(commonPrefix(['abcd', 'abc', 'ab']), 'ab')

if __name__ == '__main__': #pragma: no cover

unittest.main()

- -

- - - - - + + + + + + + + Coverage for cogapp\test_whiteutils: 0% + + + + + + + + + + + +

Hot-keys on this page

+ r + m + x + p toggle line displays +

+ j + k next/prev highlighted chunk +

+ 0 (zero) top of page +

+ 1 (one) first highlighted chunk +

+ +

+ + + + + +

100

101

102

+ +

""" Test the cogapp.whiteutils module.

http://nedbatchelder.com/code/cog

"""

import unittest

from whiteutils import *

class WhitePrefixTests(unittest.TestCase):

""" Test cases for cogapp.whiteutils.

"""

def testSingleLine(self):

self.assertEqual(whitePrefix(['']), '')

self.assertEqual(whitePrefix([' ']), '')

self.assertEqual(whitePrefix(['x']), '')

self.assertEqual(whitePrefix([' x']), ' ')

self.assertEqual(whitePrefix(['\tx']), '\t')

self.assertEqual(whitePrefix([' x']), ' ')

self.assertEqual(whitePrefix([' \t \tx ']), ' \t \t')

def testMultiLine(self):

self.assertEqual(whitePrefix([' x',' x',' x']), ' ')

self.assertEqual(whitePrefix([' y',' y',' y']), ' ')

def testBlankLinesAreIgnored(self):

self.assertEqual(whitePrefix([' x',' x','',' x']), ' ')

self.assertEqual(whitePrefix(['',' x',' x',' x']), ' ')

self.assertEqual(whitePrefix([' x',' x',' x','']), ' ')

self.assertEqual(whitePrefix([' x',' x',' ',' x']), ' ')

def testTabCharacters(self):

self.assertEqual(whitePrefix(['\timport sys', '', '\tprint sys.argv']), '\t')

def testDecreasingLengths(self):

self.assertEqual(whitePrefix([' x',' x',' x']), ' ')

class ReindentBlockTests(unittest.TestCase):

""" Test cases for cogapp.reindentBlock.

"""

def testNonTermLine(self):

self.assertEqual(reindentBlock(''), '')

self.assertEqual(reindentBlock('x'), 'x')

self.assertEqual(reindentBlock(' x'), 'x')

self.assertEqual(reindentBlock('\tx'), 'x')

self.assertEqual(reindentBlock('x', ' '), ' x')

self.assertEqual(reindentBlock('x', '\t'), '\tx')

self.assertEqual(reindentBlock(' x', ' '), ' x')

self.assertEqual(reindentBlock(' x', '\t'), '\tx')

self.assertEqual(reindentBlock(' x', ' '), ' x')

def testSingleLine(self):

self.assertEqual(reindentBlock('\n'), '\n')

self.assertEqual(reindentBlock('x\n'), 'x\n')

self.assertEqual(reindentBlock(' x\n'), 'x\n')

self.assertEqual(reindentBlock('\tx\n'), 'x\n')

self.assertEqual(reindentBlock('x\n', ' '), ' x\n')

self.assertEqual(reindentBlock('x\n', '\t'), '\tx\n')

self.assertEqual(reindentBlock(' x\n', ' '), ' x\n')

self.assertEqual(reindentBlock(' x\n', '\t'), '\tx\n')

self.assertEqual(reindentBlock(' x\n', ' '), ' x\n')

def testRealBlock(self):

self.assertEqual(

reindentBlock('\timport sys\n\n\tprint sys.argv\n'),

'import sys\n\nprint sys.argv\n'

)

class CommonPrefixTests(unittest.TestCase):

""" Test cases for cogapp.commonPrefix.

"""

def testDegenerateCases(self):

self.assertEqual(commonPrefix([]), '')

self.assertEqual(commonPrefix(['']), '')

self.assertEqual(commonPrefix(['','','','','']), '')

self.assertEqual(commonPrefix(['cat in the hat']), 'cat in the hat')

def testNoCommonPrefix(self):

self.assertEqual(commonPrefix(['a','b']), '')

self.assertEqual(commonPrefix(['a','b','c','d','e','f']), '')

self.assertEqual(commonPrefix(['a','a','a','a','a','x']), '')

def testUsualCases(self):

self.assertEqual(commonPrefix(['ab', 'ac']), 'a')

self.assertEqual(commonPrefix(['aab', 'aac']), 'aa')

self.assertEqual(commonPrefix(['aab', 'aab', 'aab', 'aac']), 'aa')

def testBlankLine(self):

self.assertEqual(commonPrefix(['abc', 'abx', '', 'aby']), '')

def testDecreasingLengths(self):

self.assertEqual(commonPrefix(['abcd', 'abc', 'ab']), 'ab')

if __name__ == '__main__': #pragma: no cover

unittest.main()

+ +

+ + + + + diff --git a/doc/sample_html/cogapp_whiteutils.html b/doc/sample_html/cogapp_whiteutils.html index 2a12461a..a7ee966d 100644 --- a/doc/sample_html/cogapp_whiteutils.html +++ b/doc/sample_html/cogapp_whiteutils.html @@ -1,209 +1,209 @@ - - - - - - - - Coverage for cogapp\whiteutils: 92% - - - - - - - - - - - -

Hot-keys on this page

- r - m - x - p toggle line displays -

- j - k next/prev highlighted chunk -

- 0 (zero) top of page -

- 1 (one) first highlighted chunk -

- -

- - - - - -

- -

""" Indentation utilities for Cog.

http://nedbatchelder.com/code/cog

"""

import re

def whitePrefix(strings):

""" Determine the whitespace prefix common to all non-blank lines

in the argument list.

"""

# Remove all blank lines from the list

strings = [s for s in strings if s.strip() != '']

if not strings: return ''

# Find initial whitespace chunk in the first line.

# This is the best prefix we can hope for.

prefix = re.match(r'\s*', strings[0]).group(0)

# Loop over the other strings, keeping only as much of

# the prefix as matches each string.

for s in strings:

for i in range(len(prefix)):

27 if prefix[i] != s[i]:

prefix = prefix[:i]

break

return prefix

def reindentBlock(lines, newIndent=''):

""" Take a block of text as a string or list of lines.

Remove any common whitespace indentation.

Re-indent using newIndent, and return it as a single string.

"""

if isinstance(lines, basestring):

lines = lines.split('\n')

oldIndent = whitePrefix(lines)

outLines = []

for l in lines:

if oldIndent:

l = l.replace(oldIndent, '', 1)

if l and newIndent:

l = newIndent + l

outLines.append(l)

return '\n'.join(outLines)

def commonPrefix(strings):

""" Find the longest string that is a prefix of all the strings.

"""

52 if not strings:

return ''

prefix = strings[0]

for s in strings:

if len(s) < len(prefix):

prefix = prefix[:len(s)]

if not prefix:

return ''

for i in range(len(prefix)):

if prefix[i] != s[i]:

prefix = prefix[:i]

break

return prefix

- -

- - - - - + + + + + + + + Coverage for cogapp\whiteutils: 92% + + + + + + + + + + + +

Hot-keys on this page

+ r + m + x + p toggle line displays +

+ j + k next/prev highlighted chunk +

+ 0 (zero) top of page +

+ 1 (one) first highlighted chunk +

+ +

+ + + + + +

+ +

""" Indentation utilities for Cog.

http://nedbatchelder.com/code/cog

"""

import re

def whitePrefix(strings):

""" Determine the whitespace prefix common to all non-blank lines

in the argument list.

"""

# Remove all blank lines from the list

strings = [s for s in strings if s.strip() != '']

if not strings: return ''

# Find initial whitespace chunk in the first line.

# This is the best prefix we can hope for.

prefix = re.match(r'\s*', strings[0]).group(0)

# Loop over the other strings, keeping only as much of

# the prefix as matches each string.

for s in strings:

for i in range(len(prefix)):

27 if prefix[i] != s[i]:

prefix = prefix[:i]

break

return prefix

def reindentBlock(lines, newIndent=''):

""" Take a block of text as a string or list of lines.

Remove any common whitespace indentation.

Re-indent using newIndent, and return it as a single string.

"""

if isinstance(lines, basestring):

lines = lines.split('\n')

oldIndent = whitePrefix(lines)

outLines = []

for l in lines:

if oldIndent:

l = l.replace(oldIndent, '', 1)

if l and newIndent:

l = newIndent + l

outLines.append(l)

return '\n'.join(outLines)

def commonPrefix(strings):

""" Find the longest string that is a prefix of all the strings.

"""

52 if not strings:

return ''

prefix = strings[0]

for s in strings:

if len(s) < len(prefix):

prefix = prefix[:len(s)]

if not prefix:

return ''

for i in range(len(prefix)):

if prefix[i] != s[i]:

prefix = prefix[:i]

break

return prefix

+ +

+ + + + + diff --git a/doc/sample_html/index.html b/doc/sample_html/index.html index a74426e0..2d4eaab4 100644 --- a/doc/sample_html/index.html +++ b/doc/sample_html/index.html @@ -1,173 +1,173 @@ - - - - - Coverage report - - - - - - - - - - - -

Hot-keys on this page

- n - s - m - x - - b - p - - c change column sorting -

- -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Module	statements	missing	excluded	branches	partial	coverage
Total	1175	721	27	207	125	39%
cogapp\__init__	1	1	0	0	0	0%
cogapp\cogapp	387	168	3	153	99	51%
cogapp\makefiles	29	23	3	16	16	13%
cogapp\test_cogapp	587	392	17	4	2	33%
cogapp\test_makefiles	66	66	2	6	6	0%
cogapp\test_whiteutils	68	68	2	0	0	0%
cogapp\whiteutils	37	3	0	28	2	92%

- - - - - + + + + + Coverage report + + + + + + + + + + + +

Hot-keys on this page

+ n + s + m + x + + b + p + + c change column sorting +

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Module	statements	missing	excluded	branches	partial	coverage
Total	1175	721	27	207	28	46%
cogapp\__init__	1	1	0	0	0	0%
cogapp\cogapp	387	168	3	153	26	64%
cogapp\makefiles	29	23	3	16	0	49%
cogapp\test_cogapp	587	392	17	4	0	34%
cogapp\test_makefiles	66	66	2	6	0	8%
cogapp\test_whiteutils	68	68	2	0	0	0%
cogapp\whiteutils	37	3	0	28	2	92%

+ + + + + diff --git a/doc/sample_html/status.dat b/doc/sample_html/status.dat index 4d00624b..6ad7a1c4 100644 --- a/doc/sample_html/status.dat +++ b/doc/sample_html/status.dat @@ -49,7 +49,7 @@ p23 I392 sS'n_missing_branches' p24 -I2 +I0 sbssS'hash' p25 S'\xc6E_\xdc&\x1f\xac\xb5\xfb\xcc\x1cV(tJ/' @@ -118,7 +118,7 @@ I2 sg23 I66 sg24 -I6 +I0 sbssg25 S'\xec\xe2\x91\xf3H\xa4\xaa+Q\x7f\xfc=&\xa0\xd8\xc0' p42 @@ -152,7 +152,7 @@ I3 sg23 I23 sg24 -I16 +I0 sbssg25 S'\x05\xa2M\xca=\x19\xb6\x1d_\xc46\x84p\xd5S&' p50 @@ -220,7 +220,7 @@ I3 sg23 I168 sg24 -I99 +I26 sbssg25 S'\x10\xe2\xbci\xd1jzzh\xa8\xa1r\xfb\xab\xe9\x13' p66 @@ -260,11 +260,11 @@ S'E\xf4\xbf \t\x8a\xfe5,][]\xcc\x12}\x97' p74 sssS'version' p75 -S'3.5' +S'3.5.1' p76 sS'settings' p77 -S"\xf7F\xe7^\xa8*x{\xec-'\x9c\xfb\x0ej\xa4" +S'\xfe\xa4\x01e\x06\x8a\x97H\x97\xaf\xbf\xcd\xfez\xe4\xbf' p78 sS'format' p79 -- cgit v1.2.1

Coverage for cogapp\init : - 0% -

- 1 statements - 0 run - 1 missing - 0 excluded - - 0 partial - -

Coverage for cogapp\init : + 0% +

+ 1 statements + 0 run + 1 missing + 0 excluded + + 0 partial + +

Coverage for cogapp\cogapp : - 51% -

- 387 statements - 219 run - 168 missing - 3 excluded - - 26 partial - -

Coverage for cogapp\cogapp : + 64% +

+ 387 statements + 219 run + 168 missing + 3 excluded + + 26 partial + +

Coverage for cogapp\makefiles : - 13% -

- 29 statements - 6 run - 23 missing - 3 excluded - - 0 partial - -

Coverage for cogapp\makefiles : + 49% +

+ 29 statements + 6 run + 23 missing + 3 excluded + + 0 partial + +

Coverage for cogapp\test_cogapp : - 33% -

- 587 statements - 195 run - 392 missing - 17 excluded - - 0 partial - -

Coverage for cogapp\test_cogapp : + 34% +

+ 587 statements + 195 run + 392 missing + 17 excluded + + 0 partial + +

Coverage for cogapp\test_makefiles : - 0% -

- 66 statements - 0 run - 66 missing - 2 excluded - - 0 partial - -

Coverage for cogapp\test_makefiles : + 8% +

+ 66 statements + 0 run + 66 missing + 2 excluded + + 0 partial + +

Coverage for cogapp\test_whiteutils : - 0% -

- 68 statements - 0 run - 68 missing - 2 excluded - - 0 partial - -

Coverage for cogapp\test_whiteutils : + 0% +

+ 68 statements + 0 run + 68 missing + 2 excluded + + 0 partial + +

Coverage for cogapp\whiteutils : - 92% -

- 37 statements - 34 run - 3 missing - 0 excluded - - 2 partial - -

Coverage for cogapp\whiteutils : + 92% +

+ 37 statements + 34 run + 3 missing + 0 excluded + + 2 partial + +

Coverage report: - 39% -

Coverage report: + 46% +

Coverage for cogapp\__init__ : - 0% -

- 1 statements - 0 run - 1 missing - 0 excluded - - 0 partial - -

Coverage for cogapp\__init__ : + 0% +

+ 1 statements + 0 run + 1 missing + 0 excluded + + 0 partial + +

Coverage for cogapp\cogapp : - 51% -

- 387 statements - 219 run - 168 missing - 3 excluded - - 26 partial - -

Coverage for cogapp\cogapp : + 64% +

+ 387 statements + 219 run + 168 missing + 3 excluded + + 26 partial + +

Coverage for cogapp\makefiles : - 13% -

- 29 statements - 6 run - 23 missing - 3 excluded - - 0 partial - -

Coverage for cogapp\makefiles : + 49% +

+ 29 statements + 6 run + 23 missing + 3 excluded + + 0 partial + +

Coverage for cogapp\test_cogapp : - 33% -

- 587 statements - 195 run - 392 missing - 17 excluded - - 0 partial - -

Coverage for cogapp\test_cogapp : + 34% +

+ 587 statements + 195 run + 392 missing + 17 excluded + + 0 partial + +

Coverage for cogapp\test_makefiles : - 0% -

- 66 statements - 0 run - 66 missing - 2 excluded - - 0 partial - -

Coverage for cogapp\test_makefiles : + 8% +

+ 66 statements + 0 run + 66 missing + 2 excluded + + 0 partial + +

Coverage for cogapp\test_whiteutils : - 0% -

- 68 statements - 0 run - 68 missing - 2 excluded - - 0 partial - -

Coverage for cogapp\test_whiteutils : + 0% +

+ 68 statements + 0 run + 68 missing + 2 excluded + + 0 partial + +

Coverage for cogapp\whiteutils : - 92% -

- 37 statements - 34 run - 3 missing - 0 excluded - - 2 partial - -

Coverage for cogapp\whiteutils : + 92% +

+ 37 statements + 34 run + 3 missing + 0 excluded + + 2 partial + +

Coverage report: - 39% -

Coverage report: + 46% +

Coverage for cogapp\init : - 0% -

Coverage for cogapp\init : + 0% +