This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5770

tests: perform a shallow copy instead of a deep copy
ClosedPublic

Authored by indygreg on Jan 30 2019, 7:54 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG5880b4e762cd: tests: perform a shallow copy instead of a deep copy
rHGaf31e369adad: tests: perform a shallow copy instead of a deep copy
rHG9701bac56c46: tests: perform a shallow copy instead of a deep copy
Summary

Python 3 can't perform a deep copy because it looks like symbols
in the locals() namespace are not deep-copyable. For the curious,
somehow the deepcopy() is attempting to copy objects attached to
the unittest.* functions for the running test!

We don't use deepcopy() anywhere in the code base and a shallow
object copy should be sufficient to test lock copying.

Actually, I'm not sure why we even test this, as I couldn't find
copy.copy() being used for lock copying either. Who knows.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Jan 30 2019, 7:54 PM
Closed by commit rHG9701bac56c46: tests: perform a shallow copy instead of a deep copy (authored by indygreg). · Explain WhyJan 30 2019, 8:08 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mtests/test-lock.py (4 lines)

Diff 13620

tests/test-lock.py

state.assertlockexists(False) state.assertlockexists(False)
def testlockfork(self): def testlockfork(self):
state = teststate(self, tempfile.mkdtemp(dir=encoding.getcwd())) state = teststate(self, tempfile.mkdtemp(dir=encoding.getcwd()))
lock = state.makelock() lock = state.makelock()
state.assertacquirecalled(True) state.assertacquirecalled(True)
# fake a fork # fake a fork
forklock = copy.deepcopy(lock) forklock = copy.copy(lock)
forklock._pidoffset = 1 forklock._pidoffset = 1
forklock.release() forklock.release()
state.assertreleasecalled(False) state.assertreleasecalled(False)
state.assertpostreleasecalled(False) state.assertpostreleasecalled(False)
state.assertlockexists(True) state.assertlockexists(True)
# release the actual lock # release the actual lock
lock.release() lock.release()
# set up lock inheritance # set up lock inheritance
with parentlock.inherit() as lockname: with parentlock.inherit() as lockname:
childstate = teststate(self, d, pidoffset=1) childstate = teststate(self, d, pidoffset=1)
childlock = childstate.makelock(parentlock=lockname) childlock = childstate.makelock(parentlock=lockname)
childstate.assertacquirecalled(True) childstate.assertacquirecalled(True)
# fork the child lock # fork the child lock
forkchildlock = copy.deepcopy(childlock) forkchildlock = copy.copy(childlock)
forkchildlock._pidoffset += 1 forkchildlock._pidoffset += 1
forkchildlock.release() forkchildlock.release()
childstate.assertreleasecalled(False) childstate.assertreleasecalled(False)
childstate.assertpostreleasecalled(False) childstate.assertpostreleasecalled(False)
childstate.assertlockexists(True) childstate.assertlockexists(True)
# release the child lock # release the child lock
childlock.release() childlock.release()