<?php
/**
 * ezcConsoleToolsOutputTest 
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 * @package ImageAnalysis
 * @version //autogen//
 * @subpackage Tests
 * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
 */

/**
 * Test suite for ImageAnalyzer class.
 * 
 * @package ImageAnalysis
 * @subpackage Tests
 */
class ezcImageAnalysisAnalyzerTest extends ezcTestCase
{

    protected $basePath;

    protected $testFiles = array( 
        'exif_jpeg'       => 'jpeg_exif.jpg',
        'noexif_jpeg'     => 'jpeg_noexif.jpg',
        'exif_tiff'       => 'tiff_exif.tiff',
        'noexif_tiff'     => 'tiff_noexif.tiff',
        'animated_gif'    => 'gif_animated.gif',
        'noanimated_gif'  => 'gif_nonanimated.gif',
        'noanimated_png'  => 'png_nonanimated.png',
        'svg'             => 'svg.svg',
    );

	public static function suite()
	{
		return new PHPUnit_Framework_TestSuite( "ezcImageAnalysisAnalyzerTest" );
	}

    protected function setUp()
    {
        if ( !ezcBaseFeatures::hasExtensionSupport( 'exif' ) )
        {
            $this->markTestSkipped( 'ext/exif is required to run this test.' );
        }

        $this->basePath = dirname( __FILE__ ) . '/data/';
    }

    public function testPhpHandlerGetMimeJpegExif()
    {
        $file =  $this->basePath . $this->testFiles['exif_jpeg'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            'image/jpeg',
            $analyzer->mime,
            'MIME-Type was not determined correctly for JPEG.'
        );
    }
    
    public function testImagemagickHandlerGetMimeJpegExif()
    {
        $file =  $this->basePath . $this->testFiles['exif_jpeg'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            'image/jpeg',
            $analyzer->mime,
            'MIME-Type was not determined correctly for JPEG.'
        );
    }

    public function testPhpHandlerGetMimeJpegNoexif()
    {
        $file =  $this->basePath . $this->testFiles['noexif_jpeg'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            'image/jpeg',
            $analyzer->mime,
            'MIME-Type was not determined correctly for JPEG.'
        );
    }
    
    public function testImagemagickHandlerGetMimeJpegNoexif()
    {
        $file =  $this->basePath . $this->testFiles['noexif_jpeg'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            'image/jpeg',
            $analyzer->mime,
            'MIME-Type was not determined correctly for JPEG.'
        );
    }

    public function testPhpHandlerGetMimeTiffExif()
    {
        $file =  $this->basePath . $this->testFiles['exif_tiff'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            'image/tiff',
            $analyzer->mime,
            'MIME-Type was not determined correctly for TIFF.'
        );
    }

    public function testImagemagickHandlerGetMimeTiffExif()
    {
        $file =  $this->basePath . $this->testFiles['exif_tiff'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            'image/tiff',
            $analyzer->mime,
            'MIME-Type was not determined correctly for TIFF.'
        );
    }

    public function testPhpHandlerGetMimeTiffNoexif()
    {
        $file =  $this->basePath . $this->testFiles['noexif_tiff'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            'image/tiff',
            $analyzer->mime,
            'MIME-Type was not determined correctly for TIFF.'
        );
    }

    public function testImagemagickHandlerGetMimeTiffNoexif()
    {
        $file =  $this->basePath . $this->testFiles['noexif_tiff'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            'image/tiff',
            $analyzer->mime,
            'MIME-Type was not determined correctly for TIFF.'
        );
    }

    public function testPhpHandlerGetMimeGifNonanimated()
    {
        $file =  $this->basePath . $this->testFiles['noanimated_gif'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            'image/gif',
            $analyzer->mime,
            'MIME-Type was not determined correctly for GIF.'
        );
    }
    
    public function testImagemagickHandlerGetMimeGifNonanimated()
    {
        $file =  $this->basePath . $this->testFiles['noanimated_gif'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            'image/gif',
            $analyzer->mime,
            'MIME-Type was not determined correctly for GIF.'
        );
    }

    public function testPhpHandlerGetMimeGifAnimated()
    {
        $file =  $this->basePath . $this->testFiles['animated_gif'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            'image/gif',
            $analyzer->mime,
            'MIME-Type was not determined correctly for GIF.'
        );
    }
    
