for t in tlist:

if t.side_effect:

raise UserError, "Multiple ways to build the same target were specified for: %s" % str(t)

if t.env != env:

raise UserError, "Two different environments were specified for the same target: %s"%str(t)

elif t.overrides != overrides:

return self.name

def builder_set(self, builder):

self.builder = builder

return not self.builder is None

def env_set(self, env, safe=0):

self.env = env

import SCons.Scanner.Fortran

import SCons.Scanner.Prog

def alias_builder(env, target, source):

pass

CachePush = SCons.Action.Action(CachePushFunc, None)

#

class ParentOfRoot:

"""

return path_elems

def src_builder(self):

if os.path.normcase("TeSt") == os.path.normpath("TeSt"):

def _my_normcase(x):

try:

return self._exists

except AttributeError:

return self._exists

def rexists(self):

self.pathTop = path

self.Root = {}

self.Top = None

self.CachePath = None

self.cache_force = None

self.cache_show = None

assert not self.Top, "You can only set the top-level path on an FS object that has not had its File, Dir, or Entry methods called yet."

self.pathTop = path

def __setTopLevelDir(self):

if not self.Top:

# Go up one directory

d = d.get_dir()

return None

def Rsearchall(self, pathlist, must_exist=1, clazz=_classEntry, cwd=None):

"""Search for a list of somethings in the Repository list."""

d = n.get_dir()

name = n.name

while d:

for rep in d.getRepositories():

try:

rnode = self.__doLookup(clazz, name, rep)

if (not must_exist or rnode.exists()) and \

(not rnode.has_builder() or isinstance(rnode, Dir)):

ret.append(rnode)

else:

return 0

def sconsign(self):

"""Return the .sconsign file info for this directory,

creating it first if necessary."""

so only do thread safe stuff here. Do thread unsafe stuff in

built().

"""

return

if self.fs.cache_show:

if CacheRetrieveSilent(self, None, None) == 0:

def do_print(action, targets, sources, env, self=self):

if self.fs.CachePath and self.fs.cache_force and os.path.exists(self.path):

CachePush(self, None, None)

"""

try:

except AttributeError:

else:

def prepare(self):

"""Prepare for this file to be created."""

def missing(node):

missing_sources = filter(missing, self.children())

if missing_sources:

desc = "No Builder for target `%s', needed by `%s'." % (missing_sources[0], self)

assert str(f) == os.path.join('sub', 'file')

assert not f.exists()

def runTest(self):

test = TestCmd(workdir = '')

fs = SCons.Node.FS.FS(test.workpath(''))

os.chdir(test.workpath(''))

assert not h, h

b1 = Builder(fs.File)

assert not h, h

assert not h, h

assert h, h

assert f3.builder is b1, f3.builder

assert not h, h

assert h, h

class prepareTestCase(unittest.TestCase):

a = dir.get_actions()

assert a == [], a

def runTest(self):

fs = SCons.Node.FS.FS()

class CacheDirTestCase(unittest.TestCase):

def runTest(self):

suite.addTest(RepositoryTestCase())

suite.addTest(find_fileTestCase())

suite.addTest(StringDirTestCase())

suite.addTest(prepareTestCase())

suite.addTest(get_actionsTestCase())

suite.addTest(CacheDirTestCase())

if not unittest.TextTestRunner().run(suite).wasSuccessful():

sys.exit(1)

"""Test the has_builder() method

"""

n1 = SCons.Node.Node()

n2 = SCons.Node.Node()

n3 = SCons.Node.Node()

n2.builder_set(Builder())

def test_builder_sig_adapter(self):

"""Test the node's adapter for builder signatures

def builder_set(self, builder):

self.builder = builder

"""Return whether this Node has a builder or not.

In Boolean tests, this turns out to be a *lot* more efficient

b = self.builder

return not b is None

def builder_sig_adapter(self):

"""Create an adapter for calculating a builder's signature.

import SCons.Node

import SCons.Node.FS

import SCons.Platform

import SCons.Tool

import SCons.Util

import SCons.Options

default_fs = SCons.Node.FS.default_fs

top = default_fs.Top

# evaluate each SConscript file

results = []

default_fs.chdir(top, change_os_dir=1)

if f.rexists():

_file_ = open(f.rstr(), "r")

# The SConscript file apparently exists in a source

# code management system. Build it, but then clear

# the builder so that it doesn't get built *again*

raise SCons.Errors.UserError, "Unknown build signature type '%s'"%type

def SetContentSignatureType(type):

if type == 'MD5':

import SCons.Sig.MD5

SCons.Script.sig_module = SCons.Sig.MD5

def BuildDefaultGlobals():

"""

Create a dictionary containing all the default globals for

"""

globals = {}

globals['Action'] = SCons.Action.Action

globals['AddPostAction'] = AddPostAction

globals['AddPreAction'] = AddPreAction

# 'lib',

# 'scons-%d' % SCons.__version__)] + sys.path[1:]

import SCons.Errors

import SCons.Job

import SCons.Node

SCons.Node.FS.default_fs.set_toplevel_dir(os.getcwd())

scripts = []

if options.file:

scripts.extend(options.file)

if not scripts:

raise SCons.Errors.UserError, "No SConstruct file found."

class Unbuffered:

def __init__(self, file):

This unlinks all targets and makes all directories before

building anything."""

if self.targets[0].get_state() != SCons.Node.up_to_date:

for t in self.targets:

t.prepare()

so only do thread safe stuff here. Do thread unsafe stuff in

prepare(), executed() or failed()."""

try:

self.targets[0].build()

except KeyboardInterrupt:

# Add derived files that have not been built

# to the candidates list:

def derived(node):

if derived:

derived.reverse()

self.candidates.extend(self.order(derived))

def has_builder(self):

return not self.builder is None

def built(self):

global built_text

built_text = built_text + " really"

assert n1.prepared

assert n2.prepared

def test_execute(self):

"""Test executing a task

else:

raise TestFailed, "did not catch expected BuildError"

def test_exception(self):

"""Test generic Taskmaster exception handling