text: # Copyright (c) Twisted Matrix Laboratories.
  # See LICENSE for details.
  
  
  import sys, os
  import types
  
  from twisted.trial import unittest
  from twisted.python import rebuild
  from twisted.python.compat import _PY3
  
  from . import crash_test_dummy
  f = crash_test_dummy.foo
  
  class Foo: pass
  class Bar(Foo): pass
  class Baz(object): pass
  class Buz(Bar, Baz): pass
  
  class HashRaisesRuntimeError:
      """
      Things that don't hash (raise an Exception) should be ignored by the
      rebuilder.
  
      @ivar hashCalled: C{bool} set to True when __hash__ is called.
      """
      def __init__(self):
          self.hashCalled = False
  
  
      def __hash__(self):
          self.hashCalled = True
          raise RuntimeError('not a TypeError!')
  
  
  
  # Set in test_hashException
  unhashableObject = None
  
  
  
  class RebuildTests(unittest.TestCase):
      """
      Simple testcase for rebuilding, to at least exercise the code.
      """
      def setUp(self):
          self.libPath = self.mktemp()
          os.mkdir(self.libPath)
          self.fakelibPath = os.path.join(self.libPath,
                                          'twisted_rebuild_fakelib')
          os.mkdir(self.fakelibPath)
          open(os.path.join(self.fakelibPath, '__init__.py'), 'w').close()
          sys.path.insert(0, self.libPath)
  
  
      def tearDown(self):
          sys.path.remove(self.libPath)
  
  
      def test_FileRebuild(self):
          from twisted.python.util import sibpath
          import shutil, time
          shutil.copyfile(sibpath(__file__, "myrebuilder1.py"),
                          os.path.join(self.fakelibPath, "myrebuilder.py"))
          from twisted_rebuild_fakelib import myrebuilder
          a = myrebuilder.A()
          b = myrebuilder.B()
          i = myrebuilder.Inherit()
          self.assertEqual(a.a(), 'a')
          # Necessary because the file has not "changed" if a second has not gone
          # by in unix.  This sucks, but it's not often that you'll be doing more
          # than one reload per second.
          time.sleep(1.1)
          shutil.copyfile(sibpath(__file__, "myrebuilder2.py"),
                          os.path.join(self.fakelibPath, "myrebuilder.py"))
          rebuild.rebuild(myrebuilder)
          b2 = myrebuilder.B()
          self.assertEqual(b2.b(), 'c')
          self.assertEqual(b.b(), 'c')
          self.assertEqual(i.a(), 'd')
          self.assertEqual(a.a(), 'b')
  
  
      def test_Rebuild(self):
          """
          Rebuilding an unchanged module.
          """
          # This test would actually pass if rebuild was a no-op, but it
          # ensures rebuild doesn't break stuff while being a less
          # complex test than testFileRebuild.
  
          x = crash_test_dummy.X('a')
  
          rebuild.rebuild(crash_test_dummy, doLog=False)
          # Instance rebuilding is triggered by attribute access.
          x.do()
          self.assertEqual(x.__class__, crash_test_dummy.X)
  
          self.assertEqual(f, crash_test_dummy.foo)
  
  
      def test_ComponentInteraction(self):
          x = crash_test_dummy.XComponent()
          x.setAdapter(crash_test_dummy.IX, crash_test_dummy.XA)
          x.getComponent(crash_test_dummy.IX)
          rebuild.rebuild(crash_test_dummy, 0)
          newComponent = x.getComponent(crash_test_dummy.IX)
  
          newComponent.method()
  
          self.assertEqual(newComponent.__class__, crash_test_dummy.XA)
  
          # Test that a duplicate registerAdapter is not allowed
          from twisted.python import components
          self.assertRaises(ValueError, components.registerAdapter,
                                crash_test_dummy.XA, crash_test_dummy.X,
                                crash_test_dummy.IX)
  
  
      def test_UpdateInstance(self):
          global Foo, Buz
  
          b = Buz()
  
          class Foo:
              def foo(self):
                  """
                  Dummy method
                  """
  
          class Buz(Bar, Baz):
              x = 10
  
          rebuild.updateInstance(b)
          assert hasattr(b, 'foo'), "Missing method on rebuilt instance"
          assert hasattr(b, 'x'), "Missing class attribute on rebuilt instance"
  
  
      def test_BananaInteraction(self):
          from twisted.python import rebuild
          from twisted.spread import banana
          rebuild.latestClass(banana.Banana)
  
  
      def test_hashException(self):
          """
          Rebuilding something that has a __hash__ that raises a non-TypeError
          shouldn't cause rebuild to die.
          """
          global unhashableObject
          unhashableObject = HashRaisesRuntimeError()
          def _cleanup():
              global unhashableObject
              unhashableObject = None
          self.addCleanup(_cleanup)
          rebuild.rebuild(rebuild)
          self.assertTrue(unhashableObject.hashCalled)
  
  
      def test_Sensitive(self):
          """
          L{twisted.python.rebuild.Sensitive}
          """
          from twisted.python import rebuild
          from twisted.python.rebuild import Sensitive
  
          class TestSensitive(Sensitive):
              def test_method(self):
                  """
                  Dummy method
                  """
  
          testSensitive = TestSensitive()
          testSensitive.rebuildUpToDate()
          self.assertFalse(testSensitive.needRebuildUpdate())
  
          # Test rebuilding a builtin class
          newException = rebuild.latestClass(Exception)
          if _PY3:
              self.assertEqual(repr(Exception), repr(newException))
          else:
              self.assertIn('twisted.python.rebuild.Exception', repr(newException))
          self.assertEqual(newException, testSensitive.latestVersionOf(newException))
  
          # Test types.MethodType on method in class
          self.assertEqual(TestSensitive.test_method,
              testSensitive.latestVersionOf(TestSensitive.test_method))
          # Test types.MethodType on method in instance of class
          self.assertEqual(testSensitive.test_method,
              testSensitive.latestVersionOf(testSensitive.test_method))
          # Test a class
          self.assertEqual(TestSensitive,
              testSensitive.latestVersionOf(TestSensitive))
  
          class Foo:
              """
              Dummy class
              """
  
          foo = Foo()
  
          # Test types.InstanceType
          self.assertEqual(foo, testSensitive.latestVersionOf(foo))
  
          def myFunction():
              """
              Dummy method
              """
  
          # Test types.FunctionType
          self.assertEqual(myFunction, testSensitive.latestVersionOf(myFunction))
  
  
  
  class NewStyleTests(unittest.TestCase):
      """
      Tests for rebuilding new-style classes of various sorts.
      """
      def setUp(self):
          self.m = types.ModuleType('whipping')
          sys.modules['whipping'] = self.m
  
  
      def tearDown(self):
          del sys.modules['whipping']
          del self.m
  
  
      def test_slots(self):
          """
          Try to rebuild a new style class with slots defined.
          """
          classDefinition = (
              "class SlottedClass(object):\n"
              "    __slots__ = ['a']\n")
  
          exec(classDefinition, self.m.__dict__)
          inst = self.m.SlottedClass()
          inst.a = 7
          exec(classDefinition, self.m.__dict__)
          rebuild.updateInstance(inst)
          self.assertEqual(inst.a, 7)
          self.assertIs(type(inst), self.m.SlottedClass)
  
  
      def test_typeSubclass(self):
          """
          Try to rebuild a base type subclass.
          """
          classDefinition = (
              "class ListSubclass(list):\n"
              "    pass\n")
  
          exec(classDefinition, self.m.__dict__)
          inst = self.m.ListSubclass()
          inst.append(2)
          exec(classDefinition, self.m.__dict__)
          rebuild.updateInstance(inst)
          self.assertEqual(inst[0], 2)
          self.assertIs(type(inst), self.m.ListSubclass)
  
  
      def test_instanceSlots(self):
          """
          Test that when rebuilding an instance with a __slots__ attribute, it
          fails accurately instead of giving a L{rebuild.RebuildError}.
          """
          classDefinition = (
              "class NotSlottedClass(object):\n"
              "    pass\n")
  
          exec(classDefinition, self.m.__dict__)
          inst = self.m.NotSlottedClass()
          inst.__slots__ = ['a']
          classDefinition = (
              "class NotSlottedClass:\n"
              "    pass\n")
          exec(classDefinition, self.m.__dict__)
          # Moving from new-style class to old-style should fail.
          self.assertRaises(TypeError, rebuild.updateInstance, inst)
  
      if getattr(types, 'ClassType', None) is None:
          test_instanceSlots.skip = "Old-style classes not supported on Python 3"
  