    public function testImagemagickHandlerGetMimeGifAnimated()
    {    
        $file =  $this->basePath . $this->testFiles['animated_gif'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            'image/gif',
            $analyzer->mime,
            'MIME-Type was not determined correctly for GIF.'
        );
    }

    public function testPhpHandlerGetMimePngNonanimated()
    {
        $file =  $this->basePath . $this->testFiles['noanimated_png'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            'image/png',
            $analyzer->mime,
            'MIME-Type was not determined correctly for PNG.'
        );
    }
        
    public function testImagemagickHandlerGetMimePngNonanimated()
    {
        $file =  $this->basePath . $this->testFiles['noanimated_png'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            'image/png',
            $analyzer->mime,
            'MIME-Type was not determined correctly for PNG.'
        );
    }

    public function testPhpHandlerJpegExifReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['exif_jpeg'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            399,
            $analyzer->data->width,
            '<width> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            600,
            $analyzer->data->height,
            '<height> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->isColor,
            '<isColor> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            ' ',
            $analyzer->data->comment,
            '<comment> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            76383,
            $analyzer->data->size,
            '<size> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->hasThumbnail,
            '<hasThumbnail> not extracted correctly for JPEG.'
        );
    }
        
    public function testImagemagickHandlerJpegExifReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['exif_jpeg'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            399,
            $analyzer->data->width,
            '<width> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            600,
            $analyzer->data->height,
            '<height> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->isColor,
            '<isColor> not extracted correctly for JPEG.'
        );
        // @FIXME: update test case, as soon as Exif works here.
        $this->assertSame( 
            null,
            $analyzer->data->comment,
            '<comment> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            76383,
            $analyzer->data->size,
            '<size> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for JPEG.'
        );
        // @FIXME: update test case, as soon as Exif works here.
        /*
        $this->assertSame( 
            true,
            $analyzer->data->hasThumbnail,
            '<hasThumbnail> not extracted correctly for JPEG.'
        );
        */
    }

    public function testPhpHandlerJpegNoexifReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['noexif_jpeg'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            399,
            $analyzer->data->width,
            '<width> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            600,
            $analyzer->data->height,
            '<height> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->isColor,
            '<isColor> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            null,
            $analyzer->data->comment,
            '<comment> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            68802,
            $analyzer->data->size,
            '<size> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->hasThumbnail,
            '<hasThumbnail> not extracted correctly for JPEG.'
        );
    }
        
    public function testImagemagickHandlerJpegNoexifReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['noexif_jpeg'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            399,
            $analyzer->data->width,
            '<width> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            600,
            $analyzer->data->height,
            '<height> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->isColor,
            '<isColor> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            null,
            $analyzer->data->comment,
            '<comment> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            68802,
            $analyzer->data->size,
            '<size> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for JPEG.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->hasThumbnail,
            '<hasThumbnail> not extracted correctly for JPEG.'
        );
    }

    public function testPhpHandlerTiffExifReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['exif_tiff'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            399,
            $analyzer->data->width,
            '<width> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            600,
            $analyzer->data->height,
            '<height> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->isColor,
            '<isColor> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            null,
            $analyzer->data->comment,
            '<comment> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            108125,
            $analyzer->data->size,
            '<size> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->hasThumbnail,
            '<hasThumbnail> not extracted correctly for TIFF.'
        );
    }
        
    public function testImagemagickHandlerTiffExifReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['exif_tiff'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            399,
            $analyzer->data->width,
            '<width> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            600,
            $analyzer->data->height,
            '<height> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->isColor,
            '<isColor> not extracted correctly for TIFF.'
        );
        // FIXME: Exif does not show comment, but ImageMagick does!!!
        $this->assertSame( 
            'A simple comment in a TIFF file.',
            $analyzer->data->comment,
            '<comment> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            108125,
            $analyzer->data->size,
            '<size> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->hasThumbnail,
            '<hasThumbnail> not extracted correctly for TIFF.'
        );
    }

    public function testPhpHandlerTiffNoexifReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['noexif_tiff'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            399,
            $analyzer->data->width,
            '<width> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            600,
            $analyzer->data->height,
            '<height> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->isColor,
            '<isColor> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            null,
            $analyzer->data->comment,
            '<comment> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            108043,
            $analyzer->data->size,
            '<size> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->hasThumbnail,
            '<hasThumbnail> not extracted correctly for TIFF.'
        );
    }
    
    public function testImagemagickHandlerTiffNoexifReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['noexif_tiff'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            399,
            $analyzer->data->width,
            '<width> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            600,
            $analyzer->data->height,
            '<height> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            true,
            $analyzer->data->isColor,
            '<isColor> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            null,
            $analyzer->data->comment,
            '<comment> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            108043,
            $analyzer->data->size,
            '<size> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for TIFF.'
        );
        $this->assertSame( 
            false,
            $analyzer->data->hasThumbnail,
            '<hasThumbnail> not extracted correctly for TIFF.'
        );
    }

    public function testPhpHandlerPngReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['noanimated_png'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            160,
            $analyzer->data->width,
            '<width> not extracted correctly for PNG.'
        );
        $this->assertSame( 
            120,
            $analyzer->data->height,
            '<height> not extracted correctly for PNG.'
        );
        $this->assertSame( 
            5420,
            $analyzer->data->size,
            '<size> not extracted correctly for PNG.'
        );
    }
    
    public function testImagemagickHandlerPngReportsDetails()
    {
        $file =  $this->basePath . $this->testFiles['noanimated_png'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            160,
            $analyzer->data->width,
            '<width> not extracted correctly for PNG.'
        );
        $this->assertSame( 
            120,
            $analyzer->data->height,
            '<height> not extracted correctly for PNG.'
        );
        $this->assertSame( 
            5420,
            $analyzer->data->size,
            '<size> not extracted correctly for PNG.'
        );
    }
    
    public function testPhpHandlerAnimatedGifReportsAnimated()
    {
        $file =  $this->basePath . $this->testFiles['animated_gif'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame(
            true,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for GIF.'
        );
    }

    public function testImagemagickHandlerAnimatedGifReportsAnimated()
    {
        $file =  $this->basePath . $this->testFiles['animated_gif'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame(
            true,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for GIF.'
        );
    }

    public function testPhpHandlerNoexifJpegReportsNotAnimated()
    {
        $file =  $this->basePath . $this->testFiles['noexif_jpeg'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame(
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> no extracted correctly for JPEG.'
        );
    }

    public function testImagemagickHandlerNoexifJpegReportsNotAnimated()
    {
        $file =  $this->basePath . $this->testFiles['noexif_jpeg'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame(
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> no extracted correctly for JPEG.'
        );
    }
    
    public function testPhpHandlerNonanimatedGifReportsNotAnimated()
    {
        $file =  $this->basePath . $this->testFiles['noanimated_gif'];
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for GIF.'
        );
    }
    
    public function testImagemagickHandlerNonanimatedGifReportsNotAnimated()
    {
        $file =  $this->basePath . $this->testFiles['noanimated_gif'];
        $analyzer = $this->getAnalyzerImagemagickHandler( $file );
        $this->assertSame( 
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for GIF.'
        );
    }

    public function testPhpHandlerExifJpegReportsNotAnimated()
    {
        $file =  $this->basePath . $this->testFiles['exif_jpeg'];

        // Test Php handler
        $analyzer = $this->getAnalyzerPhpHandler( $file );
        $this->assertSame(
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for JPEG.'
        );
    }
    
    public function testImagemagickHandlerExifJpegReportsNotAnimated()
    {    
        $file =  $this->basePath . $this->testFiles['exif_jpeg'];

        // Test ImageMagick handler
        $analyzer = $this->getAnalyzerImageMagickHandler( $file );
        $this->assertSame(
            false,
            $analyzer->data->isAnimated,
            '<isAnimated> not extracted correctly for JPEG.'
        );
    }

    public function testSvgMimeType()
    {
        $file = $this->basePath . $this->testFiles['svg'];
        $analyzer = $this->getAnalyzerImageMagickHandler( $file );
        $this->assertEquals(
            "image/svg+xml",
            $analyzer->mime,
            '<mime> not extracted correctly for SVG.'
        );
    }

    public function testAnalyzerGeneralNotProcessable()
    {

    }

    protected function getAnalyzerPhpHandler( $file )
    {
        ezcImageAnalyzer::setHandlerClasses( array( 'ezcImageAnalyzerPhpHandler' => array() ) );
        return new ezcImageAnalyzer( $file );
    }
    
    protected function getAnalyzerImageMagickHandler( $file )
    {
        ezcImageAnalyzer::setHandlerClasses( array( 'ezcImageAnalyzerImagemagickHandler' => array() ) );
        return new ezcImageAnalyzer( $file );
    }

    public function testPropertiesGetInvalid()
    {
        $file = $this->basePath . $this->testFiles['svg'];
        $analyzer = $this->getAnalyzerImageMagickHandler( $file );
        try
        {
            $analyzer->no_such_property;
            $this->fail( 'Expected exception was not thrown.' );
        }
        catch ( ezcBasePropertyNotFoundException $e )
        {
            $expected = "No such property name 'no_such_property'.";
            $this->assertEquals( $expected, $e->getMessage() );
        }
    }

    public function testPropertiesSetDenied()
    {
        $file = $this->basePath . $this->testFiles['svg'];
        $analyzer = $this->getAnalyzerImageMagickHandler( $file );
        try
        {
            $analyzer->mime = 'some value';
            $this->fail( 'Expected exception was not thrown.' );
        }
        catch ( ezcBasePropertyPermissionException $e )
        {
            $expected = "The property 'mime' is read-only.";
            $this->assertEquals( $expected, $e->getMessage() );
        }
    }

    public function testPropertiesSetInvalid()
    {
        $file = $this->basePath . $this->testFiles['svg'];
        $analyzer = $this->getAnalyzerImageMagickHandler( $file );
        try
        {
            $analyzer->no_such_property = 'some value';
            $this->fail( 'Expected exception was not thrown.' );
        }
        catch ( ezcBasePropertyNotFoundException $e )
        {
            $expected = "No such property name 'no_such_property'.";
            $this->assertEquals( $expected, $e->getMessage() );
        }
    }

    public function testImagemagickHandlerNonExistentFile()
    {
        $fileName = $this->basePath . "no_such_file.svg";
        try
        {
            $analyzer = $this->getAnalyzerImageMagickHandler( $fileName );
            $this->fail( 'Expected exception was not thrown' );
        }
        catch ( ezcBaseFileNotFoundException $e )
        {
            $expected = "The file '{$fileName}' could not be found.";
            $this->assertEquals( $expected, $e->getMessage() );
        }
    }

    public function testImagemagickHandlerUnreadableFile()
    {
        $tempDir = $this->createTempDir( 'ezcImageAnalysisAnalyzerTest' );
        $fileName = $tempDir . "/test-unreadable.svg";
        $fileHandle = fopen( $fileName, "wb" );
        fwrite( $fileHandle, "some contents" );
        fclose( $fileHandle );
        chmod( $fileName, 0 );

        try
        {
            $analyzer = $this->getAnalyzerImageMagickHandler( $fileName );
            $this->fail( 'Expected exception was not thrown' );
        }
        catch ( ezcBaseFilePermissionException $e )
        {
            $this->removeTempDir();
            $expected = "The file '{$fileName}' can not be opened for reading.";
            $this->assertEquals( $expected, $e->getMessage() );
        }
    }

    public function testImagemagickHandlerNotProcessableFile()
    {
        $tempDir = $this->createTempDir( 'ezcImageAnalysisAnalyzerTest' );
        $fileName = $tempDir . "/test-unreadable.svg";
        $fileHandle = fopen( $fileName, "wb" );
        fwrite( $fileHandle, "some contents" );
        fclose( $fileHandle );

        try
        {
            $analyzer = $this->getAnalyzerImageMagickHandler( $fileName );
            $this->fail( 'Expected exception was not thrown' );
        }
        catch ( ezcImageAnalyzerFileNotProcessableException $e )
        {
            $this->removeTempDir();
            $expected = "Could not process file '{$fileName}'. Reason: Could not determine MIME type of file..";
            $this->assertEquals( $expected, $e->getMessage() );
        }
    }

    public function testGetHandlerClasses()
    {
        ezcImageAnalyzer::getHandlerClasses();
    }

    public function testIsSet()
    {
        $file = $this->basePath . $this->testFiles['svg'];
        $analyzer = $this->getAnalyzerImageMagickHandler( $file );
        $this->assertEquals( true, isset( $analyzer->mime ) );
        $this->assertEquals( true, isset( $analyzer->data ) );
        $this->assertEquals( false, isset( $analyzer->no_such_property ) );
    }
}
?>