def test_args(self):
     def to_test(*args):
         raise ValueError('%s'%repr(args))
     should_raise(
         to_test,
         ValueError('(1,)')
         )(1)

 def test_kw(self):
     def to_test(**kw):
         raise ValueError('%r'%kw)
     should_raise(
         to_test,
         ValueError("{'x': 1}")
         )(x=1)

 def test_class_class(self):
     class Test:
         def __init__(self, x):
             # The TypeError is raised due to the mis-matched parameters
             # so the pass never gets executed
             pass  # pragma: no cover
     should_raise(TypeError)(Test)()

 def test_both(self):
     def to_test(*args,**kw):
         raise ValueError('%r %r'%(args,kw))
     should_raise(
         to_test,
         ValueError("(1,) {'x': 2}")
         )(1,x=2)

    def test_formatting_info(self):
        r = TestReader()
        f = Mock()
        
        r.formatting_info = True
        
        r.setup(('Sheet1',[['R1C1','R1C2']]))

        # at this point you can now manipulate the xf index as follows:
        book = r.books[0][0]
        sx,rx,cx = 0,0,0
        book.sheet_by_index(sx)._cell_xf_indexes[rx][cx]=42

        # NB: cells where you haven't specified an xf index manually as
        #     above will have an xf index of 0:
        compare(book.sheet_by_index(0).cell(0,1).xf_index,0)
        # and no matching style:
        should_raise(book.xf_list,IndexError)[0]

        r(f)
        
        compare([
            ('start', (), {}),
            ('workbook',(C('xlutils.tests.fixtures.DummyBook'), 'test.xls'),{}),
            ('sheet', (C('xlrd.sheet.Sheet'), 'Sheet1'), {}),
            ('row', (0, 0), {}),
            ('cell', (0, 0, 0, 0), {}),
            ('cell', (0, 1, 0, 1), {}),
            ('finish', (), {})],f.method_calls)

        compare(book.sheet_by_index(0).cell(0,0).xf_index,42)

 def test_wrong_exception(self):
     def to_test():
         raise ValueError('bar')
     with ShouldAssert(
         "ValueError('foo',) (expected) != ValueError('bar',) (raised)"
     ):
         should_raise(ValueError('foo'))(to_test)()

 def test_kw_to_args(self):
     def to_test(x):
         raise ValueError('%s'%x)
     should_raise(
         to_test,
         ValueError('1')
         )(x=1)

 def test_no_supplied_or_raised(self):
     # effectvely we're saying "something should be raised!"
     # but we want to inspect s.raised rather than making
     # an up-front assertion
     def to_test():
         pass
     with ShouldAssert("No exception raised!"):
         should_raise()(to_test)()

 def test_method_args(self):
     class X:
         def to_test(self, *args):
             self.args = args
             raise ValueError()
     x = X()
     should_raise(ValueError)(x.to_test)(1, 2, 3)
     self.assertEqual(x.args, (1, 2, 3))

 def test_method_kw(self):
     class X:
         def to_test(self, **kw):
             self.kw = kw
             raise ValueError()
     x = X()
     should_raise(ValueError)(x.to_test)(x=1, y=2)
     self.assertEqual(x.kw, {'x': 1, 'y': 2})

 def test_empty_sheet_name(self):
     r = TestReader(
         ('',([['S1R0C0']]),),
         )
     book = tuple(r.get_workbooks())[0][0]
     # fire methods on writer
     should_raise(r,ValueError(
         'Empty sheet name will result in invalid Excel file!'
         ))(TestWriter())

 def test_wrong_exception(self):
     def to_test():
         raise ValueError('bar')
     if PY_37_PLUS:
         expected = "ValueError('foo') (expected) != ValueError('bar') (raised)"
     else:
         expected = "ValueError('foo',) (expected) != ValueError('bar',) (raised)"
     with ShouldAssert(expected):
         should_raise(ValueError('foo'))(to_test)()

    def test_not_there(self):

        o = object()

        @replace("testfixtures.tests.sample1.bad", o)
        def test_something(r):
            pass  # pragma: no cover

        should_raise(test_something, AttributeError("Original 'bad' not found"))()

 def test_wrong_exception(self):
     def to_test():
         raise ValueError('bar')
     try:
         should_raise(to_test,ValueError('foo'))()
     except AssertionError,e:
         self.assertEqual(
             e,
             C(AssertionError("ValueError('bar',) raised, ValueError('foo',) expected"))
             )

 def test_no_exception(self):
     def to_test():
         pass
     try:
         should_raise(to_test,ValueError())()
     except AssertionError,e:
         self.assertEqual(
             e,
             C(AssertionError('None raised, ValueError() expected'))
             )

 def test_method_both(self):
     class X:
         def to_test(self, *args, **kw):
             self.args = args
             self.kw = kw
             raise ValueError()
     x = X()
     should_raise(ValueError)(x.to_test)(1, y=2)
     self.assertEqual(x.args, (1, ))
     self.assertEqual(x.kw, {'y': 2})

 def test_excessive_length_sheet_name(self):
     r = TestReader(
         ('X'*32,([['S1R0C0']]),),
         )
     book = tuple(r.get_workbooks())[0][0]
     # fire methods on writer
     should_raise(r,ValueError(
         'Sheet name cannot be more than 31 characters long, '
         'supplied name was 32 characters long!'
         ))(TestWriter())

 def test_bogus_sheet_name(self):
     r = TestReader(
         ('sheet',([['S1R0C0']]),),
         ('Sheet',([['S2R0C0']]),),
         )
     book = tuple(r.get_workbooks())[0][0]
     # fire methods on writer
     should_raise(r,ValueError(
         "A sheet named 'sheet' has already been added!"
         ))(TestWriter())

 def test_wrong_exception_class(self):
     def to_test():
         raise ValueError('bar')
     if PY3:
         message = ("<class 'KeyError'> (expected) != "
                    "ValueError('bar',) (raised)")
     else:
         message = ("<type 'exceptions.KeyError'> (expected) != "
                    "ValueError('bar',) (raised)")
     with ShouldAssert(message):
         should_raise(KeyError)(to_test)()

 def test_wrong_exception(self):
     def to_test():
         raise ValueError('bar')
     try:
         should_raise(ValueError('foo'))(to_test)()
     except AssertionError as e:
         self.assertEqual(
             e,
             C(AssertionError("ValueError('bar',) raised, ValueError('foo',) expected"))
             )
     else:
         self.fail('No exception raised!')