def test_switches_backend(self):
        """
        Tests that calling an operation will switch backend if the current
        backend doesn't support it
        """
        def say_hello(backend):
            return "Hello world!"

        self.FakeBackend.operations = {
            'say_hello': say_hello,
        }

        def say_goodbye(backend):
            return "Goodbye!"

        self.AnotherFakeBackend.operations = {
            'say_goodbye': say_goodbye,
        }

        image = Image(self.FakeBackend(), 'jpeg')
        self.assertIsInstance(image.backend, self.FakeBackend)

        image.say_goodbye()
        self.assertIsInstance(image.backend, self.AnotherFakeBackend)

        image.say_hello()
        self.assertIsInstance(image.backend, self.FakeBackend)

    def test_register_backend(self):
        """
        Tests basic usage of register_backend
        """
        Image.register_backend(self.FakeBackend)

        self.assertEqual(Image.backends, [self.FakeBackend])

    def test_register_backend_multiple(self):
        """
        Tests register_backend can register multiple backends
        """
        Image.register_backend(self.FakeBackend)
        Image.register_backend(self.AnotherFakeBackend)

        self.assertEqual(Image.backends, [self.FakeBackend, self.AnotherFakeBackend])

    def test_save_as_foo(self):
        image = Image()
        image.save_as_jpeg = mock.MagicMock()

        with self.assertRaises(ValueError):
            image.save("foo", "outfile")

        self.assertFalse(image.save_as_jpeg.mock_calls)

    def test_register_backend_removes_duplicates(self):
        """
        Tests register_backend won't insert the same backend more than once
        """
        Image.register_backend(self.FakeBackend)
        Image.register_backend(self.FakeBackend)

        self.assertEqual(Image.backends, [self.FakeBackend])

    def test_raises_error_on_invalid_header(self):
        import imghdr

        f = io.BytesIO()
        f.write(b'Not an image')
        f.seek(0)

        with self.assertRaises(UnrecognisedImageFormatError) as e:
            Image.open(f)

    def test_register_loader(self):
        """
        Tests basic usage of register_loader
        """
        Image.register_loader('jpeg', self.FakeBackend)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (0, self.FakeBackend),
            ],
        })

    def test_register_loader_priority(self):
        """
        Tests that register_loader saves priority
        """
        Image.register_loader('jpeg', self.FakeBackend, priority=100)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (100, self.FakeBackend),
            ],
        })

def has_jpeg_support():
    wagtail_jpg = os.path.join(os.path.dirname(__file__), 'check_files', 'wagtail.jpg')
    succeeded = True

    with open(wagtail_jpg, 'rb') as f:
        try:
            Image.open(f)
        except (IOError, Image.LoaderError):
            succeeded = False

    return succeeded

    def test_image_format_detection(self):
        Image.loaders = {
            'png': [
                (0, self.FakeBackend),
            ],
            'jpeg': [
                (100, self.AnotherFakeBackend),
            ],
        }

        self.assertIsInstance(Image.open('tests/images/transparent.png').backend, self.FakeBackend)
        self.assertIsInstance(Image.open('tests/images/flower.jpg').backend, self.AnotherFakeBackend)

    def test_register_loader_priority_multiple(self):
        """
        Tests that register_loader keeps the loaders list sorted by priority
        """
        Image.register_loader('jpeg', self.FakeBackend, priority=100)
        Image.register_loader('jpeg', self.AnotherFakeBackend, priority=200)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (100, self.FakeBackend),
                (200, self.AnotherFakeBackend),
            ],
        })

    def test_register_loader_priority_same(self):
        """
        Tests that new loaders are placed after loaders that have the same
        priority
        """
        Image.register_loader('jpeg', self.FakeBackend)
        Image.register_loader('jpeg', self.AnotherFakeBackend)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (0, self.FakeBackend),
                (0, self.AnotherFakeBackend),
            ],
        })

    def test_register_loader_different_extension_at_same_time_with_priority(self):
        """
        Tests that register_loader saves priority when using multipe extensions
        """
        Image.register_loader(['jpeg', 'gif'], self.FakeBackend, priority=100)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (100, self.FakeBackend),
            ],
            'gif': [
                (100, self.FakeBackend),
            ],
        })

    def test_image_detect_stream(self):
        Image.loaders = {
            'png': [
                (0, self.FakeBackend),
            ],
            'jpeg': [
                (100, self.AnotherFakeBackend),
            ],
        }

        with open('tests/images/transparent.png', 'rb') as f:
            self.assertIsInstance(Image.open(f).backend, self.FakeBackend)
        with open('tests/images/flower.jpg', 'rb') as f:
            self.assertIsInstance(Image.open(f).backend, self.AnotherFakeBackend)

    def test_return_value_gets_passed_back(self):
        """
        Tests that the return value of the underlying function gets passed back
        to the caller
        """
        def myop(backend):
            return "Hello world!"

        self.FakeBackend.operations = {
            'test': myop,
        }

        image = Image(self.FakeBackend(), 'jpeg')

        self.assertEqual(image.test(), "Hello world!")

    def test_register_loader_different_extension_at_same_time_tuple(self):
        """
        Tests that a single backend can be assigned to load two extensions with
        a single call to register_loader using a tuple
        """
        Image.register_loader(('jpeg', 'gif'), self.FakeBackend)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (0, self.FakeBackend),
            ],
            'gif': [
                (0, self.FakeBackend),
            ],
        })

    def test_register_loader_priority_multiple_other_way(self):
        """
        Tests that register_loader keeps the loaders list sorted by priority

        Same as above test, just inserting in opposite way to make sure the
        loaders are being sorted by priority (and not insertion order)
        """
        Image.register_loader('jpeg', self.FakeBackend, priority=200)
        Image.register_loader('jpeg', self.AnotherFakeBackend, priority=100)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (100, self.AnotherFakeBackend),
                (200, self.FakeBackend),
            ],
        })

    def test_calls_function(self):
        """
        Tests that calling the operation calls the underlying function
        """
        def myop(backend):
            backend.func_called = True

        self.FakeBackend.operations = {
            'test': myop,
        }

        image = Image(self.FakeBackend(), 'jpeg')
        image.backend.func_called = False
        image.test()

        self.assertTrue(image.backend.func_called)

    def test_register_loader_different_extension(self):
        """
        Tests that register_loader stores loaders for different extensions
        separately
        """
        Image.register_loader('jpeg', self.FakeBackend)
        Image.register_loader('gif', self.FakeBackend)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (0, self.FakeBackend),
            ],
            'gif': [
                (0, self.FakeBackend),
            ],
        })

    def get_willow_image(self):
        # Open file if it is closed
        close_file = False
        try:
            image_file = self.file

            if self.file.closed:
                # Reopen the file
                if self.is_stored_locally():
                    self.file.open('rb')
                else:
                    # Some external storage backends don't allow reopening
                    # the file. Get a fresh file instance. #1397
                    storage = self._meta.get_field('file').storage
                    image_file = storage.open(self.file.name, 'rb')

                close_file = True
        except IOError as e:
            # re-throw this as a SourceImageIOError so that calling code can distinguish
            # these from IOErrors elsewhere in the process
            raise SourceImageIOError(text_type(e))

        # Seek to beginning
        image_file.seek(0)

        try:
            yield WillowImage.open(image_file)
        finally:
            if close_file:
                image_file.close()