text: from nose.exc import SkipTest
  from nose.tools import *
  from nose.twistedtools import *
  try:    
      from twisted.internet.defer import Deferred
      from twisted.internet.error import DNSLookupError
  except ImportError:
      raise SkipTest('twisted not available; skipping')
  
  _multiprocess_ = False
  
  
  def teardown():
      # print "stopping reactor"
      stop_reactor()
  
  class CustomError(Exception):
      pass
  
  # FIXME move all dns-using tests to functional
  
  # Should succeed unless google is down
  #@deferred
  def test_resolve():
      return reactor.resolve("www.google.com")
  test_resolve = deferred()(test_resolve)
  
  # Raises TypeError because the function does not return a Deferred
  #@raises(TypeError)
  #@deferred()
  def test_raises_bad_return():
      print reactor
      reactor.resolve("www.python.org")
  test_raises_bad_return = raises(TypeError)(deferred()(test_raises_bad_return))
  
  # Check we propagate twisted Failures as Exceptions
  # (XXX this test might take some time: find something better?)
  #@raises(DNSLookupError)
  #@deferred()
  def test_raises_twisted_error():
      return reactor.resolve("x.y.invalid")
  test_raises_twisted_error = raises(DNSLookupError)(
      deferred()(test_raises_twisted_error))
  
  # Check we detect Exceptions inside the callback chain
  #@raises(CustomError)
  #@deferred(timeout=1.0)
  def test_raises_callback_error():
      d = Deferred()
      def raise_error(_):
          raise CustomError()
      def finish():
          d.callback(None)
      d.addCallback(raise_error)
      reactor.callLater(0.01, finish)
      return d
  test_raises_callback_error = raises(CustomError)(
      deferred(timeout=1.0)(test_raises_callback_error))
  
  # Check we detect Exceptions inside the test body
  #@raises(CustomError)
  #@deferred(timeout=1.0)
  def test_raises_plain_error():
      raise CustomError
  test_raises_plain_error = raises(CustomError)(
      deferred(timeout=1.0)(test_raises_plain_error))
  
  # The deferred is triggered before the timeout: ok
  #@deferred(timeout=1.0)
  def test_timeout_ok():
      d = Deferred()
      def finish():
          d.callback(None)
      reactor.callLater(0.01, finish)
      return d
  test_timeout_ok = deferred(timeout=1.0)(test_timeout_ok)
  
  # The deferred is triggered after the timeout: failure
  #@raises(TimeExpired)
  #@deferred(timeout=0.1)
  def test_timeout_expired():
      d = Deferred()
      def finish():
          d.callback(None)
      reactor.callLater(1.0, finish)
      return d
  test_timeout_expired = raises(TimeExpired)(
      deferred(timeout=0.1)(test_timeout_expired))
  
  
  if __name__ == '__main__':
      from nose import runmodule
      runmodule()
  