def test_removeMultiInstance_pass():
"""Test MDGModfifier::removeMultiInstance binding."""
node = cmds.createNode('network')
cmds.addAttr(node, ln='pass', multi=True)
plug_obj = as_plug(node + '.pass')
null_obj = cmdc.Plug()
cmds.setAttr(node + '.pass[0]', 1.0)
cmds.setAttr(node + '.pass[1]', 1.0)
cmds.setAttr(node + '.pass[2]', 1.0)
index_obj = plug_obj.elementByLogicalIndex(1)
mod = cmdc.DGModifier()
mod.removeMultiInstance(index_obj, True)
mod.doIt()
assert plug_obj.getExistingArrayAttributeIndices() == [
0, 2
], 'DGMOdifier.removeMultiInstance doIt failed'
mod.undoIt()
assert plug_obj.getExistingArrayAttributeIndices() == [
0, 1, 2
], 'DGMOdifier.removeMultiInstance undoIt failed'
def test_elementByPhysicalIndex(self):
"""Test for MPlug::elementByPhysicalIndex binding."""
array_root = cmdc.SelectionList().add(p(self.node, 'array')).getPlug(0)
selection = cmdc.SelectionList().add(p(self.node, 'array[*]'))
plug_0 = selection.getPlug(0)
plug_1 = selection.getPlug(1)
plug_3 = selection.getPlug(2)
assert array_root.elementByPhysicalIndex(0) == plug_0
assert array_root.elementByPhysicalIndex(1) == plug_1
assert array_root.elementByPhysicalIndex(2) == plug_3
nose.tools.assert_raises(IndexError, array_root.elementByPhysicalIndex,
9001)
non_array_root = cmdc.SelectionList().add(p(self.node,
'single')).getPlug(0)
nose.tools.assert_raises(TypeError,
non_array_root.elementByPhysicalIndex, 0)
nose.tools.assert_raises(ValueError,
cmdc.Plug().elementByPhysicalIndex, 0)
def test_destinationsWithConversion(self):
"""Test for MPlug::destinationsWithConversions binding."""
src_plug = cmdc.SelectionList().add(p(self.src_node,
'attr')).getPlug(0)
tgt_plug = cmdc.SelectionList().add(p(self.tgt_node,
'attr')).getPlug(0)
alt_plug = cmdc.SelectionList().add(p(self.alt_node,
'attr')).getPlug(0)
assert tgt_plug.destinations(
) == [], 'Plug.destinationsWithConversions should return an empty list for unconnected plugs'
destinations = src_plug.destinationsWithConversions()
assert destinations is not None, 'Plug.destinationsWithConversions returned a null'
assert len(
destinations
) == 2, 'Plug.destinationsWithConversions returned %s values; expected 2' % len(
destinations)
assert destinations[0].node().hasFn(
cmdc.Fn.kUnitConversion
), 'Plug.destinationsWithConversions skipped over conversion node'
assert destinations[1].node().hasFn(
cmdc.Fn.kUnitConversion
), 'Plug.destinationsWithConversions skipped over conversion node'
assert tgt_plug not in destinations, 'Plug.destinationsWithConversions returned incorrect results'
assert alt_plug not in destinations, 'Plug.destinationsWithConversions returned incorrect results'
nose.tools.assert_raises(ValueError,
cmdc.Plug().destinationsWithConversions)
def test_elementByLogicalIndex(self):
"""Test for MPlug::elementByLogicalIndex binding."""
array_root = cmdc.SelectionList().add(p(self.node, 'array')).getPlug(0)
selection = cmdc.SelectionList().add(p(self.node, 'array[*]'))
plug_0 = selection.getPlug(0)
plug_1 = selection.getPlug(1)
plug_3 = selection.getPlug(2)
assert array_root.elementByLogicalIndex(0) == plug_0
assert array_root.elementByLogicalIndex(1) == plug_1
assert array_root.elementByLogicalIndex(3) == plug_3
# A plug will be created at the requested index if it does not exist.
assert not array_root.elementByLogicalIndex(5).isNull()
non_array_root = cmdc.SelectionList().add(p(self.node,
'single')).getPlug(0)
nose.tools.assert_raises(TypeError,
non_array_root.elementByLogicalIndex, 0)
nose.tools.assert_raises(ValueError,
cmdc.Plug().elementByLogicalIndex, 0)
def test_numChildren(self):
"""Test for MPlug::numChildren binding."""
parent = cmdc.SelectionList().add(p(self.node, 'parent_a')).getPlug(0)
assert parent.numChildren() == 1
non_parent = cmdc.SelectionList().add(p(self.node,
'single')).getPlug(0)
nose.tools.assert_raises(TypeError, non_parent.numChildren)
nose.tools.assert_raises(ValueError, cmdc.Plug().numChildren)
def test_numElements(self):
"""Test for MPlug::numElements binding."""
array_root = cmdc.SelectionList().add(p(self.node, 'array')).getPlug(0)
assert array_root.numElements() == 3
non_array_root = cmdc.SelectionList().add(p(self.node,
'single')).getPlug(0)
nose.tools.assert_raises(TypeError, non_array_root.numElements)
nose.tools.assert_raises(ValueError, cmdc.Plug().numElements)
def test_source(self):
"""Test for MPlug::source binding."""
src_plug = cmdc.SelectionList().add(p(self.src_node,
'attr')).getPlug(0)
tgt_plug = cmdc.SelectionList().add(p(self.tgt_node,
'attr')).getPlug(0)
assert src_plug.source().isNull(
), 'Plug.source should return a null plug when not a destination'
assert tgt_plug.source(
) == src_plug, 'Plug.source did not return the source plug.'
nose.tools.assert_raises(ValueError, cmdc.Plug().source)
def test_parent(self):
"""Test for MPlug::parent binding."""
parent = cmdc.SelectionList().add(p(self.node, 'parent_a')).getPlug(0)
child = cmdc.SelectionList().add(p(self.node, 'parent_a',
'child_a')).getPlug(0)
result = child.parent()
assert result is not None
assert result.name() == parent.name()
nose.tools.assert_raises(TypeError, parent.parent)
nose.tools.assert_raises(ValueError, cmdc.Plug().parent)
def test_array(self):
"""Test for MPlug::array binding."""
array_element = cmdc.SelectionList().add(p(self.node, 'array',
0)).getPlug(0)
array_root = array_element.array()
assert array_root is not None
assert array_root.name() == p(self.node, 'array')
non_array_element = cmdc.SelectionList().add(p(self.node,
'single')).getPlug(0)
nose.tools.assert_raises(TypeError, non_array_element.array)
nose.tools.assert_raises(ValueError, cmdc.Plug().array)
def test_getExistingArrayAttributeIndices(self):
"""Test for MPlug::getExistingArrayAttributeIndices binding."""
array_root = cmdc.SelectionList().add(p(self.node, 'array')).getPlug(0)
indices = array_root.getExistingArrayAttributeIndices()
assert indices == [0, 1, 3]
non_array_root = cmdc.SelectionList().add(p(self.node,
'single')).getPlug(0)
nose.tools.assert_raises(
TypeError, non_array_root.getExistingArrayAttributeIndices)
nose.tools.assert_raises(ValueError,
cmdc.Plug().getExistingArrayAttributeIndices)
def test_disconnect_fail():
src_plug = as_plug(cmds.createNode('transform') + '.visibility')
src_node = src_plug.node()
src_attr = src_plug.attribute()
dst_plug = as_plug(cmds.createNode('transform') + '.visibility')
dst_node = dst_plug.node()
dst_attr = dst_plug.attribute()
null = cmdc.Object()
nop_plug = cmdc.Plug()
for exc, doc, args in (
[ValueError, 'a null source object', (null, null, null, null)],
[ValueError, 'a null source attribute', (src_node, null, null, null)],
[
ValueError, 'a null destination object',
(src_node, src_attr, null, null)
],
[
ValueError, 'a null destination attribute',
(src_node, src_attr, dst_node, null)
],
[
TypeError, 'a non-node source object',
(src_attr, src_attr, null, null)
],
[
TypeError, 'a non-attribute source attribute',
(src_node, src_node, null, null)
],
[
TypeError, 'a non-node destination object',
(src_node, src_attr, dst_attr, dst_attr)
],
[
TypeError, 'a non-attribute destination attribute',
(src_node, src_attr, dst_node, dst_node)
],
[ValueError, 'a null source plug', (nop_plug, dst_plug)],
[ValueError, 'a null destination plug', (src_plug, nop_plug)],
):
test_disconnect_fail.__doc__ = """Test MDGModifier::disconnect raises error if called with {}.""".format(
doc)
yield _disconnect_fail, exc, args
def test_sourceWithConversion(self):
"""Test for MPlug::sourceWithConversion binding."""
src_plug = cmdc.SelectionList().add(p(self.src_node,
'attr')).getPlug(0)
tgt_plug = cmdc.SelectionList().add(p(self.tgt_node,
'attr')).getPlug(0)
assert src_plug.sourceWithConversion().isNull(
), 'Plug.sourceWithConversion should return a null plug when not a destination'
assert tgt_plug.sourceWithConversion(
) != src_plug, 'Plug.sourceWithConversion skipped over the conversion node'
assert tgt_plug.sourceWithConversion().node().hasFn(
cmdc.Fn.kUnitConversion
), 'Plug.sourceWithConversion skipped over conversion node'
nose.tools.assert_raises(ValueError, cmdc.Plug().sourceWithConversion)
def test_removeMultiInstance_fail():
"""Test MDGModfifier::removeMultiInstance binding error handling."""
node = cmds.createNode('network')
cmds.addAttr(node, ln='fail')
plug_obj = as_plug(node + '.fail')
null_obj = cmdc.Plug()
for exception, doc, plug_obj in (
[ValueError, 'a null plug', null_obj],
[TypeError, 'a non-element plug', plug_obj],
):
test_removeMultiInstance_fail.__doc__ = """Test MDGModifier::removeMultiInstance raises an error if called with {}.""".format(
doc)
yield _removeMultiInstance_fail, exception, plug_obj
def test_logicalIndex(self):
"""Test for MPlug::logicalIndex binding."""
selection = cmdc.SelectionList().add(p(self.node, 'array[*]'))
plug_0 = selection.getPlug(0)
plug_1 = selection.getPlug(1)
plug_3 = selection.getPlug(2)
assert plug_0.logicalIndex() == 0
assert plug_1.logicalIndex() == 1
assert plug_3.logicalIndex() == 3
non_element = cmdc.SelectionList().add(p(self.node,
'single')).getPlug(0)
nose.tools.assert_raises(TypeError, non_element.logicalIndex)
nose.tools.assert_raises(ValueError, cmdc.Plug().logicalIndex)
def test_child(self):
"""Test for MPlug::child binding."""
parent = cmdc.SelectionList().add(p(self.node, 'parent_a')).getPlug(0)
child = cmdc.SelectionList().add(p(self.node, 'parent_a',
'child_a')).getPlug(0).attribute()
attr = parent.child(child)
assert attr is not None
assert attr.name() == p(self.node, 'child_a'), attr.name()
attr = parent.child(0)
assert attr is not None
assert attr.name() == p(self.node, 'child_a'), attr.name()
parent = cmdc.SelectionList().add(p(self.node, 'parent_a')).getPlug(0)
child = cmdc.SelectionList().add(p(self.node, 'parent_b',
'child_b')).getPlug(0).attribute()
nose.tools.assert_raises(ValueError, parent.child, child)
nose.tools.assert_raises(IndexError, parent.child, 1)
nose.tools.assert_raises(ValueError, cmdc.Plug().child, 0)
