def testExpansionMask( self ) :
n1 = GafferTest.StringInOutNode( substitutions = Gaffer.Context.Substitutions.AllSubstitutions )
n2 = GafferTest.StringInOutNode( substitutions = Gaffer.Context.Substitutions.AllSubstitutions & ~Gaffer.Context.Substitutions.FrameSubstitutions )
n1["in"].setValue( "hello.####.${ext}" )
n2["in"].setValue( "hello.####.${ext}" )
self.assertEqual( n1["out"].getValue(), os.path.expanduser( "hello.0001." ) )
self.assertEqual( n2["out"].getValue(), os.path.expanduser( "hello.####." ) )
c = Gaffer.Context()
c["ext"] = "cob"
c.setFrame( 10 )
with c :
self.assertEqual( n1["out"].getValue(), os.path.expanduser( "hello.0010.cob" ) )
self.assertEqual( n2["out"].getValue(), os.path.expanduser( "hello.####.cob" ) )
def testPlugFlagsOnReload( self ): s = Gaffer.ScriptNode() s["b"] = Gaffer.Box() s["b"]["s"] = GafferTest.StringInOutNode() s["b"]["a"] = GafferTest.AddNode() s["b"].exportForReference( self.temporaryDirectory() + "/test.grf" ) # import it into a script. s2 = Gaffer.ScriptNode() s2["r"] = Gaffer.Reference() s2["r"].load( self.temporaryDirectory() + "/test.grf" ) s2["r"]["__pluggy"] = Gaffer.Plug( flags = Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) s2["r"]["__pluggy"]["int"] = Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) s2["r"]["__pluggy"]["compound"] = Gaffer.Plug( flags = Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) s2["r"]["__pluggy"]["compound"]["int"] = Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) self.assertEqual( s2["r"]["__pluggy"].getFlags(), Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) self.assertEqual( s2["r"]["__pluggy"]["int"].getFlags(), Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) self.assertEqual( s2["r"]["__pluggy"]["compound"].getFlags(), Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) self.assertEqual( s2["r"]["__pluggy"]["compound"]["int"].getFlags(), Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) s2["r"].load( self.temporaryDirectory() + "/test.grf" ) self.assertEqual( s2["r"]["__pluggy"].getFlags(), Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) self.assertEqual( s2["r"]["__pluggy"]["int"].getFlags(), Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) self.assertEqual( s2["r"]["__pluggy"]["compound"].getFlags(), Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default ) self.assertEqual( s2["r"]["__pluggy"]["compound"]["int"].getFlags(), Gaffer.Plug.Flags.Dynamic | Gaffer.Plug.Flags.Default )
def testPatternMatching(self):
n = GafferTest.StringInOutNode()
self.assertHashesValid(n)
d = Gaffer.DeleteContextVariablesComputeNode()
d["in"] = Gaffer.StringPlug()
d["out"] = Gaffer.StringPlug(direction=Gaffer.Plug.Direction.Out)
d["in"].setInput(n["out"])
c = Gaffer.ContextVariablesComputeNode()
c["in"] = Gaffer.StringPlug()
c["out"] = Gaffer.StringPlug(direction=Gaffer.Plug.Direction.Out)
c["in"].setInput(d["out"])
n["in"].setValue("$a1_$a2_$b1_$b2_$c1_$c2")
self.assertEqual(c["out"].getValue(), "_____")
c["variables"].addMember("a1", IECore.StringData("A1"))
c["variables"].addMember("a2", IECore.StringData("A2"))
c["variables"].addMember("b1", IECore.StringData("B1"))
c["variables"].addMember("b2", IECore.StringData("B2"))
c["variables"].addMember("c1", IECore.StringData("C1"))
c["variables"].addMember("c2", IECore.StringData("C2"))
self.assertEqual(c["out"].getValue(), "A1_A2_B1_B2_C1_C2")
d["variables"].setValue("a* c*")
self.assertEqual(c["out"].getValue(), "__B1_B2__")
def testDirtyPropagation(self):
n = GafferTest.StringInOutNode()
c = Gaffer.ContextVariables()
c.setup(Gaffer.StringPlug())
c["in"].setInput(n["out"])
# adding a variable should dirty the output:
dirtied = GafferTest.CapturingSlot(c.plugDirtiedSignal())
c["variables"].addChild(
Gaffer.NameValuePlug("a",
IECore.StringData("A"),
"member1",
flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic))
self.assertIn(c["out"], [p[0] for p in dirtied])
# modifying the variable should dirty the output:
dirtied = GafferTest.CapturingSlot(c.plugDirtiedSignal())
c["variables"]["member1"]["value"].setValue("b")
self.assertIn(c["out"], [p[0] for p in dirtied])
# removing the variable should also dirty the output:
dirtied = GafferTest.CapturingSlot(c.plugDirtiedSignal())
c["variables"].removeChild(c["variables"]["member1"])
self.assertIn(c["out"], [p[0] for p in dirtied])
def testExtraVariables(self):
s = Gaffer.ScriptNode()
s["n"] = GafferTest.StringInOutNode()
s["c"] = Gaffer.ContextVariablesComputeNode()
s["c"]["in"] = Gaffer.StringPlug(flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["c"]["out"] = Gaffer.StringPlug(direction=Gaffer.Plug.Direction.Out,
flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["c"]["in"].setInput(s["n"]["out"])
s["n"]["in"].setValue("$a")
self.assertEqual(s["c"]["out"].getValue(), "")
dirtied = GafferTest.CapturingSlot(s["c"].plugDirtiedSignal())
s["c"]["extraVariables"].setValue(IECore.CompoundData({"a": "A"}))
self.failUnless(s["c"]["out"] in {p[0] for p in dirtied})
self.assertEqual(s["c"]["out"].getValue(), "A")
# Extra variables trump regular variables of the same name
s["c"]["variables"].addMember("a", IECore.StringData("B"))
self.assertEqual(s["c"]["out"].getValue(), "A")
s2 = Gaffer.ScriptNode()
s2.execute(s.serialise())
self.assertEqual(s2["c"]["out"].getValue(), "A")
def testFactory( self ) : node = GafferTest.StringInOutNode() self.assertTrue( GafferUI.View.create( node["out"] ) is None ) # check that we can make our own view and register it for the node class MyView( GafferUI.View ) : def __init__( self, viewedPlug = None ) : GafferUI.View.__init__( self, "MyView", Gaffer.StringPlug( "in" ) ) self["in"].setInput( viewedPlug ) GafferUI.View.registerView( GafferTest.StringInOutNode, "out", MyView ) view = GafferUI.View.create( node["out"] ) self.assertTrue( isinstance( view, MyView ) ) self.assertTrue( view["in"].getInput().isSame( node["out"] ) ) # and check that that registration leaves other nodes alone n = Gaffer.Node() n["out"] = Gaffer.StringPlug( direction = Gaffer.Plug.Direction.Out ) self.assertTrue( GafferUI.View.create( n["out"] ) is None )
def testExtraVariables( self ) :
s = Gaffer.ScriptNode()
s["n"] = GafferTest.StringInOutNode()
s["c"] = Gaffer.ContextVariables()
s["c"].setup( Gaffer.StringPlug() )
s["c"]["in"].setInput( s["n"]["out"] )
s["n"]["in"].setValue( "$a" )
self.assertEqual( s["c"]["out"].getValue(), "" )
dirtied = GafferTest.CapturingSlot( s["c"].plugDirtiedSignal() )
s["c"]["extraVariables"].setValue( IECore.CompoundData( { "a" : "A" } ) )
self.failUnless( s["c"]["out"] in { p[0] for p in dirtied } )
self.assertEqual( s["c"]["out"].getValue(), "A" )
# Extra variables trump regular variables of the same name
s["c"]["variables"].addChild( Gaffer.NameValuePlug( "a", IECore.StringData( "B" ) ) )
self.assertEqual( s["c"]["out"].getValue(), "A" )
s2 = Gaffer.ScriptNode()
s2.execute( s.serialise() )
self.assertEqual( s2["c"]["out"].getValue(), "A" )
def testDefaultValueExpansion(self):
n = GafferTest.StringInOutNode(defaultValue="${A}")
context = Gaffer.Context()
context["A"] = "b"
with context:
self.assertEqual(n["out"].getValue(), "b")
def testDeriving( self ) : class MyView( GafferImageUI.ImageView ) : def __init__( self, viewedPlug = None ) : GafferImageUI.ImageView.__init__( self, "MyView" ) converter = Gaffer.Node() converter["in"] = Gaffer.StringPlug() converter["out"] = GafferImage.ImagePlug( direction = Gaffer.Plug.Direction.Out ) converter["text"] = GafferImage.Text() converter["text"]["text"].setInput( converter["in"] ) converter["out"].setInput( converter["text"]["out"] ) self._insertConverter( converter ) self["in"].setInput( viewedPlug ) GafferUI.View.registerView( GafferTest.StringInOutNode, "out", MyView ) string = GafferTest.StringInOutNode() view = GafferUI.View.create( string["out"] ) self.assertTrue( isinstance( view, MyView ) ) self.assertTrue( view["in"].getInput().isSame( string["out"] ) ) self.assertTrue( isinstance( view["in"], Gaffer.StringPlug ) ) view["exposure"].setValue( 1 ) view["gamma"].setValue( 0.5 )
def testPatternMatching( self ) : n = GafferTest.StringInOutNode() self.assertHashesValid( n ) d = Gaffer.DeleteContextVariables() d.setup( Gaffer.StringPlug() ) d["in"].setInput( n["out"] ) c = Gaffer.ContextVariables() c.setup( Gaffer.StringPlug() ) c["in"].setInput( d["out"] ) n["in"].setValue( "$a1_$a2_$b1_$b2_$c1_$c2" ) self.assertEqual( c["out"].getValue(), "_____" ) c["variables"].addChild( Gaffer.NameValuePlug( "a1", IECore.StringData( "A1" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) ) c["variables"].addChild( Gaffer.NameValuePlug( "a2", IECore.StringData( "A2" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) ) c["variables"].addChild( Gaffer.NameValuePlug( "b1", IECore.StringData( "B1" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) ) c["variables"].addChild( Gaffer.NameValuePlug( "b2", IECore.StringData( "B2" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) ) c["variables"].addChild( Gaffer.NameValuePlug( "c1", IECore.StringData( "C1" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) ) c["variables"].addChild( Gaffer.NameValuePlug( "c2", IECore.StringData( "C2" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) ) self.assertEqual( c["out"].getValue(), "A1_A2_B1_B2_C1_C2" ) d["variables"].setValue( "a* c*" ) self.assertEqual( c["out"].getValue(), "__B1_B2__" )
def testRowAccessorWithComputedNames(self):
n = GafferTest.StringInOutNode()
n["in"].setValue("x")
s = Gaffer.Spreadsheet()
r = s["rows"].addRow()
r["name"].setInput(n["out"])
self.assertEqual(s["rows"].row("x"), None)
def testRecursiveExpansion(self):
n = GafferTest.StringInOutNode()
n["in"].setValue("$a")
context = Gaffer.Context()
context["a"] = "a$b"
context["b"] = "b"
with context:
self.assertEqual(n["out"].getValue(), "ab")
def testRecursiveExpansionCycles(self):
n = GafferTest.StringInOutNode()
n["in"].setValue("$a")
context = Gaffer.Context()
context["a"] = "a$b"
context["b"] = "b$a"
with context:
self.assertRaises(RuntimeError, n["out"].getValue)
def testDirtyPropagation( self ) : n = GafferTest.StringInOutNode() d = Gaffer.DeleteContextVariables() d.setup( Gaffer.StringPlug() ) d["in"].setInput( n["out"] ) # deleting a variable should dirty the output: dirtied = GafferTest.CapturingSlot( d.plugDirtiedSignal() ) d["variables"].setValue( "a" ) self.failUnless( d["out"] in [ p[0] for p in dirtied ] )
def test( self ) : n = GafferTest.StringInOutNode() self.assertHashesValid( n ) c = Gaffer.ContextVariables() c.setup( Gaffer.StringPlug() ) c["in"].setInput( n["out"] ) n["in"].setValue( "$a" ) self.assertEqual( c["out"].getValue(), "" ) c["variables"].addChild( Gaffer.NameValuePlug( "a", IECore.StringData( "A" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) self.assertEqual( c["out"].getValue(), "A" )
def testTildeExpansion( self ) : n = GafferTest.StringInOutNode() n["in"].setValue( "~" ) self.assertEqual( n["out"].getValue(), os.path.expanduser( "~" ) ) n["in"].setValue( "~/something.tif" ) self.assertEqual( n["out"].getValue(), os.path.expanduser( "~/something.tif" ) ) # ~ shouldn't be expanded unless it's at the front - it would # be meaningless in other cases. n["in"].setValue( "in ~1900" ) self.assertEqual( n["out"].getValue(), "in ~1900" )
def test(self):
n = GafferTest.StringInOutNode()
self.assertHashesValid(n)
c = Gaffer.ContextVariables()
c.setup(Gaffer.StringPlug())
c["in"].setInput(n["out"])
n["in"].setValue("$a")
self.assertEqual(c["out"].getValue(), "")
c["variables"].addMember("a", IECore.StringData("A"))
self.assertEqual(c["out"].getValue(), "A")
def testExpansionFromInputConnection(self):
p = Gaffer.StringPlug()
p.setValue("${foo}")
n = GafferTest.StringInOutNode()
n["in"].setInput(p)
c = Gaffer.Context()
with c:
self.assertEqual(n["out"].getValue(), "")
h = n["out"].hash()
c["foo"] = "foo"
with c:
self.assertNotEqual(n["out"].hash(), h)
self.assertEqual(n["out"].getValue(), "foo")
def testExpansion(self):
n = GafferTest.StringInOutNode()
self.assertHashesValid(n)
# nothing should be expanded when we're in a non-computation context
n["in"].setValue("testyTesty.##.exr")
self.assertEqual(n["in"].getValue(), "testyTesty.##.exr")
n["in"].setValue("${a}/$b/${a:b}")
self.assertEqual(n["in"].getValue(), "${a}/$b/${a:b}")
# but expansions should happen magically when the compute()
# calls getValue().
context = Gaffer.Context()
context.setFrame(10)
n["in"].setValue("testyTesty.###.exr")
with context:
self.assertEqual(n["out"].getValue(), "testyTesty.010.exr")
context["A"] = "apple"
n["in"].setValue("what a lovely $A")
with context:
self.assertEqual(n["out"].getValue(), "what a lovely apple")
n["in"].setValue("what a lovely ${A}")
with context:
self.assertEqual(n["out"].getValue(), "what a lovely apple")
context["A"] = "peach"
with context:
self.assertEqual(n["out"].getValue(), "what a lovely peach")
context["env:dir"] = "a/path"
n["in"].setValue("a/${env:dir}/b")
with context:
self.assertEqual(n["out"].getValue(), "a/a/path/b")
n["in"].setValue("$dontExist")
with context:
self.assertEqual(n["out"].getValue(), "")
# once again, nothing should be expanded when we're in a
# non-computation context
n["in"].setValue("testyTesty.##.exr")
self.assertEqual(n["in"].getValue(), "testyTesty.##.exr")
def testLoadThrowsExceptionsOnError( self ) : s = Gaffer.ScriptNode() s["b"] = Gaffer.Box() s["b"]["n"] = GafferTest.StringInOutNode() s["b"].exportForReference( self.temporaryDirectory() + "/test.grf" ) del GafferTest.StringInOutNode # induce a failure during loading s2 = Gaffer.ScriptNode() s2["r"] = Gaffer.Reference() with IECore.CapturingMessageHandler() as mh : self.assertRaises( Exception, s2["r"].load, self.temporaryDirectory() + "/test.grf" ) self.assertEqual( len( mh.messages ), 2 ) self.assertTrue( "has no attribute 'StringInOutNode'" in mh.messages[0].message ) self.assertTrue( "KeyError: 'n'" in mh.messages[1].message )
def testHashUsesValue(self):
script = Gaffer.ScriptNode()
script["node"] = GafferTest.StringInOutNode()
script["expression"] = Gaffer.Expression()
script["expression"].setExpression(
"""parent["node"]["in"] = str( min( context.getFrame(), 10.0 ) )"""
)
hashes = {}
with Gaffer.Context() as context:
for i in range(0, 20):
context.setFrame(i)
hashes[i] = str(script["node"]["in"].hash())
self.assertEqual(len(set(hashes.values())), 11)
for i in range(10, 20):
self.assertEqual(hashes[i], hashes[10])
def testExtraVariablesExpression(self):
s = Gaffer.ScriptNode()
s["n"] = GafferTest.StringInOutNode()
s["c"] = Gaffer.ContextVariablesComputeNode()
s["c"]["in"] = Gaffer.StringPlug(flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["c"]["out"] = Gaffer.StringPlug(direction=Gaffer.Plug.Direction.Out,
flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["c"]["in"].setInput(s["n"]["out"])
s["n"]["in"].setValue("$a$b$c")
self.assertEqual(s["c"]["out"].getValue(), "")
s["e"] = Gaffer.Expression()
s["e"].setExpression(
inspect.cleandoc("""
result = IECore.CompoundData()
if context.getFrame() > 1 :
result["a"] = "A"
if context.getFrame() > 2 :
result["b"] = "B"
if context.getFrame() > 3 :
result["c"] = "C"
parent["c"]["extraVariables"] = result
"""))
with Gaffer.Context() as c:
self.assertEqual(s["c"]["out"].getValue(), "")
c.setFrame(2)
self.assertEqual(s["c"]["out"].getValue(), "A")
c.setFrame(3)
self.assertEqual(s["c"]["out"].getValue(), "AB")
c.setFrame(4)
self.assertEqual(s["c"]["out"].getValue(), "ABC")
def testEnvironmentExpansion(self):
n = GafferTest.StringInOutNode()
n["in"].setValue("${NOT_AN_ENVIRONMENT_VARIABLE}")
h1 = n["out"].hash()
self.assertEqual(n["out"].getValue(), "")
n["in"].setValue("${GAFFER_ROOT}")
self.assertEqual(n["out"].getValue(), os.environ["GAFFER_ROOT"])
h2 = n["out"].hash()
self.assertNotEqual(h1, h2)
context = Gaffer.Context()
context["GAFFER_ROOT"] = "b"
with context:
# context should win against environment
self.assertEqual(n["out"].getValue(), "b")
self.assertNotEqual(n["out"].hash(), h1)
self.assertNotEqual(n["out"].hash(), h2)
def testSerialisation( self ) : s = Gaffer.ScriptNode() s["n"] = GafferTest.StringInOutNode() s["c"] = Gaffer.ContextVariables() s["c"].setup( Gaffer.StringPlug() ) s["c"]["in"].setInput( s["n"]["out"] ) s["n"]["in"].setValue( "$a" ) self.assertEqual( s["c"]["out"].getValue(), "" ) s["c"]["variables"].addChild( Gaffer.NameValuePlug( "a", IECore.StringData( "A" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) self.assertEqual( s["c"]["out"].getValue(), "A" ) s2 = Gaffer.ScriptNode() s2.execute( s.serialise() ) self.assertEqual( s2["c"].keys(), s["c"].keys() ) self.assertEqual( s2["c"]["out"].getValue(), "A" )
def testSerialisation(self):
s = Gaffer.ScriptNode()
s["n"] = GafferTest.StringInOutNode()
s["c"] = Gaffer.ContextVariables()
s["c"].setup(Gaffer.StringPlug())
s["c"]["in"].setInput(s["n"]["out"])
s["n"]["in"].setValue("$a")
self.assertEqual(s["c"]["out"].getValue(), "")
s["c"]["variables"].addMember("a", IECore.StringData("A"))
self.assertEqual(s["c"]["out"].getValue(), "A")
s2 = Gaffer.ScriptNode()
s2.execute(s.serialise())
self.assertEqual(s2["c"].keys(), s["c"].keys())
self.assertEqual(s2["c"]["out"].getValue(), "A")
def testEnabledPlugTypeConversion(self):
plane = GafferScene.Plane()
string = GafferTest.StringInOutNode()
processor = GafferScene.StandardAttributes()
processor["in"].setInput(plane["out"])
processor["attributes"]["doubleSided"]["enabled"].setValue(True)
processor["attributes"]["doubleSided"]["value"].setValue(True)
processor["enabled"].setInput(string["out"])
string["in"].setValue("")
self.assertScenesEqual(processor["in"], processor["out"])
self.assertSceneHashesEqual(processor["in"], processor["out"])
string["in"].setValue("x")
self.assertNotEqual(processor["in"].attributes("/plane"),
processor["out"].attributes("/plane"))
self.assertNotEqual(processor["in"].attributesHash("/plane"),
processor["out"].attributesHash("/plane"))
def testEnvironmentExpansion(self):
n = GafferTest.StringInOutNode()
n["in"].setValue("${A}")
h1 = n["out"].hash()
self.assertEqual(n["out"].getValue(), "")
os.environ["A"] = "a"
self.assertEqual(n["out"].getValue(), "a")
h2 = n["out"].hash()
self.assertNotEqual(h1, h2)
context = Gaffer.Context()
context["A"] = "b"
with context:
# context should win against environment
self.assertEqual(n["out"].getValue(), "b")
self.assertNotEqual(n["out"].hash(), h1)
self.assertNotEqual(n["out"].hash(), h2)
def testSerialisation( self ) : s = Gaffer.ScriptNode() s["n"] = GafferTest.StringInOutNode() s["c"] = Gaffer.ContextVariablesComputeNode() s["c"]["in"] = Gaffer.StringPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["c"]["out"] = Gaffer.StringPlug( direction = Gaffer.Plug.Direction.Out, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["c"]["in"].setInput( s["n"]["out"] ) s["n"]["in"].setValue( "$a" ) self.assertEqual( s["c"]["out"].getValue(), "" ) s["c"]["variables"].addMember( "a", IECore.StringData( "A" ) ) self.assertEqual( s["c"]["out"].getValue(), "A" ) s2 = Gaffer.ScriptNode() s2.execute( s.serialise() ) self.assertEqual( s2["c"].keys(), s["c"].keys() ) self.assertEqual( s2["c"]["out"].getValue(), "A" )
def testErrorTolerantLoading( self ) : # make a box containing 2 nodes, and export it. s = Gaffer.ScriptNode() s["b"] = Gaffer.Box() s["b"]["s"] = GafferTest.StringInOutNode() s["b"]["a"] = GafferTest.AddNode() s["b"].exportForReference( self.temporaryDirectory() + "/test.grf" ) # import it into a script. s2 = Gaffer.ScriptNode() s2["r"] = Gaffer.Reference() s2["r"].load( self.temporaryDirectory() + "/test.grf" ) self.assertTrue( "a" in s2["r"] ) self.assertTrue( isinstance( s2["r"]["a"], GafferTest.AddNode ) ) # save that script, and then mysteriously # disable GafferTest.StringInOutNode. s2["fileName"].setValue( self.temporaryDirectory() + "/test.gfr" ) s2.save() del GafferTest.StringInOutNode # load the script, and check that we could at least # load in the other referenced node. s3 = Gaffer.ScriptNode() s3["fileName"].setValue( self.temporaryDirectory() + "/test.gfr" ) with IECore.CapturingMessageHandler() as mh : s3.load( continueOnError=True ) self.assertTrue( len( mh.messages ) ) self.assertTrue( "a" in s3["r"] ) self.assertTrue( isinstance( s3["r"]["a"], GafferTest.AddNode ) )
def testPrecomputedHash(self):
n = GafferTest.StringInOutNode()
n["in"].setValue("hi")
self.assertEqual(n["out"].getValue(), "hi")
self.assertEqual(n.numHashCalls, 1)
self.assertEqual(n.numComputeCalls, 1)
h = n["out"].hash()
numHashCalls = n.numHashCalls
# Accept either 1 or 2 - it would be reasonable for the ValuePlug
# to have either cached the hash or not, but that's not what we're
# testing here.
self.assertTrue(numHashCalls == 1 or numHashCalls == 2)
self.assertEqual(n.numComputeCalls, 1)
# What we care about is that calling getValue() with a precomputed hash
# definitely doesn't recompute the hash again.
self.assertEqual(n["out"].getValue(_precomputedHash=h), "hi")
self.assertEqual(n.numHashCalls, numHashCalls)
self.assertEqual(n.numComputeCalls, 1)
