text: import unittest
  
  class TestBWCompat(unittest.TestCase):
      def test_bwcompat_notfound(self):
          from pyramid.exceptions import NotFound as one
          from pyramid.httpexceptions import HTTPNotFound as two
          self.assertTrue(one is two)
  
      def test_bwcompat_forbidden(self):
          from pyramid.exceptions import Forbidden as one
          from pyramid.httpexceptions import HTTPForbidden as two
          self.assertTrue(one is two)
  
  class TestBadCSRFToken(unittest.TestCase):
      def test_response_equivalence(self):
          from pyramid.exceptions import BadCSRFToken
          from pyramid.httpexceptions import HTTPBadRequest
          self.assertTrue(isinstance(BadCSRFToken(), HTTPBadRequest))
  
  class TestNotFound(unittest.TestCase):
      def _makeOne(self, message):
          from pyramid.exceptions import NotFound
          return NotFound(message)
  
      def test_it(self):
          from pyramid.interfaces import IExceptionResponse
          e = self._makeOne('notfound')
          self.assertTrue(IExceptionResponse.providedBy(e))
          self.assertEqual(e.status, '404 Not Found')
          self.assertEqual(e.message, 'notfound')
  
      def test_response_equivalence(self):
          from pyramid.exceptions import NotFound
          from pyramid.httpexceptions import HTTPNotFound
          self.assertTrue(NotFound is HTTPNotFound)
  
  class TestForbidden(unittest.TestCase):
      def _makeOne(self, message):
          from pyramid.exceptions import Forbidden
          return Forbidden(message)
  
      def test_it(self):
          from pyramid.interfaces import IExceptionResponse
          e = self._makeOne('forbidden')
          self.assertTrue(IExceptionResponse.providedBy(e))
          self.assertEqual(e.status, '403 Forbidden')
          self.assertEqual(e.message, 'forbidden')
  
      def test_response_equivalence(self):
          from pyramid.exceptions import Forbidden
          from pyramid.httpexceptions import HTTPForbidden
          self.assertTrue(Forbidden is HTTPForbidden)
  
  class TestConfigurationConflictError(unittest.TestCase):
      def _makeOne(self, conflicts):
          from pyramid.exceptions import ConfigurationConflictError
          return ConfigurationConflictError(conflicts)
  
      def test_str(self):
          conflicts = {'a':('1', '2', '3'), 'b':('4', '5', '6')}
          exc = self._makeOne(conflicts)
          self.assertEqual(str(exc),
  """\
  Conflicting configuration actions
    For: a
      1
      2
      3
    For: b
      4
      5
      6""")
  
  class TestConfigurationExecutionError(unittest.TestCase):
      def _makeOne(self, etype, evalue, info):
          from pyramid.exceptions import ConfigurationExecutionError
          return ConfigurationExecutionError(etype, evalue, info)
  
      def test_str(self):
          exc = self._makeOne('etype', 'evalue', 'info')
          self.assertEqual(str(exc), 'etype: evalue\n  in:\n  info')
          
  class TestCyclicDependencyError(unittest.TestCase):
      def _makeOne(self, cycles):
          from pyramid.exceptions import CyclicDependencyError
          return CyclicDependencyError(cycles)
  
      def test___str__(self):
          exc = self._makeOne({'a':['c', 'd'], 'c':['a']})
          result = str(exc)
          self.assertTrue("'a' sorts before ['c', 'd']" in result)
          self.assertTrue("'c' sorts before ['a']" in result)
  
  
  