Version 0.3

2013-06-25 10:03:20 +02:00 · 2013-06-25 10:03:20 +02:00 · ad3a5af623
commit ad3a5af623
parent 0d69145ec3
130 changed files with 7283 additions and 2627 deletions
--- a/tests/FFMpeg/Functional/FunctionalTestCase.php
+++ b/tests/FFMpeg/Functional/FunctionalTestCase.php
@ -0,0 +1,13 @@
+<?php
+
+namespace FFMpeg\Functional;
+
+use FFMpeg\FFMpeg;
+
+abstract class FunctionalTestCase extends \PHPUnit_Framework_TestCase
+{
+    public function getFFMpeg()
+    {
+        return FFMpeg::create(array('timeout' => 300));
+    }
+}
--- a/tests/FFMpeg/Functional/VideoTranscodeTest.php
+++ b/tests/FFMpeg/Functional/VideoTranscodeTest.php
@ -0,0 +1,38 @@
+<?php
+
+namespace FFMpeg\Functional;
+
+use FFMpeg\Format\Video\X264;
+
+class VideoTranscodeTest extends FunctionalTestCase
+{
+    public function testSimpleTranscodeX264()
+    {
+        $filename = __DIR__ . '/output/output-x264.mp4';
+        if (is_file($filename)) {
+            unlink(__DIR__ . '/output/output-x264.mp4');
+        }
+
+        $ffmpeg = $this->getFFMpeg();
+        $video = $ffmpeg->open(__DIR__ . '/../../files/Test.ogv');
+
+        $this->assertInstanceOf('FFMpeg\Media\Video', $video);
+
+        $lastPercentage = null;
+        $phpunit = $this;
+
+        $codec = new X264('libvo_aacenc');
+        $codec->on('progress', function ($video, $codec, $percentage) use ($phpunit, &$lastPercentage) {
+            if (null !== $lastPercentage) {
+                $phpunit->assertGreaterThanOrEqual($lastPercentage, $percentage);
+            }
+            $lastPercentage = $percentage;
+            $phpunit->assertGreaterThanOrEqual(0, $percentage);
+            $phpunit->assertLessThanOrEqual(100, $percentage);
+        });
+
+        $video->save($codec, $filename);
+        $this->assertFileExists($filename);
+        unlink($filename);
+    }
+}
--- a/tests/FFMpeg/Functional/output/.placeholder
+++ b/tests/FFMpeg/Functional/output/.placeholder
--- a/tests/FFMpeg/Tests/Coordinate/AspectRatioTest.php
+++ b/tests/FFMpeg/Tests/Coordinate/AspectRatioTest.php
@ -0,0 +1,83 @@
+<?php
+
+namespace FFMpeg\Tests\Coordinate;
+
+use FFMpeg\Coordinate\Dimension;
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Coordinate\AspectRatio;
+
+class AspectRatioTest extends TestCase
+{
+    /**
+     * @dataProvider provideDimensionsAndExpectedratio
+     */
+    public function testFromDimensions($width, $height, $strategy, $expected, $calculatedWidth, $calculatedHeight, $modulus = 2)
+    {
+        $ratio = AspectRatio::create(new Dimension($width, $height), $strategy);
+        $this->assertEquals($expected, $ratio->getValue());
+
+        $this->assertEquals($calculatedHeight, $ratio->calculateHeight(240, $modulus));
+        $this->assertEquals($calculatedWidth, $ratio->calculateWidth(320, $modulus));
+    }
+
+    public function provideDimensionsAndExpectedratio()
+    {
+        return array(
+            //AR_5_4
+            array(720, 576, false, 5/4, 400, 192),
+            array(720, 577, false, 5/4, 400, 192),
+            array(720, 620, false, 720/620, 372, 206),
+            array(720, 576, true, 5/4, 400, 192),
+            //AR_ROTATED_4_5
+            array(576, 720, false, 4/5, 256, 300),
+            array(576, 720, true, 4/5, 256, 300),
+            //AR_4_3
+            array(320, 240, false, 4/3, 426, 180),
+            array(320, 240, true, 4/3, 426, 180),
+            //AR_ROTATED_3_4
+            array(240, 320, false, 3/4, 240, 320),
+            array(240, 320, true, 3/4, 240, 320),
+            //AR_16_9
+            array(1920, 1080, false, 16/9, 568, 136),
+            array(1920, 1080, true, 16/9, 568, 136),
+            array(1280, 720, false, 16/9, 568, 136),
+            array(1280, 720, true, 16/9, 568, 136),
+            array(3840, 2160, false, 16/9, 568, 136),
+            array(3840, 2160, true, 16/9, 568, 136),
+            // modulus 4
+            array(1920, 1080, false, 16/9, 568, 136, 4),
+            array(1920, 1080, true, 16/9, 568, 136, 4),
+            array(1280, 720, false, 16/9, 568, 136, 4),
+            array(1280, 720, true, 16/9, 568, 136, 4),
+            array(3840, 2160, false, 16/9, 568, 136, 4),
+            array(3840, 2160, true, 16/9, 568, 136, 4),
+            // modulus 16
+            array(1920, 1080, false, 16/9, 576, 128, 16),
+            array(1920, 1080, true, 16/9, 576, 128, 16),
+            array(1280, 720, false, 16/9, 576, 128, 16),
+            array(1280, 720, true, 16/9, 576, 128, 16),
+            array(3840, 2160, false, 16/9, 576, 128, 16),
+            array(3840, 2160, true, 16/9, 576, 128, 16),
+            //AR_ROTATED_9_16
+            array(1080, 1920, false, 9/16, 180, 426),
+            array(1080, 1920, true, 9/16, 180, 426),
+            array(720, 1280, false, 9/16, 180, 426),
+            array(720, 1280, true, 9/16, 180, 426),
+            array(2160, 3840, false, 9/16, 180, 426),
+            array(2160, 3840, true, 9/16, 180, 426),
+            //AR_3_2
+            array(360, 240, false, 3/2, 480, 160),
+            array(360, 240, true, 3/2, 480, 160),
+            //AR_ROTATED_2_3
+            array(240, 360, false, 2/3, 214, 360),
+            array(240, 360, true, 2/3, 214, 360),
+            //AR_5_3
+            //AR_ROTATED_3_5
+            //AR_1_1
+            //AR_1_DOT_85_1
+            //AR_ROTATED_1_DOT_85
+            //AR_2_DOT_39_1
+            //AR_ROTATED_2_DOT_39
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/Coordinate/DimensionTest.php
+++ b/tests/FFMpeg/Tests/Coordinate/DimensionTest.php
@ -0,0 +1,38 @@
+<?php
+
+namespace FFMpeg\Tests\Coordinate;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Coordinate\Dimension;
+
+class DimensionTest extends TestCase
+{
+    /**
+     * @dataProvider provideInvalidDimensions
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testInvalidDimensions($width, $height)
+    {
+        new Dimension($width, $height);
+    }
+
+    public function provideInvalidDimensions()
+    {
+        return array(
+            array(320, 0),
+            array(320, -10),
+            array(0, 240),
+            array(-10, 240),
+            array(0, 0),
+            array(0, -10),
+            array(-10, 0),
+        );
+    }
+
+    public function testGetters()
+    {
+        $dimension = new Dimension(320, 240);
+        $this->assertEquals(320, $dimension->getWidth());
+        $this->assertEquals(240, $dimension->getHeight());
+    }
+}
--- a/tests/FFMpeg/Tests/Coordinate/FrameRateTest.php
+++ b/tests/FFMpeg/Tests/Coordinate/FrameRateTest.php
@ -0,0 +1,31 @@
+<?php
+
+namespace FFMpeg\Tests\Coordinate;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Coordinate\FrameRate;
+
+class FrameRateTest extends TestCase
+{
+    public function testGetter()
+    {
+        $fr = new FrameRate(23.997);
+        $this->assertEquals(23.997, $fr->getValue());
+    }
+
+    /**
+     * @dataProvider provideInvalidFrameRates
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testInvalidFrameRate($value)
+    {
+        new FrameRate($value);
+    }
+
+    public function provideInvalidFrameRates()
+    {
+        return array(
+            array(0), array(-1.5), array(-2),
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/Coordinate/PointTest.php
+++ b/tests/FFMpeg/Tests/Coordinate/PointTest.php
@ -0,0 +1,16 @@
+<?php
+
+namespace FFMpeg\Tests\Coordinate;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Coordinate\Point;
+
+class PointTest extends TestCase
+{
+    public function testGetters()
+    {
+        $point = new Point(4, 25);
+        $this->assertEquals(4, $point->getX());
+        $this->assertEquals(25, $point->getY());
+    }
+}
--- a/tests/FFMpeg/Tests/Coordinate/TimeCodeTest.php
+++ b/tests/FFMpeg/Tests/Coordinate/TimeCodeTest.php
@ -0,0 +1,38 @@
+<?php
+
+namespace FFMpeg\Tests\Coordinate;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Coordinate\TimeCode;
+
+class TimeCodeTest extends TestCase
+{
+    /**
+     * @dataProvider provideTimecodes
+     */
+    public function testFromString($timecode, $expected)
+    {
+        $tc = TimeCode::fromString($timecode);
+        $this->assertEquals((string) $tc, $expected);
+    }
+
+    public function provideTimeCodes()
+    {
+        return array(
+            array('1:02:04:05:20', '26:04:05.20'),
+            array('1:02:04:05.20', '26:04:05.20'),
+            array('02:04:05:20', '02:04:05.20'),
+            array('02:04:05.20', '02:04:05.20'),
+            array('00:00:05.20', '00:00:05.20'),
+            array('00:00:00.00', '00:00:00.00'),
+        );
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testFromInvalidString()
+    {
+        TimeCode::fromString('lalali lala');
+    }
+}
--- a/tests/FFMpeg/Tests/Driver/FFMpegDriverTest.php
+++ b/tests/FFMpeg/Tests/Driver/FFMpegDriverTest.php
@ -0,0 +1,43 @@
+<?php
+
+namespace FFMpeg\Tests\Driver;
+
+use Alchemy\BinaryDriver\Configuration;
+use FFMpeg\Driver\FFMpegDriver;
+use FFMpeg\Tests\TestCase;
+use Symfony\Component\Process\ExecutableFinder;
+
+class FFMpegDriverTest extends TestCase
+{
+    public function setUp()
+    {
+        $executableFinder = new ExecutableFinder();
+
+        $found = false;
+        foreach (array('avconv', 'ffmpeg') as $name) {
+            if (null !== $executableFinder->find($name)) {
+                $found = true;
+                break;
+            }
+        }
+
+        if (!$found) {
+            $this->markTestSkipped('Neither ffmpeg or avconv found');
+        }
+    }
+
+    public function testCreate()
+    {
+        $logger = $this->getLoggerMock();
+        $ffmpeg = FFMpegDriver::create($logger, array());
+        $this->assertInstanceOf('FFMpeg\Driver\FFMpegDriver', $ffmpeg);
+        $this->assertEquals($logger, $ffmpeg->getProcessRunner()->getLogger());
+    }
+
+    public function testCreateWithConfig()
+    {
+        $conf = new Configuration();
+        $ffmpeg = FFMpegDriver::create($this->getLoggerMock(), $conf);
+        $this->assertEquals($conf, $ffmpeg->getConfiguration());
+    }
+}
--- a/tests/FFMpeg/Tests/Driver/FFProbeDriverTest.php
+++ b/tests/FFMpeg/Tests/Driver/FFProbeDriverTest.php
@ -0,0 +1,43 @@
+<?php
+
+namespace FFMpeg\Tests\Driver;
+
+use Alchemy\BinaryDriver\Configuration;
+use FFMpeg\Driver\FFProbeDriver;
+use FFMpeg\Tests\TestCase;
+use Symfony\Component\Process\ExecutableFinder;
+
+class FFProbeDriverTest extends TestCase
+{
+    public function setUp()
+    {
+        $executableFinder = new ExecutableFinder();
+
+        $found = false;
+        foreach (array('avprobe', 'ffprobe') as $name) {
+            if (null !== $executableFinder->find($name)) {
+                $found = true;
+                break;
+            }
+        }
+
+        if (!$found) {
+            $this->markTestSkipped('Neither ffprobe or avprobe found');
+        }
+    }
+
+    public function testCreate()
+    {
+        $logger = $this->getLoggerMock();
+        $ffprobe = FFProbeDriver::create(array(), $logger);
+        $this->assertInstanceOf('FFMpeg\Driver\FFProbeDriver', $ffprobe);
+        $this->assertEquals($logger, $ffprobe->getProcessRunner()->getLogger());
+    }
+
+    public function testCreateWithConfig()
+    {
+        $conf = new Configuration();
+        $ffprobe = FFProbeDriver::create($conf, $this->getLoggerMock());
+        $this->assertEquals($conf, $ffprobe->getConfiguration());
+    }
+}
--- a/tests/FFMpeg/Tests/FFMpegServiceProviderTest.php
+++ b/tests/FFMpeg/Tests/FFMpegServiceProviderTest.php
@ -0,0 +1,69 @@
+<?php
+
+namespace FFMpeg\Tests;
+
+use FFMpeg\FFMpegServiceProvider;
+use Silex\Application;
+
+class FFMpegServiceProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testWithConfig()
+    {
+        $app = new Application();
+        $app->register(new FFMpegServiceProvider(), array(
+            'ffmpeg.configuration' => array(
+                'ffmpeg.threads'   => 12,
+                'ffmpeg.timeout'   => 10666,
+                'ffprobe.timeout'  => 4242,
+            )
+        ));
+
+        $this->assertInstanceOf('FFMpeg\FFMpeg', $app['ffmpeg']);
+        $this->assertSame($app['ffmpeg'], $app['ffmpeg.ffmpeg']);
+        $this->assertInstanceOf('FFMpeg\FFProbe', $app['ffmpeg.ffprobe']);
+
+        $this->assertEquals(12, $app['ffmpeg']->getFFMpegDriver()->getConfiguration()->get('ffmpeg.threads'));
+        $this->assertEquals(10666, $app['ffmpeg']->getFFMpegDriver()->getProcessBuilderFactory()->getTimeout());
+        $this->assertEquals(4242, $app['ffmpeg.ffprobe']->getFFProbeDriver()->getProcessBuilderFactory()->getTimeout());
+    }
+
+    public function testWithoutConfig()
+    {
+        $app = new Application();
+        $app->register(new FFMpegServiceProvider());
+
+        $this->assertInstanceOf('FFMpeg\FFMpeg', $app['ffmpeg']);
+        $this->assertSame($app['ffmpeg'], $app['ffmpeg.ffmpeg']);
+        $this->assertInstanceOf('FFMpeg\FFProbe', $app['ffmpeg.ffprobe']);
+
+        $this->assertEquals(4, $app['ffmpeg']->getFFMpegDriver()->getConfiguration()->get('ffmpeg.threads'));
+        $this->assertEquals(300, $app['ffmpeg']->getFFMpegDriver()->getProcessBuilderFactory()->getTimeout());
+        $this->assertEquals(30, $app['ffmpeg.ffprobe']->getFFProbeDriver()->getProcessBuilderFactory()->getTimeout());
+    }
+
+    public function testWithFFMpegBinaryConfig()
+    {
+        $app = new Application();
+        $app->register(new FFMpegServiceProvider(), array(
+            'ffmpeg.configuration' => array(
+                'ffmpeg.binaries' => '/path/to/ffmpeg',
+            )
+        ));
+
+        $this->setExpectedException('Alchemy\BinaryDriver\Exception\ExecutableNotFoundException', 'Executable not found, proposed : /path/to/ffmpeg');
+        $app['ffmpeg'];
+    }
+
+    public function testWithFFMprobeBinaryConfig()
+    {
+        $app = new Application();
+        $app->register(new FFMpegServiceProvider(), array(
+            'ffmpeg.configuration' => array(
+                'ffprobe.binaries' => '/path/to/ffprobe',
+            )
+        ));
+
+        $this->setExpectedException('Alchemy\BinaryDriver\Exception\ExecutableNotFoundException', 'Executable not found, proposed : /path/to/ffprobe');
+        $app['ffmpeg.ffprobe'];
+    }
+}
--- a/tests/FFMpeg/Tests/FFMpegTest.php
+++ b/tests/FFMpeg/Tests/FFMpegTest.php
@ -0,0 +1,112 @@
+<?php
+
+namespace FFMpeg\Tests;
+
+use FFMpeg\FFMpeg;
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+use FFMpeg\FFProbe\DataMapping\Stream;
+
+class FFMpegTest Extends TestCase
+{
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testOpenInvalid()
+    {
+        $ffmpeg = new FFMpeg($this->getFFMpegDriverMock(), $this->getFFProbeMock());
+        $ffmpeg->open('/path/to/unknown/file');
+    }
+
+    public function testOpenAudio()
+    {
+        $streams = $this->getStreamCollectionMock();
+        $streams->expects($this->once())
+            ->method('audios')
+            ->will($this->returnValue(new StreamCollection(array(new Stream(array())))));
+        $streams->expects($this->once())
+            ->method('videos')
+            ->will($this->returnValue(array()));
+
+        $ffprobe = $this->getFFProbeMock();
+        $ffprobe->expects($this->once())
+            ->method('streams')
+            ->with(__FILE__)
+            ->will($this->returnValue($streams));
+
+        $ffmpeg = new FFMpeg($this->getFFMpegDriverMock(), $ffprobe);
+        $this->assertInstanceOf('FFMpeg\Media\Audio', $ffmpeg->open(__FILE__));
+    }
+
+    public function testOpenVideo()
+    {
+        $streams = $this->getStreamCollectionMock();
+        $streams->expects($this->once())
+            ->method('videos')
+            ->will($this->returnValue(new StreamCollection(array(new Stream(array())))));
+        $streams->expects($this->never())
+            ->method('audios');
+
+        $ffprobe = $this->getFFProbeMock();
+        $ffprobe->expects($this->once())
+            ->method('streams')
+            ->with(__FILE__)
+            ->will($this->returnValue($streams));
+
+        $ffmpeg = new FFMpeg($this->getFFMpegDriverMock(), $ffprobe);
+        $this->assertInstanceOf('FFMpeg\Media\Video', $ffmpeg->open(__FILE__));
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testOpenUnknown()
+    {
+        $ffprobe = $this->getFFProbeMock();
+        $ffprobe->expects($this->once())
+            ->method('streams')
+            ->with(__FILE__)
+            ->will($this->returnValue(new StreamCollection()));
+
+        $ffmpeg = new FFMpeg($this->getFFMpegDriverMock(), $ffprobe);
+        $ffmpeg->open(__FILE__);
+    }
+
+    public function testCreateWithoutLoggerOrProbe()
+    {
+        $this->assertInstanceOf('FFMpeg\FFMpeg', FFMpeg::create());
+    }
+
+    public function testCreateWithLoggerAndProbe()
+    {
+        $logger = $this->getLoggerMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        $ffmpeg = FFMpeg::create(array('timeout' => 42), $logger, $ffprobe);
+        $this->assertInstanceOf('FFMpeg\FFMpeg', $ffmpeg);
+
+        $this->assertSame($logger, $ffmpeg->getFFMpegDriver()->getProcessRunner()->getLogger());
+        $this->assertSame($ffprobe, $ffmpeg->getFFProbe());
+        $this->assertSame(42, $ffmpeg->getFFMpegDriver()->getProcessBuilderFactory()->getTimeout());
+    }
+
+    public function testGetSetFFProbe()
+    {
+        $ffprobe = $this->getFFProbeMock();
+        $ffmpeg = new FFMpeg($this->getFFMpegDriverMock(), $ffprobe);
+        $this->assertSame($ffprobe, $ffmpeg->getFFProbe());
+        $anotherFFProbe = $this->getFFProbeMock();
+        $ffmpeg->setFFProbe($anotherFFProbe);
+        $this->assertSame($anotherFFProbe, $ffmpeg->getFFProbe());
+    }
+
+    public function testGetSetDriver()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffmpeg = new FFMpeg($driver, $this->getFFProbeMock());
+        $this->assertSame($driver, $ffmpeg->getFFMpegDriver());
+        $anotherDriver = $this->getFFMpegDriverMock();
+        $ffmpeg->setFFMpegDriver($anotherDriver);
+        $this->assertSame($anotherDriver, $ffmpeg->getFFMpegDriver());
+    }
+}
--- a/tests/FFMpeg/Tests/FFProbe/DataMapping/AbstractDataTest.php
+++ b/tests/FFMpeg/Tests/FFProbe/DataMapping/AbstractDataTest.php
@ -0,0 +1,56 @@
+<?php
+
+namespace FFMpeg\Tests\FFProbe\DataMapping;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\DataMapping\AbstractData;
+
+class AbstractDataTest extends TestCase
+{
+    public function testHas()
+    {
+        $imp = new Implementation(array('key1' => 'value1', 'key2' => 'value2'));
+
+        $this->assertTrue($imp->has('key1'));
+        $this->assertTrue($imp->has('key2'));
+        $this->assertFalse($imp->has('value1'));
+        $this->assertFalse($imp->has('key3'));
+    }
+
+    public function testGet()
+    {
+        $imp = new Implementation(array('key1' => 'value1', 'key2' => 'value2'));
+
+        $this->assertEquals('value1', $imp->get('key1'));
+        $this->assertEquals('value2', $imp->get('key2'));
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testGetInvalid()
+    {
+        $imp = new Implementation(array('key1' => 'value1', 'key2' => 'value2'));
+
+        $imp->get('key3');
+    }
+
+    public function testKeys()
+    {
+        $imp = new Implementation(array('key1' => 'value1', 'key2' => 'value2'));
+
+        $this->assertEquals(array('key1', 'key2'), $imp->keys());
+    }
+
+    public function testAll()
+    {
+        $values = array('key1' => 'value1', 'key2' => 'value2');
+        $imp = new Implementation($values);
+
+        $this->assertEquals($values, $imp->all());
+    }
+}
+
+class Implementation extends AbstractData
+{
+}
--- a/tests/FFMpeg/Tests/FFProbe/DataMapping/StreamCollectionTest.php
+++ b/tests/FFMpeg/Tests/FFProbe/DataMapping/StreamCollectionTest.php
@ -0,0 +1,89 @@
+<?php
+
+namespace FFMpeg\Tests\FFProbe\DataMapping;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+
+class StreamCollectionTest extends TestCase
+{
+    public function testAdd()
+    {
+        $stream = $this->getStreamMock();
+
+        $collection = new StreamCollection();
+        $this->assertEquals(array(), $collection->all());
+        $collection->add($stream);
+        $this->assertEquals(array($stream), $collection->all());
+        $collection->add($stream);
+        $this->assertEquals(array($stream, $stream), $collection->all());
+    }
+
+    public function testVideos()
+    {
+        $audio = $this->getStreamMock();
+        $audio->expects($this->once())
+            ->method('isVideo')
+            ->will($this->returnValue(false));
+
+        $video = $this->getStreamMock();
+        $video->expects($this->once())
+            ->method('isVideo')
+            ->will($this->returnValue(true));
+
+        $collection = new StreamCollection(array($audio, $video));
+        $videos = $collection->videos();
+
+        $this->assertInstanceOf('FFMpeg\FFProbe\DataMapping\StreamCollection', $videos);
+        $this->assertCount(1, $videos);
+        $this->assertEquals(array($video), $videos->all());
+    }
+
+    public function testAudios()
+    {
+        $audio = $this->getStreamMock();
+        $audio->expects($this->once())
+            ->method('isAudio')
+            ->will($this->returnValue(true));
+
+        $video = $this->getStreamMock();
+        $video->expects($this->once())
+            ->method('isAudio')
+            ->will($this->returnValue(false));
+
+        $collection = new StreamCollection(array($audio, $video));
+        $audios = $collection->audios();
+
+        $this->assertInstanceOf('FFMpeg\FFProbe\DataMapping\StreamCollection', $audios);
+        $this->assertCount(1, $audios);
+        $this->assertEquals(array($audio), $audios->all());
+    }
+
+    public function testCount()
+    {
+        $stream = $this->getStreamMock();
+
+        $collection = new StreamCollection(array($stream));
+        $this->assertCount(1, $collection);
+    }
+
+    public function testGetIterator()
+    {
+        $audio = $this->getStreamMock();
+        $video = $this->getStreamMock();
+
+        $collection = new StreamCollection(array($audio, $video));
+        $this->assertInstanceOf('\Iterator', $collection->getIterator());
+        $this->assertCount(2, $collection->getIterator());
+    }
+
+    public function testFirst()
+    {
+        $stream1 = $this->getStreamMock();
+        $stream2 = $this->getStreamMock();
+
+        $coll = new StreamCollection(array($stream1, $stream2));
+
+        $this->assertSame($stream1, $coll->first());
+    }
+}
--- a/tests/FFMpeg/Tests/FFProbe/DataMapping/StreamTest.php
+++ b/tests/FFMpeg/Tests/FFProbe/DataMapping/StreamTest.php
@ -0,0 +1,43 @@
+<?php
+
+namespace FFMpeg\Tests\FFProbe\DataMapping;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\DataMapping\Stream;
+
+class StreamTest extends TestCase
+{
+    /**
+     * @dataProvider provideAudioCases
+     */
+    public function testIsAudio($isAudio, $properties)
+    {
+        $stream = new Stream($properties);
+        $this->assertTrue($isAudio === $stream->isAudio());
+    }
+
+    public function provideAudioCases()
+    {
+        return array(
+            array(true, array('codec_type' => 'audio')),
+            array(false, array('codec_type' => 'video')),
+        );
+    }
+
+    /**
+     * @dataProvider provideVideoCases
+     */
+    public function testIsVideo($isVideo, $properties)
+    {
+        $stream = new Stream($properties);
+        $this->assertTrue($isVideo === $stream->isVideo());
+    }
+
+    public function provideVideoCases()
+    {
+        return array(
+            array(true, array('codec_type' => 'video')),
+            array(false, array('codec_type' => 'audio')),
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/FFProbe/MapperTest.php
+++ b/tests/FFMpeg/Tests/FFProbe/MapperTest.php
@ -0,0 +1,44 @@
+<?php
+
+namespace FFMpeg\Tests\FFProbe;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\Mapper;
+use FFMpeg\FFProbe;
+use FFMpeg\FFProbe\DataMapping\Format;
+use FFMpeg\FFProbe\DataMapping\Stream;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+
+class MapperTest extends TestCase
+{
+    /**
+     * @dataProvider provideMappings
+     */
+    public function testMap($type, $data, $expected)
+    {
+        $mapper = new Mapper();
+        $this->assertEquals($expected, $mapper->map($type, $data));
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testMapInvalidArgument()
+    {
+        $mapper = new Mapper();
+        $mapper->map('cool type', 'data');
+    }
+
+    public function provideMappings()
+    {
+        $format = json_decode(file_get_contents(__DIR__ . '/../../../fixtures/ffprobe/show_format.json'), true);
+        $streams = json_decode(file_get_contents(__DIR__ . '/../../../fixtures/ffprobe/show_streams.json'), true);
+
+        return array(
+            array(FFProbe::TYPE_FORMAT, $format, new Format($format['format'])),
+            array(FFProbe::TYPE_STREAMS, $streams, new StreamCollection(array_map(function ($streamData) {
+                return new Stream($streamData);
+            }, $streams['streams']))),
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/FFProbe/OptionsTesterTest.php
+++ b/tests/FFMpeg/Tests/FFProbe/OptionsTesterTest.php
@ -0,0 +1,101 @@
+<?php
+
+namespace FFMpeg\Tests\FFProbe;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\OptionsTester;
+
+class OptionsTesterTest extends TestCase
+{
+    /**
+     * @dataProvider provideOptions
+     */
+    public function testHasOptionWithCacheEmpty($isPresent, $data, $optionName)
+    {
+        $cache = $this->getCacheMock();
+
+        $cache->expects($this->never())
+            ->method('fetch');
+
+        $cache->expects($this->exactly(2))
+            ->method('contains')
+            ->will($this->returnValue(false));
+
+        $cache->expects($this->exactly(2))
+            ->method('save');
+
+        $ffprobe = $this->getFFProbeDriverMock();
+        $ffprobe->expects($this->once())
+            ->method('command')
+            ->with(array('-help', '-loglevel', 'quiet'))
+            ->will($this->returnValue($data));
+
+        $tester = new OptionsTester($ffprobe, $cache);
+        $this->assertTrue($isPresent === $tester->has($optionName));
+    }
+
+    public function provideOptions()
+    {
+        $data = file_get_contents(__DIR__ . '/../../../fixtures/ffprobe/help.raw');
+
+        return array(
+            array(true, $data, '-print_format'),
+            array(false, $data, '-another_print_format'),
+        );
+    }
+
+    /**
+     * @dataProvider provideOptions
+     */
+    public function testHasOptionWithHelpCacheLoaded($isPresent, $data, $optionName)
+    {
+        $cache = $this->getCacheMock();
+
+        $cache->expects($this->once())
+            ->method('fetch')
+            ->will($this->returnValue($data));
+
+        $cache->expects($this->at(0))
+            ->method('contains')
+            ->will($this->returnValue(false));
+
+        $cache->expects($this->at(1))
+            ->method('contains')
+            ->will($this->returnValue(true));
+
+        $cache->expects($this->once())
+            ->method('save');
+
+        $ffprobe = $this->getFFProbeDriverMock();
+        $ffprobe->expects($this->never())
+            ->method('command');
+
+        $tester = new OptionsTester($ffprobe, $cache);
+        $this->assertTrue($isPresent === $tester->has($optionName));
+    }
+
+    /**
+     * @dataProvider provideOptions
+     */
+    public function testHasOptionWithCacheFullyLoaded($isPresent, $data, $optionName)
+    {
+        $cache = $this->getCacheMock();
+
+        $cache->expects($this->once())
+            ->method('fetch')
+            ->with('option-' . $optionName)
+            ->will($this->returnValue($isPresent));
+
+        $cache->expects($this->once())
+            ->method('contains')
+            ->with('option-' . $optionName)
+            ->will($this->returnValue(true));
+
+        $ffprobe = $this->getFFProbeDriverMock();
+        $ffprobe->expects($this->never())
+            ->method('command');
+
+        $tester = new OptionsTester($ffprobe, $cache);
+        $this->assertTrue($isPresent === $tester->has($optionName));
+    }
+}
--- a/tests/FFMpeg/Tests/FFProbe/OutputParserTest.php
+++ b/tests/FFMpeg/Tests/FFProbe/OutputParserTest.php
@ -0,0 +1,42 @@
+<?php
+
+namespace FFMpeg\Tests\FFProbe;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\OutputParser;
+use FFMpeg\FFProbe;
+
+class OutputParserTest extends TestCase
+{
+    /**
+     * @dataProvider provideTypeDataAndOutput
+     */
+    public function testParse($type, $data, $expectedOutput)
+    {
+        $parser = new OutputParser();
+        $this->assertEquals($expectedOutput, $parser->parse($type, $data));
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testParseWithInvalidArgument()
+    {
+        $parser = new OutputParser();
+        $parser->parse('comme ca', 'data');
+    }
+
+    public function provideTypeDataAndOutput()
+    {
+        $expectedFormat = json_decode(file_get_contents(__DIR__ . '/../../../fixtures/ffprobe/show_format.json'), true);
+        $expectedStreams = json_decode(file_get_contents(__DIR__ . '/../../../fixtures/ffprobe/show_streams.json'), true);
+
+        $rawFormat = file_get_contents(__DIR__ . '/../../../fixtures/ffprobe/show_format.raw');
+        $rawStreams = file_get_contents(__DIR__ . '/../../../fixtures/ffprobe/show_streams.raw');
+
+        return array(
+            array(FFProbe::TYPE_FORMAT, $rawFormat, $expectedFormat),
+            array(FFProbe::TYPE_STREAMS, $rawStreams, $expectedStreams),
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/FFProbeTest.php
+++ b/tests/FFMpeg/Tests/FFProbeTest.php
@ -0,0 +1,308 @@
+<?php
+
+namespace FFMpeg\Tests;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe;
+use Symfony\Component\Process\ExecutableFinder;
+use Alchemy\BinaryDriver\ConfigurationInterface;
+use Alchemy\BinaryDriver\Configuration;
+
+class FFProbeTest extends TestCase
+{
+    public function testGetSetParser()
+    {
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+        $parser = $this->getFFProbeParserMock();
+
+        $ffprobe->setParser($parser);
+        $this->assertSame($parser, $ffprobe->getParser());
+    }
+
+    public function testGetSetFFProbeDriver()
+    {
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+        $driver = $this->getFFProbeDriverMock();
+
+        $ffprobe->setFFProbeDriver($driver);
+        $this->assertSame($driver, $ffprobe->getFFProbeDriver());
+    }
+
+    public function testGetSetFFProbeMapper()
+    {
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+        $mapper = $this->getFFProbeMapperMock();
+
+        $ffprobe->setMapper($mapper);
+        $this->assertSame($mapper, $ffprobe->getMapper());
+    }
+
+    public function testGetSetOptionsTester()
+    {
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+        $tester = $this->getFFProbeOptionsTesterMock();
+
+        $ffprobe->setOptionsTester($tester);
+        $this->assertSame($tester, $ffprobe->getOptionsTester());
+    }
+
+    public function testGetSetCache()
+    {
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+        $cache = $this->getCacheMock();
+
+        $ffprobe->setCache($cache);
+        $this->assertSame($cache, $ffprobe->getCache());
+    }
+
+    public function provideDataWhitoutCache()
+    {
+        $stream = $this->getStreamMock();
+        $format = $this->getFormatMock();
+
+        return array(
+            array($stream, 'streams', array('-show_streams', '-print_format'), FFProbe::TYPE_STREAMS, array(__FILE__, '-show_streams', '-print_format', 'json'), false),
+            array($format, 'format', array('-show_format', '-print_format'), FFProbe::TYPE_FORMAT, array(__FILE__, '-show_format', '-print_format', 'json'), false),
+            array($stream, 'streams', array('-show_streams'), FFProbe::TYPE_STREAMS, array(__FILE__, '-show_streams'), true),
+            array($format, 'format', array('-show_format'), FFProbe::TYPE_FORMAT, array(__FILE__, '-show_format'), true),
+        );
+    }
+
+    /**
+     * @dataProvider provideDataWhitoutCache
+     */
+    public function testProbeWithoutCache($output, $method, $commands, $type, $caughtCommands, $isRaw)
+    {
+        $pathfile = __FILE__;
+        $data = array('key' => 'value');
+        $rawData = 'raw data';
+
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+
+        $mapper = $this->getFFProbeMapperMock();
+        $mapper->expects($this->once())
+            ->method('map')
+            ->with($type, $data)
+            ->will($this->returnValue($output));
+
+        $parser = $this->getFFProbeParserMock();
+
+        if ($isRaw) {
+            $parser->expects($this->once())
+                ->method('parse')
+                ->with($type, $rawData)
+                ->will($this->returnValue($data));
+        } else {
+            $parser->expects($this->never())
+                ->method('parse');
+        }
+
+        $tester = $this->getFFProbeOptionsTesterMockWithOptions($commands);
+
+        $cache = $this->getCacheMock();
+        $cache->expects($this->once())
+            ->method('contains')
+            ->will($this->returnValue(false));
+        $cache->expects($this->never())
+            ->method('fetch');
+        $cache->expects($this->once())
+            ->method('save')
+            ->with($this->anything(), $output);
+
+        $driver = $this->getFFProbeDriverMock();
+        $driver->expects($this->once())
+            ->method('command')
+            ->with($caughtCommands)
+            ->will($this->returnValue($isRaw ? $rawData : json_encode($data)));
+
+        $ffprobe->setOptionsTester($tester)
+            ->setCache($cache)
+            ->setMapper($mapper)
+            ->setFFProbeDriver($driver)
+            ->setParser($parser);
+
+        $this->assertEquals($output, call_user_func(array($ffprobe, $method), $pathfile));
+    }
+
+    public function provideDataForInvalidJson()
+    {
+        $stream = $this->getStreamMock();
+        $format = $this->getFormatMock();
+
+        return array(
+            array($stream, 'streams', array('-show_streams', '-print_format'), FFProbe::TYPE_STREAMS, array(__FILE__, '-show_streams', '-print_format', 'json')),
+            array($format, 'format', array('-show_format', '-print_format'), FFProbe::TYPE_FORMAT, array(__FILE__, '-show_format', '-print_format', 'json')),
+        );
+    }
+
+    /**
+     * @dataProvider provideDataForInvalidJson
+     */
+    public function testProbeWithWrongJson($output, $method, $commands, $type, $caughtCommands)
+    {
+        $pathfile = __FILE__;
+        $data = array('key' => 'value');
+
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+
+        $mapper = $this->getFFProbeMapperMock();
+        $mapper->expects($this->once())
+            ->method('map')
+            ->with($this->isType('string'), 'good data parsed')
+            ->will($this->returnValue($output));
+
+        $parser = $this->getFFProbeParserMock();
+        $parser->expects($this->once())
+            ->method('parse')
+            ->with($this->isType('string', json_encode($data) . 'lala'))
+            ->will($this->returnValue('good data parsed'));
+
+        $tester = $this->getFFProbeOptionsTesterMockWithOptions($commands);
+
+        $cache = $this->getCacheMock();
+        $cache->expects($this->exactly(2))
+            ->method('contains')
+            ->will($this->returnValue(false));
+        $cache->expects($this->never())
+            ->method('fetch');
+
+        $driver = $this->getFFProbeDriverMock();
+        $driver->expects($this->exactly(2))
+            ->method('command')
+            ->will($this->returnValue(json_encode($data) . 'lala'));
+
+        $ffprobe->setOptionsTester($tester)
+            ->setCache($cache)
+            ->setMapper($mapper)
+            ->setFFProbeDriver($driver)
+            ->setParser($parser);
+
+        $this->assertEquals($output, call_user_func(array($ffprobe, $method), $pathfile));
+    }
+
+    public function provideProbingDataWithCache()
+    {
+        $stream = $this->getStreamMock();
+        $format = $this->getFormatMock();
+
+        return array(
+            array($stream, 'streams'),
+            array($format, 'format'),
+        );
+    }
+
+    /**
+     * @dataProvider provideProbingDataWithCache
+     */
+    public function testProbeWithCache($output, $method)
+    {
+        $pathfile = __FILE__;
+
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+
+        $mapper = $this->getFFProbeMapperMock();
+        $mapper->expects($this->never())
+            ->method('map');
+
+        $tester = $this->getFFProbeOptionsTesterMock();
+
+        $cache = $this->getCacheMock();
+        $cache->expects($this->once())
+            ->method('contains')
+            ->will($this->returnValue(true));
+        $cache->expects($this->once())
+            ->method('fetch')
+            ->will($this->returnValue($output));
+        $cache->expects($this->never())
+            ->method('save');
+
+        $driver = $this->getFFProbeDriverMock();
+        $driver->expects($this->never())
+            ->method('command');
+
+        $ffprobe->setOptionsTester($tester)
+            ->setCache($cache)
+            ->setMapper($mapper)
+            ->setFFProbeDriver($driver);
+
+        $this->assertEquals($output, call_user_func(array($ffprobe, $method), $pathfile));
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     * @dataProvider provideProbeMethod
+     */
+    public function testProbeWithInvalidFile($method)
+    {
+        $pathfile = '/path/to/nofile';
+
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+        call_user_func(array($ffprobe, $method), $pathfile);
+    }
+
+    public function provideProbeMethod()
+    {
+        return array(
+            array('streams'),
+            array('format'),
+        );
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\RuntimeException
+     * @dataProvider provideProbeMethod
+     */
+    public function testProbeWithoutShowStreamsAvailable($method)
+    {
+        $pathfile = __FILE__;
+
+        $ffprobe = new FFProbe($this->getFFProbeDriverMock(), $this->getCacheMock());
+        $ffprobe->setOptionsTester($this->getFFProbeOptionsTesterMock());
+        call_user_func(array($ffprobe, $method), $pathfile);
+    }
+
+    /**
+     * @dataProvider provideCreateOptions
+     */
+    public function testCreate($logger, $conf, $cache)
+    {
+        $finder = new ExecutableFinder();
+
+        $found = false;
+        foreach (array('avprobe', 'ffprobe') as $name) {
+            if (null !== $finder->find($name)) {
+                $found = true;
+            }
+        }
+
+        if (!$found) {
+            $this->markTestSkipped("Unable to find avprobe or ffprobe on system");
+        }
+
+        $ffprobe = FFProbe::create();
+        $this->assertInstanceOf('FFMpeg\FFprobe', $ffprobe);
+
+        $ffprobe = FFProbe::create($conf, $logger, $cache);
+        $this->assertInstanceOf('FFMpeg\FFprobe', $ffprobe);
+
+        if (null !== $cache) {
+            $this->assertSame($cache, $ffprobe->getCache());
+        }
+        if (null !== $logger) {
+            $this->assertSame($logger, $ffprobe->getFFProbeDriver()->getProcessRunner()->getLogger());
+        }
+        if ($conf instanceof ConfigurationInterface) {
+            $this->assertSame($conf, $ffprobe->getFFProbeDriver()->getConfiguration());
+        }
+    }
+
+    public function provideCreateOptions()
+    {
+        return array(
+            array(null, array('key' => 'value'), null),
+            array($this->getLoggerMock(), array('key' => 'value'), null),
+            array(null, new Configuration(), null),
+            array(null, array('key' => 'value'), $this->getCacheMock()),
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/Filters/Audio/AudioFiltersTest.php
+++ b/tests/FFMpeg/Tests/Filters/Audio/AudioFiltersTest.php
@ -0,0 +1,26 @@
+<?php
+
+namespace FFMpeg\Tests\Filters\Audio;
+
+use FFMpeg\Filters\Audio\AudioFilters;
+use FFMpeg\Tests\TestCase;
+
+class AudioFiltersTest extends TestCase
+{
+    public function testResample()
+    {
+        $capturedFilter = null;
+
+        $audio = $this->getAudioMock();
+        $audio->expects($this->once())
+            ->method('addFilter')
+            ->with($this->isInstanceOf('FFMpeg\Filters\Audio\AudioResamplableFilter'))
+            ->will($this->returnCallback(function ($filter) use (&$capturedFilter) {
+                $capturedFilter = $filter;
+            }));
+
+        $filters = new AudioFilters($audio);
+        $filters->resample(8000);
+        $this->assertEquals(8000, $capturedFilter->getRate());
+    }
+}
--- a/tests/FFMpeg/Tests/Filters/Audio/AudioResamplableFilterTest.php
+++ b/tests/FFMpeg/Tests/Filters/Audio/AudioResamplableFilterTest.php
@ -0,0 +1,24 @@
+<?php
+
+namespace FFMpeg\Tests\Filters\Audio;
+
+use FFMpeg\Filters\Audio\AudioResamplableFilter;
+use FFMpeg\Tests\TestCase;
+
+class AudioResamplableFilterTest extends TestCase
+{
+    public function testGetRate()
+    {
+        $filter = new AudioResamplableFilter(500);
+        $this->assertEquals(500, $filter->getRate());
+    }
+
+    public function testApply()
+    {
+        $audio = $this->getAudioMock();
+        $format = $this->getMock('FFMpeg\Format\AudioInterface');
+
+        $filter = new AudioResamplableFilter(500);
+        $this->assertEquals(array('-ac', 2, '-ar', 500), $filter->apply($audio, $format));
+    }
+}
--- a/tests/FFMpeg/Tests/Filters/FiltersCollectionTest.php
+++ b/tests/FFMpeg/Tests/Filters/FiltersCollectionTest.php
@ -0,0 +1,30 @@
+<?php
+
+namespace FFMpeg\Tests\Filters;
+
+use FFMpeg\Filters\FiltersCollection;
+
+class FiltersCollectionTest extends \PHPUnit_Framework_TestCase
+{
+    public function testCount()
+    {
+        $coll = new FiltersCollection();
+        $this->assertCount(0, $coll);
+
+        $coll->add($this->getMock('FFMpeg\Filters\FilterInterface'));
+        $this->assertCount(1, $coll);
+
+        $coll->add($this->getMock('FFMpeg\Filters\FilterInterface'));
+        $this->assertCount(2, $coll);
+    }
+
+    public function testIterator()
+    {
+        $coll = new FiltersCollection();
+        $coll->add($this->getMock('FFMpeg\Filters\FilterInterface'));
+        $coll->add($this->getMock('FFMpeg\Filters\FilterInterface'));
+
+        $this->assertInstanceOf('\ArrayIterator', $coll->getIterator());
+        $this->assertCount(2, $coll->getIterator());
+    }
+}
--- a/tests/FFMpeg/Tests/Filters/Video/ResizeFilterTest.php
+++ b/tests/FFMpeg/Tests/Filters/Video/ResizeFilterTest.php
@ -0,0 +1,75 @@
+<?php
+
+namespace FFMpeg\Tests\Filters\Video;
+
+use FFMpeg\Filters\Video\ResizeFilter;
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\DataMapping\Stream;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+use FFMpeg\Coordinate\Dimension;
+
+class ResizeFilterTest extends TestCase
+{
+    /**
+     * @dataProvider provideDimensions
+     */
+    public function testApply(Dimension $dimension, $mode, $width, $height, $modulus, $expected, $forceStandards = true)
+    {
+        $video = $this->getVideoMock();
+        $pathfile = '/path/to/file'.mt_rand();
+
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+        $format->expects($this->any())
+            ->method('getModulus')
+            ->will($this->returnValue($modulus));
+
+        $streams = new StreamCollection(array(
+            new Stream(array(
+                'codec_type' => 'video',
+                'width'      => $width,
+                'height'     => $height,
+            ))
+        ));
+
+        $video->expects($this->once())
+            ->method('getStreams')
+            ->will($this->returnValue($streams));
+
+        $filter = new ResizeFilter($dimension, $mode, $forceStandards);
+        $this->assertEquals($expected, $filter->apply($video, $format));
+    }
+
+    public function provideDimensions()
+    {
+        return array(
+            array(new Dimension(320, 240), ResizeFilter::RESIZEMODE_FIT, 640, 480, 2, array('-s', '320x240')),
+            array(new Dimension(320, 240), ResizeFilter::RESIZEMODE_INSET, 640, 480, 2, array('-s', '320x240')),
+            array(new Dimension(320, 240), ResizeFilter::RESIZEMODE_SCALE_HEIGHT, 640, 480, 2, array('-s', '320x240')),
+            array(new Dimension(320, 240), ResizeFilter::RESIZEMODE_SCALE_WIDTH, 640, 480, 2, array('-s', '320x240')),
+
+            array(new Dimension(640, 480), ResizeFilter::RESIZEMODE_FIT, 320, 240, 2, array('-s', '640x480')),
+            array(new Dimension(640, 480), ResizeFilter::RESIZEMODE_INSET, 320, 240, 2, array('-s', '640x480')),
+            array(new Dimension(640, 480), ResizeFilter::RESIZEMODE_SCALE_HEIGHT, 320, 240, 2, array('-s', '640x480')),
+            array(new Dimension(640, 480), ResizeFilter::RESIZEMODE_SCALE_WIDTH, 320, 240, 2, array('-s', '640x480')),
+
+            array(new Dimension(640, 360), ResizeFilter::RESIZEMODE_FIT, 1280, 720, 2, array('-s', '640x360')),
+            array(new Dimension(640, 360), ResizeFilter::RESIZEMODE_INSET, 1280, 720, 2, array('-s', '640x360')),
+            array(new Dimension(640, 360), ResizeFilter::RESIZEMODE_SCALE_HEIGHT, 1280, 720, 2, array('-s', '640x360')),
+            array(new Dimension(640, 360), ResizeFilter::RESIZEMODE_SCALE_WIDTH, 1280, 720, 2, array('-s', '640x360')),
+
+            array(new Dimension(640, 360), ResizeFilter::RESIZEMODE_FIT, 1280, 720, 2, array('-s', '640x360')),
+            array(new Dimension(640, 360), ResizeFilter::RESIZEMODE_INSET, 1280, 720, 2, array('-s', '640x360')),
+            array(new Dimension(640, 360), ResizeFilter::RESIZEMODE_SCALE_HEIGHT, 1280, 720, 2, array('-s', '640x360')),
+            array(new Dimension(640, 360), ResizeFilter::RESIZEMODE_SCALE_WIDTH, 1280, 720, 2, array('-s', '640x360')),
+
+            // test non standard dimension
+            array(new Dimension(700, 150), ResizeFilter::RESIZEMODE_INSET, 123, 456, 2, array('-s', '62x150'), true),
+            array(new Dimension(700, 150), ResizeFilter::RESIZEMODE_INSET, 123, 456, 2, array('-s', '40x150'), false),
+
+            array(new Dimension(320, 320), ResizeFilter::RESIZEMODE_FIT, 640, 480, 2, array('-s', '320x320')),
+            array(new Dimension(320, 320), ResizeFilter::RESIZEMODE_INSET, 640, 480, 2, array('-s', '320x240')),
+            array(new Dimension(320, 320), ResizeFilter::RESIZEMODE_SCALE_HEIGHT, 640, 480, 2, array('-s', '320x240')),
+            array(new Dimension(320, 320), ResizeFilter::RESIZEMODE_SCALE_WIDTH, 640, 480, 2, array('-s', '426x320')),
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/Filters/Video/SynchronizeFilterTest.php
+++ b/tests/FFMpeg/Tests/Filters/Video/SynchronizeFilterTest.php
@ -0,0 +1,58 @@
+<?php
+
+namespace FFMpeg\Tests\Filters\Video;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+use FFMpeg\FFProbe\DataMapping\Stream;
+use FFMpeg\Filters\Video\SynchronizeFilter;
+
+class SynchronizeFilterTest extends TestCase
+{
+    /**
+     * @dataProvider provideStreams
+     */
+    public function testApply($streams, $expected)
+    {
+        $video = $this->getVideoMock();
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+        $video->expects($this->once())
+            ->method('getStreams')
+            ->will($this->returnValue($streams));
+        $video->expects($this->any())
+            ->method('getPathfile')
+            ->will($this->returnValue(__FILE__));
+
+        $filter = new SynchronizeFilter();
+        $this->assertEquals($expected, $filter->apply($video, $format));
+    }
+
+    public function provideStreams()
+    {
+        $audio = new StreamCollection(array(new Stream(array(
+            'index' => 0,
+            'codec_type' => 'audio',
+        ))));
+        $synced = new StreamCollection(array(new Stream(array(
+            'index' => 0,
+            'codec_type' => 'video',
+        )), new Stream(array(
+            'index' => 1,
+            'codec_type' => 'audio',
+        ))));
+        $video = new StreamCollection(array(new Stream(array(
+            'index' => 0,
+            'codec_type' => 'video',
+            'start_time' => '0.123456',
+        )), new Stream(array(
+            'index' => 1,
+            'codec_type' => 'audio',
+        ))));
+
+        return array(
+            array($audio, array()),
+            array($synced, array()),
+            array($video, array('-itsoffset', '0.123456', '-i', __FILE__, '-map', '1:0', '-map', '0:1')),
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/Filters/Video/VideoFiltersTest.php
+++ b/tests/FFMpeg/Tests/Filters/Video/VideoFiltersTest.php
@ -0,0 +1,79 @@
+<?php
+
+namespace FFMpeg\Tests\Filters\Video;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Filters\Video\VideoFilters;
+use FFMpeg\Filters\Video\ResizeFilter;
+
+class VideoFiltersTest extends TestCase
+{
+    /**
+     * @dataProvider provideResizeOptions
+     */
+    public function testResize($mode, $forceStandards)
+    {
+        $capturedFilter = null;
+
+        $video = $this->getVideoMock();
+        $filters = new VideoFilters($video);
+        $dimension = $this->getDimensionMock();
+
+        $video->expects($this->once())
+            ->method('addFilter')
+            ->with($this->isInstanceOf('FFMpeg\Filters\Video\ResizeFilter'))
+            ->will($this->returnCallback(function ($filter) use (&$capturedFilter) {
+                $capturedFilter = $filter;
+            }));
+
+        $filters->resize($dimension, $mode, $forceStandards);
+
+        $this->assertSame($mode, $capturedFilter->getMode());
+        $this->assertSame($forceStandards, $capturedFilter->areStandardsForced());
+        $this->assertSame($dimension, $capturedFilter->getDimension());
+    }
+
+    public function provideResizeOptions()
+    {
+        return array(
+            array(ResizeFilter::RESIZEMODE_FIT, true),
+            array(ResizeFilter::RESIZEMODE_SCALE_WIDTH, true),
+            array(ResizeFilter::RESIZEMODE_SCALE_HEIGHT, false),
+            array(ResizeFilter::RESIZEMODE_INSET, false),
+        );
+    }
+
+    public function testResample()
+    {
+        $capturedFilter = null;
+
+        $video = $this->getVideoMock();
+        $filters = new VideoFilters($video);
+        $framerate = $this->getFramerateMock();
+        $gop = 42;
+
+        $video->expects($this->once())
+            ->method('addFilter')
+            ->with($this->isInstanceOf('FFMpeg\Filters\Video\VideoResampleFilter'))
+            ->will($this->returnCallback(function ($filter) use (&$capturedFilter) {
+                $capturedFilter = $filter;
+            }));
+
+        $filters->resample($framerate, $gop);
+
+        $this->assertSame($framerate, $capturedFilter->getFramerate());
+        $this->assertSame($gop, $capturedFilter->getGOP());
+    }
+
+    public function testSynchronize()
+    {
+        $video = $this->getVideoMock();
+        $filters = new VideoFilters($video);
+
+        $video->expects($this->once())
+            ->method('addFilter')
+            ->with($this->isInstanceOf('FFMpeg\Filters\Video\SynchronizeFilter'));
+
+        $filters->synchronize();
+    }
+}
--- a/tests/FFMpeg/Tests/Filters/Video/VideoResampleFilterTest.php
+++ b/tests/FFMpeg/Tests/Filters/Video/VideoResampleFilterTest.php
@ -0,0 +1,44 @@
+<?php
+
+namespace FFMpeg\Tests\Filters\Video;
+
+use FFMpeg\Filters\Video\VideoResampleFilter;
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Coordinate\FrameRate;
+
+class VideoResampleFilterTest extends TestCase
+{
+    public function testApplyWithAFormatThatSupportsBFrames()
+    {
+        $framerate = new FrameRate(54);
+        $gop = 42;
+
+        $video = $this->getVideoMock();
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+        $format->expects($this->any())
+            ->method('supportBFrames')
+            ->will($this->returnValue(true));
+
+        $expected = array('-r', 54, '-b_strategy', '1', '-bf', '3', '-g', 42);
+
+        $filter = new VideoResampleFilter($framerate, $gop);
+        $this->assertEquals($expected, $filter->apply($video, $format));
+    }
+
+    public function testApplyWithAFormatThatDoesNotSupportsBFrames()
+    {
+        $framerate = new FrameRate(54);
+        $gop = 42;
+
+        $video = $this->getVideoMock();
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+        $format->expects($this->any())
+            ->method('supportBFrames')
+            ->will($this->returnValue(false));
+
+        $expected = array('-r', 54);
+
+        $filter = new VideoResampleFilter($framerate, $gop);
+        $this->assertEquals($expected, $filter->apply($video, $format));
+    }
+}
--- a/tests/FFMpeg/Tests/Format/Audio/AudioTestCase.php
+++ b/tests/FFMpeg/Tests/Format/Audio/AudioTestCase.php
@ -0,0 +1,96 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Audio;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Format\Audio\DefaultAudio;
+
+abstract class AudioTestCase extends TestCase
+{
+    public function testExtraParams()
+    {
+        foreach ($this->getFormat()->getExtraParams() as $param) {
+            $this->assertScalar($param);
+        }
+    }
+
+    public function testGetAudioCodec()
+    {
+        $this->assertScalar($this->getFormat()->getAudioCodec());
+        $this->assertContains($this->getFormat()->getAudioCodec(), $this->getFormat()->getAvailableAudioCodecs());
+    }
+
+    public function testSetAudioCodec()
+    {
+        $format = $this->getFormat();
+
+        foreach ($format->getAvailableAudioCodecs() as $codec) {
+            $format->setAudioCodec($codec);
+            $this->assertEquals($codec, $format->getAudioCodec());
+        }
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testSetInvalidAudioCodec()
+    {
+        $this->getFormat()->setAudioCodec('invalid-random-audio-codec');
+    }
+
+    public function testGetAvailableAudioCodecs()
+    {
+        $this->assertGreaterThan(0, count($this->getFormat()->getAvailableAudioCodecs()));
+    }
+
+    public function testGetAudioKiloBitrate()
+    {
+        $this->assertInternalType('integer', $this->getFormat()->getAudioKiloBitrate());
+    }
+
+    public function testSetAudioKiloBitrate()
+    {
+        $format = $this->getFormat();
+        $format->setAudioKiloBitrate(256);
+        $this->assertEquals(256, $format->getAudioKiloBitrate());
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testSetInvalidKiloBitrate()
+    {
+        $this->getFormat()->setAudioKiloBitrate(0);
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testSetNegativeKiloBitrate()
+    {
+        $this->getFormat()->setAudioKiloBitrate(-10);
+    }
+
+    public function testCreateProgressListener()
+    {
+        $media = $this->getMock('FFMpeg\Media\MediaTypeInterface');
+        $media->expects($this->any())
+            ->method('getPathfile')
+            ->will($this->returnValue(__FILE__));
+        $format = $this->getFormat();
+        $ffprobe = $this->getFFProbeMock();
+
+        foreach ($format->createProgressListener($media, $ffprobe, 1, 3) as $listener) {
+            $this->assertInstanceOf('FFMpeg\Format\ProgressListener\AudioProgressListener', $listener);
+            $this->assertSame($ffprobe, $listener->getFFProbe());
+            $this->assertSame(__FILE__, $listener->getPathfile());
+            $this->assertSame(1, $listener->getCurrentPass());
+            $this->assertSame(3, $listener->getTotalPass());
+        }
+    }
+
+    /**
+     * @return DefaultAudio
+     */
+    abstract public function getFormat();
+}
--- a/tests/FFMpeg/Tests/Format/Audio/FlacTest.php
+++ b/tests/FFMpeg/Tests/Format/Audio/FlacTest.php
@ -0,0 +1,13 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Audio;
+
+use FFMpeg\Format\Audio\Flac;
+
+class FlacTest extends AudioTestCase
+{
+    public function getFormat()
+    {
+        return new Flac();
+    }
+}
--- a/tests/FFMpeg/Tests/Format/Audio/Mp3Test.php
+++ b/tests/FFMpeg/Tests/Format/Audio/Mp3Test.php
@ -0,0 +1,13 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Audio;
+
+use FFMpeg\Format\Audio\Mp3;
+
+class Mp3Test extends AudioTestCase
+{
+    public function getFormat()
+    {
+        return new Mp3();
+    }
+}
--- a/tests/FFMpeg/Tests/Format/ProgressListener/AudioProgressListenerTest.php
+++ b/tests/FFMpeg/Tests/Format/ProgressListener/AudioProgressListenerTest.php
@ -0,0 +1,87 @@
+<?php
+
+namespace FFMpeg\Tests\Format\ProgressListener;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Format\ProgressListener\AudioProgressListener;
+use FFMpeg\FFProbe\DataMapping\Format;
+
+class AudioProgressListenerTest extends TestCase
+{
+    /**
+     * @dataProvider provideData
+     */
+    public function testHandle($size, $duration,
+        $data, $expectedPercent, $expectedRemaining, $expectedRate,
+        $data2, $expectedPercent2, $expectedRemaining2, $expectedRate2,
+        $currentPass, $totalPass
+    )
+    {
+        $ffprobe = $this->getFFProbeMock();
+        $ffprobe->expects($this->once())
+            ->method('format')
+            ->with(__FILE__)
+            ->will($this->returnValue(new Format(array(
+                'size'     => $size,
+                'duration' => $duration,
+            ))));
+
+        $listener = new AudioProgressListener($ffprobe, __FILE__, $currentPass, $totalPass);
+        $phpunit = $this;
+        $n = 0;
+        $listener->on('progress', function ($percent, $remaining, $rate) use (&$n, $phpunit, $expectedPercent, $expectedRemaining, $expectedRate, $expectedPercent2, $expectedRemaining2, $expectedRate2) {
+            if (0 === $n) {
+                $phpunit->assertEquals($expectedPercent, $percent);
+                $phpunit->assertEquals($expectedRemaining, $remaining);
+                $phpunit->assertEquals($expectedRate, $rate);
+            } elseif (1 === $n) {
+                $phpunit->assertEquals($expectedPercent2, $percent);
+                $phpunit->assertEquals($expectedRemaining2, $remaining);
+                $phpunit->assertLessThan($expectedRate2 + 3, $rate);
+                $phpunit->assertGreaterThan($expectedRate2 - 3, $rate);
+            }
+            $n++;
+        });
+        // first one does not trigger progress event
+        $listener->handle('any-type'.mt_rand(), $data);
+        sleep(1);
+        $listener->handle('any-type'.mt_rand(), $data);
+        sleep(1);
+        $listener->handle('any-type'.mt_rand(), $data2);
+        $this->assertEquals(2, $n);
+    }
+
+    public function provideData()
+    {
+        return array(
+            array(
+                2894412,
+                180.900750,
+                'size=     712kB time=00:00:45.50 bitrate= 128.1kbits/s',
+                25,
+                0,
+                0,
+                'size=     1274kB time=00:01:29.32 bitrate= 142.8kbits/s',
+                49,
+                2,
+                563,
+                1,
+                1
+            ),
+            array(
+                2894412,
+                180.900750,
+                'size=     712kB time=00:00:45.50 bitrate= 128.1kbits/s',
+                12,
+                0,
+                0,
+                'size=     1274kB time=00:01:29.32 bitrate= 142.8kbits/s',
+                24,
+                2,
+                563,
+                1,
+                2
+            )
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/Format/ProgressListener/VideoProgressListenerTest.php
+++ b/tests/FFMpeg/Tests/Format/ProgressListener/VideoProgressListenerTest.php
@ -0,0 +1,87 @@
+<?php
+
+namespace FFMpeg\Tests\Format\ProgressListener;
+
+use FFMpeg\Tests\TestCase;
+use FFMpeg\Format\ProgressListener\VideoProgressListener;
+use FFMpeg\FFProbe\DataMapping\Format;
+
+class VideoProgressListenerTest extends TestCase
+{
+    /**
+     * @dataProvider provideData
+     */
+    public function testHandle($size, $duration,
+        $data, $expectedPercent, $expectedRemaining, $expectedRate,
+        $data2, $expectedPercent2, $expectedRemaining2, $expectedRate2,
+        $currentPass, $totalPass
+    )
+    {
+        $ffprobe = $this->getFFProbeMock();
+        $ffprobe->expects($this->once())
+            ->method('format')
+            ->with(__FILE__)
+            ->will($this->returnValue(new Format(array(
+                'size'     => $size,
+                'duration' => $duration,
+            ))));
+
+        $listener = new VideoProgressListener($ffprobe, __FILE__, $currentPass, $totalPass);
+        $phpunit = $this;
+        $n = 0;
+        $listener->on('progress', function ($percent, $remaining, $rate) use (&$n, $phpunit, $expectedPercent, $expectedRemaining, $expectedRate, $expectedPercent2, $expectedRemaining2, $expectedRate2) {
+            if (0 === $n) {
+                $phpunit->assertEquals($expectedPercent, $percent);
+                $phpunit->assertEquals($expectedRemaining, $remaining);
+                $phpunit->assertEquals($expectedRate, $rate);
+            } elseif (1 === $n) {
+                $phpunit->assertEquals($expectedPercent2, $percent);
+                $phpunit->assertEquals($expectedRemaining2, $remaining);
+                $phpunit->assertLessThan($expectedRate2 + 10, $rate);
+                $phpunit->assertGreaterThan($expectedRate2 - 10, $rate);
+            }
+            $n++;
+        });
+        // first one does not trigger progress event
+        $listener->handle('any-type'.mt_rand(), $data);
+        sleep(1);
+        $listener->handle('any-type'.mt_rand(), $data);
+        sleep(1);
+        $listener->handle('any-type'.mt_rand(), $data2);
+        $this->assertEquals(2, $n);
+    }
+
+    public function provideData()
+    {
+        return array(
+            array(
+                147073958,
+                281.147533,
+                'frame=  206 fps=202 q=10.0 size=     571kB time=00:00:07.12 bitrate= 656.8kbits/s dup=9 drop=0',
+                2,
+                0,
+                0,
+                'frame=  854 fps=113 q=20.0 size=    4430kB time=00:00:33.04 bitrate=1098.5kbits/s dup=36 drop=0',
+                11,
+                32,
+                3868,
+                1,
+                1
+            ),
+            array(
+                147073958,
+                281.147533,
+                'frame=  206 fps=202 q=10.0 size=     571kB time=00:00:07.12 bitrate= 656.8kbits/s dup=9 drop=0',
+                1,
+                0,
+                0,
+                'frame=  854 fps=113 q=20.0 size=    4430kB time=00:00:33.04 bitrate=1098.5kbits/s dup=36 drop=0',
+                5,
+                32,
+                3868,
+                1,
+                2
+            )
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/Format/Video/OggTest.php
+++ b/tests/FFMpeg/Tests/Format/Video/OggTest.php
@ -0,0 +1,13 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Video;
+
+use FFMpeg\Format\Video\Ogg;
+
+class OggTest extends VideoTestCase
+{
+    public function getFormat()
+    {
+        return new Ogg();
+    }
+}
--- a/tests/FFMpeg/Tests/Format/Video/VideoTestCase.php
+++ b/tests/FFMpeg/Tests/Format/Video/VideoTestCase.php
@ -0,0 +1,85 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Video;
+
+use FFMpeg\Tests\Format\Audio\AudioTestCase;
+
+abstract class VideoTestCase extends AudioTestCase
+{
+    public function testGetVideoCodec()
+    {
+        $this->assertScalar($this->getFormat()->getVideoCodec());
+        $this->assertContains($this->getFormat()->getVideoCodec(), $this->getFormat()->getAvailableVideoCodecs());
+    }
+
+    public function testSupportBFrames()
+    {
+        $this->assertInternalType('boolean', $this->getFormat()->supportBFrames());
+    }
+
+    public function testSetVideoCodec()
+    {
+        $format = $this->getFormat();
+
+        foreach ($format->getAvailableVideoCodecs() as $codec) {
+            $format->setVideoCodec($codec);
+            $this->assertEquals($codec, $format->getVideoCodec());
+        }
+    }
+
+    public function testGetKiloBitrate()
+    {
+        $this->assertInternalType('integer', $this->getFormat()->getKiloBitrate());
+    }
+
+    public function testSetKiloBitrate()
+    {
+        $format = $this->getFormat();
+        $format->setKiloBitrate(2560);
+        $this->assertEquals(2560, $format->getKiloBitrate());
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testSetInvalidVideoCodec()
+    {
+        $this->getFormat()->setVideoCodec('invalid-random-video-codec');
+    }
+
+    public function testGetAvailableVideoCodecs()
+    {
+        $this->assertGreaterThan(0, count($this->getFormat()->getAvailableVideoCodecs()));
+    }
+
+    public function testCreateProgressListener()
+    {
+        $media = $this->getMock('FFMpeg\Media\MediaTypeInterface');
+        $media->expects($this->any())
+            ->method('getPathfile')
+            ->will($this->returnValue(__FILE__));
+        $format = $this->getFormat();
+        $ffprobe = $this->getFFProbeMock();
+
+        foreach ($format->createProgressListener($media, $ffprobe, 1, 3) as $listener) {
+            $this->assertInstanceOf('FFMpeg\Format\ProgressListener\VideoProgressListener', $listener);
+            $this->assertSame($ffprobe, $listener->getFFProbe());
+            $this->assertSame(__FILE__, $listener->getPathfile());
+            $this->assertSame(1, $listener->getCurrentPass());
+            $this->assertSame(3, $listener->getTotalPass());
+        }
+    }
+
+    public function testGetPasses()
+    {
+        $this->assertInternalType('integer', $this->getFormat()->getPasses());
+        $this->assertGreaterThan(0, $this->getFormat()->getPasses());
+    }
+
+    public function testGetModulus()
+    {
+        $this->assertInternalType('integer', $this->getFormat()->getModulus());
+        $this->assertGreaterThan(0, $this->getFormat()->getModulus());
+        $this->assertEquals(0, $this->getFormat()->getModulus() % 2);
+    }
+}
--- a/tests/FFMpeg/Tests/Format/Video/WMV3Test.php
+++ b/tests/FFMpeg/Tests/Format/Video/WMV3Test.php
@ -0,0 +1,13 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Video;
+
+use FFMpeg\Format\Video\WMV3;
+
+class WMV3Test extends VideoTestCase
+{
+    public function getFormat()
+    {
+        return new WMV3();
+    }
+}
--- a/tests/FFMpeg/Tests/Format/Video/WMVTest.php
+++ b/tests/FFMpeg/Tests/Format/Video/WMVTest.php
@ -0,0 +1,13 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Video;
+
+use FFMpeg\Format\Video\WMV;
+
+class WMVTest extends VideoTestCase
+{
+    public function getFormat()
+    {
+        return new WMV();
+    }
+}
--- a/tests/FFMpeg/Tests/Format/Video/WebMTest.php
+++ b/tests/FFMpeg/Tests/Format/Video/WebMTest.php
@ -0,0 +1,13 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Video;
+
+use FFMpeg\Format\Video\WebM;
+
+class WebMTest extends VideoTestCase
+{
+    public function getFormat()
+    {
+        return new WebM();
+    }
+}
--- a/tests/FFMpeg/Tests/Format/Video/X264Test.php
+++ b/tests/FFMpeg/Tests/Format/Video/X264Test.php
@ -0,0 +1,13 @@
+<?php
+
+namespace FFMpeg\Tests\Format\Video;
+
+use FFMpeg\Format\Video\X264;
+
+class X264Test extends VideoTestCase
+{
+    public function getFormat()
+    {
+        return new X264();
+    }
+}
--- a/tests/FFMpeg/Tests/Media/AbstractMediaTestCase.php
+++ b/tests/FFMpeg/Tests/Media/AbstractMediaTestCase.php
@ -0,0 +1,10 @@
+<?php
+
+namespace FFMpeg\Tests\Media;
+
+use FFMpeg\Tests\TestCase;
+
+abstract class AbstractMediaTestCase extends TestCase
+{
+    abstract public function testWithInvalidFile();
+}
--- a/tests/FFMpeg/Tests/Media/AbstractStreamableTestCase.php
+++ b/tests/FFMpeg/Tests/Media/AbstractStreamableTestCase.php
@ -0,0 +1,38 @@
+<?php
+
+namespace FFMpeg\Tests\Media;
+
+abstract class AbstractStreamableTestCase extends AbstractMediaTestCase
+{
+    public function testGetStreams()
+    {
+        $classname = $this->getClassName();
+        $ffprobe = $this->getFFProbeMock();
+        $format = $this->getFormatMock();
+
+        $ffprobe->expects($this->once())
+            ->method('format')
+            ->with(__FILE__)
+            ->will($this->returnValue($format));
+
+        $media = new $classname(__FILE__, $this->getFFMpegDriverMock(), $ffprobe);
+        $this->assertSame($format, $media->getFormat());
+    }
+
+    public function testGetFormat()
+    {
+        $classname = $this->getClassName();
+        $ffprobe = $this->getFFProbeMock();
+        $streams = $this->getStreamCollectionMock();
+
+        $ffprobe->expects($this->once())
+            ->method('streams')
+            ->with(__FILE__)
+            ->will($this->returnValue($streams));
+
+        $media = new $classname(__FILE__, $this->getFFMpegDriverMock(), $ffprobe);
+        $this->assertSame($streams, $media->getStreams());
+    }
+
+    abstract protected function getClassName();
+}
--- a/tests/FFMpeg/Tests/Media/AudioTest.php
+++ b/tests/FFMpeg/Tests/Media/AudioTest.php
@ -0,0 +1,268 @@
+<?php
+
+namespace FFMpeg\Tests\Media;
+
+use FFMpeg\Media\Audio;
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+use FFMpeg\Format\ProgressableInterface;
+use FFMpeg\Format\AudioInterface;
+
+class AudioTest extends AbstractStreamableTestCase
+{
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testWithInvalidFile()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        new Audio('/no/file', $driver, $ffprobe);
+    }
+
+    public function testFiltersReturnsAudioFilters()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        $audio = new Audio(__FILE__, $driver, $ffprobe);
+        $this->assertInstanceOf('FFMpeg\Filters\Audio\AudioFilters', $audio->filters());
+    }
+
+    public function testAddFiltersAddsAFilter()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        $filters = $this->getMockBuilder('FFMpeg\Filters\FiltersCollection')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $audio = new Audio(__FILE__, $driver, $ffprobe);
+        $audio->setFiltersCollection($filters);
+
+        $filter = $this->getMock('FFMpeg\Filters\Audio\AudioFilterInterface');
+
+        $filters->expects($this->once())
+            ->method('add')
+            ->with($filter);
+
+        $audio->addFilter($filter);
+    }
+
+    public function testSaveWithFailure()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+        $outputPathfile = '/target/file';
+
+        $format = $this->getMock('FFMpeg\Format\AudioInterface');
+        $format->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+
+        $configuration = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+
+        $driver->expects($this->any())
+            ->method('getConfiguration')
+            ->will($this->returnValue($configuration));
+
+        $failure = new ExecutionFailureException('failed to encode');
+        $driver->expects($this->once())
+            ->method('command')
+            ->will($this->throwException($failure));
+
+        $audio = new Audio(__FILE__, $driver, $ffprobe);
+        $this->setExpectedException('FFMpeg\Exception\RuntimeException');
+        $audio->save($format, $outputPathfile);
+    }
+
+    public function testSaveAppliesFilters()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+        $outputPathfile = '/target/file';
+        $format = $this->getMock('FFMpeg\Format\AudioInterface');
+        $format->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+
+        $configuration = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+
+        $driver->expects($this->any())
+            ->method('getConfiguration')
+            ->will($this->returnValue($configuration));
+
+        $audio = new Audio(__FILE__, $driver, $ffprobe);
+
+        $filter = $this->getMock('FFMpeg\Filters\Audio\AudioFilterInterface');
+        $filter->expects($this->once())
+            ->method('apply')
+            ->with($audio, $format)
+            ->will($this->returnValue(array('extra-filter-command')));
+
+        $capturedCommands = array();
+
+        $driver->expects($this->once())
+            ->method('command')
+            ->with($this->isType('array'), false, $this->anything())
+            ->will($this->returnCallback(function ($commands, $errors, $listeners) use (&$capturedCommands) {
+                $capturedCommands[] = $commands;
+            }));
+
+        $audio->addFilter($filter);
+        $audio->save($format, $outputPathfile);
+
+        foreach ($capturedCommands as $commands) {
+            $this->assertEquals('-y', $commands[0]);
+            $this->assertEquals('-i', $commands[1]);
+            $this->assertEquals(__FILE__, $commands[2]);
+            $this->assertEquals('extra-filter-command', $commands[3]);
+        }
+    }
+
+    /**
+     * @dataProvider provideSaveData
+     */
+    public function testSaveShouldSave($threads, $expectedCommands, $expectedListeners, $format)
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        $configuration = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+
+        $driver->expects($this->any())
+            ->method('getConfiguration')
+            ->will($this->returnValue($configuration));
+
+        $configuration->expects($this->once())
+            ->method('has')
+            ->with($this->equalTo('ffmpeg.threads'))
+            ->will($this->returnValue($threads));
+
+        if ($threads) {
+            $configuration->expects($this->once())
+                ->method('get')
+                ->with($this->equalTo('ffmpeg.threads'))
+                ->will($this->returnValue(24));
+        } else {
+            $configuration->expects($this->never())
+                ->method('get');
+        }
+
+        $capturedCommand = $capturedListeners = null;
+
+        $driver->expects($this->once())
+            ->method('command')
+            ->with($this->isType('array'), false, $this->anything())
+            ->will($this->returnCallback(function ($commands, $errors, $listeners) use (&$capturedCommand, &$capturedListeners) {
+                $capturedCommand = $commands;
+                $capturedListeners = $listeners;
+            }));
+
+        $outputPathfile = '/target/file';
+
+        $audio = new Audio(__FILE__, $driver, $ffprobe);
+        $audio->save($format, $outputPathfile);
+
+        $this->assertEquals($expectedCommands, $capturedCommand);
+        $this->assertEquals($expectedListeners, $capturedListeners);
+    }
+
+    public function provideSaveData()
+    {
+        $format = $this->getMock('FFMpeg\Format\AudioInterface');
+        $format->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+        $format->expects($this->any())
+            ->method('getAudioKiloBitrate')
+            ->will($this->returnValue(663));
+
+        $audioFormat = $this->getMock('FFMpeg\Format\AudioInterface');
+        $audioFormat->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+        $audioFormat->expects($this->any())
+            ->method('getAudioKiloBitrate')
+            ->will($this->returnValue(664));
+        $audioFormat->expects($this->any())
+            ->method('getAudioCodec')
+            ->will($this->returnValue('patati-patata-audio'));
+
+        $formatExtra = $this->getMock('FFMpeg\Format\AudioInterface');
+        $formatExtra->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array('extra', 'param')));
+        $formatExtra->expects($this->any())
+            ->method('getAudioKiloBitrate')
+            ->will($this->returnValue(665));
+
+        $listeners = array($this->getMock('Alchemy\BinaryDriver\Listeners\ListenerInterface'));
+
+        $progressableFormat = $this->getMockBuilder('FFMpeg\Tests\Media\AudioProg')
+            ->disableOriginalConstructor()->getMock();
+        $progressableFormat->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+        $progressableFormat->expects($this->any())
+            ->method('createProgressListener')
+            ->will($this->returnValue($listeners));
+        $progressableFormat->expects($this->any())
+            ->method('getAudioKiloBitrate')
+            ->will($this->returnValue(666));
+
+        return array(
+            array(false, array(
+                    '-y', '-i', __FILE__,
+                    '-b:a', '663k',
+                    '/target/file',
+                ), null, $format),
+            array(false, array(
+                    '-y', '-i', __FILE__,
+                    '-acodec', 'patati-patata-audio',
+                    '-b:a', '664k',
+                    '/target/file',
+                ), null, $audioFormat),
+            array(false, array(
+                    '-y', '-i', __FILE__,
+                    'extra', 'param',
+                    '-b:a', '665k',
+                    '/target/file',
+                ), null, $formatExtra),
+            array(true, array(
+                    '-y', '-i', __FILE__,
+                    '-threads', 24,
+                    '-b:a', '663k',
+                    '/target/file',
+                ), null, $format),
+            array(true, array(
+                    '-y', '-i', __FILE__,
+                    'extra', 'param',
+                    '-threads', 24,
+                    '-b:a', '665k',
+                    '/target/file',
+                ), null, $formatExtra),
+            array(false, array(
+                    '-y', '-i', __FILE__,
+                    '-b:a', '666k',
+                    '/target/file',
+                ), $listeners, $progressableFormat),
+            array(true, array(
+                    '-y', '-i', __FILE__,
+                    '-threads', 24,
+                    '-b:a', '666k',
+                    '/target/file',
+                ), $listeners, $progressableFormat),
+        );
+    }
+
+    public function getClassName()
+    {
+        return 'FFMpeg\Media\Audio';
+    }
+}
+
+abstract class AudioProg implements ProgressableInterface, AudioInterface
+{
+}
--- a/tests/FFMpeg/Tests/Media/FrameTest.php
+++ b/tests/FFMpeg/Tests/Media/FrameTest.php
@ -0,0 +1,98 @@
+<?php
+
+namespace FFMpeg\Tests\Media;
+
+use FFMpeg\Media\Frame;
+
+class FrameTest extends AbstractMediaTestCase
+{
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testWithInvalidFile()
+    {
+        new Frame('/No/file', $this->getFFMpegDriverMock(), $this->getFFProbeMock(), $this->getTimeCodeMock());
+    }
+
+    public function testGetTimeCode()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+        $timecode = $this->getTimeCodeMock();
+
+        $frame = new Frame(__FILE__, $driver, $ffprobe, $timecode);
+        $this->assertSame($timecode, $frame->getTimeCode());
+    }
+
+    public function testFiltersReturnFilters()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+        $timecode = $this->getTimeCodeMock();
+
+        $frame = new Frame(__FILE__, $driver, $ffprobe, $timecode);
+        $this->assertInstanceOf('FFMpeg\Filters\Frame\FrameFilters', $frame->filters());
+    }
+
+    public function testAddFiltersAddsAFilter()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+        $timecode = $this->getTimeCodeMock();
+
+        $filters = $this->getMockBuilder('FFMpeg\Filters\FiltersCollection')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $filter = $this->getMock('FFMpeg\Filters\Frame\FrameFilterInterface');
+
+        $filters->expects($this->once())
+            ->method('add')
+            ->with($filter);
+
+        $frame = new Frame(__FILE__, $driver, $ffprobe, $timecode);
+        $frame->setFiltersCollection($filters);
+        $frame->addFilter($filter);
+    }
+
+    /**
+     * @dataProvider provideSaveAsOptions
+     */
+    public function testSaveAs($accurate, $commands)
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+        $timecode = $this->getTimeCodeMock();
+        $timecode->expects($this->once())
+            ->method('__toString')
+            ->will($this->returnValue('timecode'));
+
+        $pathfile = '/target/destination';
+
+        array_push($commands, $pathfile);
+
+        $driver->expects($this->once())
+            ->method('command')
+            ->with($commands);
+
+        $frame = new Frame(__FILE__, $driver, $ffprobe, $timecode);
+        $this->assertSame($frame, $frame->saveAs($pathfile, $accurate));
+    }
+
+    public function provideSaveAsOptions()
+    {
+        return array(
+            array(false, array(
+                '-ss', 'timecode',
+                '-i', __FILE__,
+                '-vframes', '1',
+                '-f', 'image2')
+            ),
+            array(true, array(
+                '-i', __FILE__,
+                '-vframes', '1', '-ss', 'timecode',
+                '-f', 'image2'
+            )),
+        );
+    }
+}
--- a/tests/FFMpeg/Tests/Media/VideoTest.php
+++ b/tests/FFMpeg/Tests/Media/VideoTest.php
@ -0,0 +1,394 @@
+<?php
+
+namespace FFMpeg\Tests\Media;
+
+use FFMpeg\Media\Video;
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+use FFMpeg\Format\ProgressableInterface;
+use FFMpeg\Format\VideoInterface;
+
+class VideoTest extends AbstractStreamableTestCase
+{
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testWithInvalidFile()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        new Video('/no/file', $driver, $ffprobe);
+    }
+
+    public function testFiltersReturnsVideoFilters()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        $video = new Video(__FILE__, $driver, $ffprobe);
+        $this->assertInstanceOf('FFMpeg\Filters\Video\VideoFilters', $video->filters());
+    }
+
+    public function testAddFiltersAddsAFilter()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        $filters = $this->getMockBuilder('FFMpeg\Filters\FiltersCollection')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $video = new Video(__FILE__, $driver, $ffprobe);
+        $video->setFiltersCollection($filters);
+
+        $filter = $this->getMock('FFMpeg\Filters\Video\VideoFilterInterface');
+
+        $filters->expects($this->once())
+            ->method('add')
+            ->with($filter);
+
+        $video->addFilter($filter);
+    }
+
+    public function testFrameShouldReturnAFrame()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        $at = $this->getTimeCodeMock();
+
+        $video = new Video(__FILE__, $driver, $ffprobe);
+        $frame = $video->frame($at);
+
+        $this->assertInstanceOf('FFMpeg\Media\Frame', $frame);
+        $this->assertSame($at, $frame->getTimeCode());
+        $this->assertSame(__FILE__, $frame->getPathfile());
+    }
+
+    public function testSaveWithFailure()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+        $outputPathfile = '/target/file';
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+        $format->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+
+        $configuration = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+
+        $driver->expects($this->any())
+            ->method('getConfiguration')
+            ->will($this->returnValue($configuration));
+
+        $failure = new ExecutionFailureException('failed to encode');
+        $driver->expects($this->once())
+            ->method('command')
+            ->will($this->throwException($failure));
+
+        $video = new Video(__FILE__, $driver, $ffprobe);
+        $this->setExpectedException('FFMpeg\Exception\RuntimeException');
+        $video->save($format, $outputPathfile);
+    }
+
+    public function testSaveAppliesFilters()
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+        $outputPathfile = '/target/file';
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+        $format->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+
+        $configuration = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+
+        $driver->expects($this->any())
+            ->method('getConfiguration')
+            ->will($this->returnValue($configuration));
+
+        $video = new Video(__FILE__, $driver, $ffprobe);
+
+        $filter = $this->getMock('FFMpeg\Filters\Video\VideoFilterInterface');
+        $filter->expects($this->once())
+            ->method('apply')
+            ->with($video, $format)
+            ->will($this->returnValue(array('extra-filter-command')));
+
+        $capturedCommands = array();
+
+        $driver->expects($this->exactly(2))
+            ->method('command')
+            ->with($this->isType('array'), false, $this->anything())
+            ->will($this->returnCallback(function ($commands, $errors, $listeners) use (&$capturedCommands) {
+                $capturedCommands[] = $commands;
+            }));
+
+        $video->addFilter($filter);
+        $video->save($format, $outputPathfile);
+
+        foreach ($capturedCommands as $commands) {
+            $this->assertEquals('-y', $commands[0]);
+            $this->assertEquals('-i', $commands[1]);
+            $this->assertEquals(__FILE__, $commands[2]);
+            $this->assertEquals('extra-filter-command', $commands[3]);
+        }
+    }
+
+    /**
+     * @dataProvider provideSaveData
+     */
+    public function testSaveShouldSave($threads, $expectedCommands, $expectedListeners, $format)
+    {
+        $driver = $this->getFFMpegDriverMock();
+        $ffprobe = $this->getFFProbeMock();
+
+        $configuration = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+
+        $driver->expects($this->any())
+            ->method('getConfiguration')
+            ->will($this->returnValue($configuration));
+
+        $configuration->expects($this->once())
+            ->method('has')
+            ->with($this->equalTo('ffmpeg.threads'))
+            ->will($this->returnValue($threads));
+
+        if ($threads) {
+            $configuration->expects($this->once())
+                ->method('get')
+                ->with($this->equalTo('ffmpeg.threads'))
+                ->will($this->returnValue(24));
+        } else {
+            $configuration->expects($this->never())
+                ->method('get');
+        }
+
+        $capturedCommands = array();
+        $capturedListeners = null;
+
+        $driver->expects($this->exactly(2))
+            ->method('command')
+            ->with($this->isType('array'), false, $this->anything())
+            ->will($this->returnCallback(function ($commands, $errors, $listeners) use (&$capturedCommands, &$capturedListeners) {
+                $capturedCommands[] = $commands;
+                $capturedListeners = $listeners;
+            }));
+
+        $outputPathfile = '/target/file';
+
+        $video = new Video(__FILE__, $driver, $ffprobe);
+        $video->save($format, $outputPathfile);
+
+        $prefix = null;
+
+        foreach ($capturedCommands as $passKey => $pass) {
+            foreach ($pass as $command) {
+                if (0 === strpos($command, 'pass-')) {
+                    $prefix = $command;
+                    break;
+                }
+            }
+
+            if (null === $prefix) {
+                $this->fail('Unable to find pass prefix command.');
+            }
+
+            $found = false;
+            foreach ($pass as $key => $command) {
+                if ($command === $prefix) {
+                    $found = true;
+                    unset($capturedCommands[$passKey][$key]);
+                    $capturedCommands[$passKey] = array_values($capturedCommands[$passKey]);
+                    break;
+                }
+            }
+
+            if (!$found) {
+                $this->fail('Unable to find pass prefix command back.');
+            }
+        }
+
+        $this->assertEquals($expectedCommands, $capturedCommands);
+        $this->assertEquals($expectedListeners, $capturedListeners);
+    }
+
+    public function provideSaveData()
+    {
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+        $format->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+        $format->expects($this->any())
+            ->method('getKiloBitrate')
+            ->will($this->returnValue(663));
+        $format->expects($this->any())
+            ->method('getAudioKiloBitrate')
+            ->will($this->returnValue(92));
+
+        $audioVideoFormat = $this->getMock('FFMpeg\Format\VideoInterface');
+        $audioVideoFormat->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+        $audioVideoFormat->expects($this->any())
+            ->method('getVideoCodec')
+            ->will($this->returnValue('gloubi-boulga-video'));
+        $audioVideoFormat->expects($this->any())
+            ->method('getAudioCodec')
+            ->will($this->returnValue('patati-patata-audio'));
+        $audioVideoFormat->expects($this->any())
+            ->method('getKiloBitrate')
+            ->will($this->returnValue(664));
+        $audioVideoFormat->expects($this->any())
+            ->method('getAudioKiloBitrate')
+            ->will($this->returnValue(92));
+
+        $formatExtra = $this->getMock('FFMpeg\Format\VideoInterface');
+        $formatExtra->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array('extra', 'param')));
+        $formatExtra->expects($this->any())
+            ->method('getKiloBitrate')
+            ->will($this->returnValue(665));
+        $formatExtra->expects($this->any())
+            ->method('getAudioKiloBitrate')
+            ->will($this->returnValue(92));
+
+        $listeners = array($this->getMock('Alchemy\BinaryDriver\Listeners\ListenerInterface'));
+
+        $progressableFormat = $this->getMockBuilder('FFMpeg\Tests\Media\Prog')
+            ->disableOriginalConstructor()->getMock();
+        $progressableFormat->expects($this->any())
+            ->method('getExtraParams')
+            ->will($this->returnValue(array()));
+        $progressableFormat->expects($this->any())
+            ->method('createProgressListener')
+            ->will($this->returnValue($listeners));
+        $progressableFormat->expects($this->any())
+            ->method('getKiloBitrate')
+            ->will($this->returnValue(666));
+        $progressableFormat->expects($this->any())
+            ->method('getAudioKiloBitrate')
+            ->will($this->returnValue(92));
+
+        return array(
+            array(false, array(array(
+                    '-y', '-i', __FILE__, '-b:v', '663k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '1', '-passlogfile',
+                    '-an', '/target/file',
+                ), array(
+                    '-y', '-i', __FILE__,
+                    '-b:v', '663k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '2', '-passlogfile',
+                    '-ac', '2', '-ar', '44100', '/target/file',
+                )), null, $format),
+            array(false, array(array(
+                    '-y', '-i', __FILE__,
+                    '-vcodec', 'gloubi-boulga-video',
+                    '-acodec', 'patati-patata-audio', '-b:v', '664k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '1', '-passlogfile',
+                    '-an', '/target/file',
+                ), array(
+                    '-y', '-i', __FILE__,
+                    '-vcodec', 'gloubi-boulga-video',
+                    '-acodec', 'patati-patata-audio',
+                    '-b:v', '664k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '2', '-passlogfile',
+                    '-ac', '2', '-ar', '44100', '/target/file',
+                )), null, $audioVideoFormat),
+            array(false, array(array(
+                    '-y', '-i', __FILE__,
+                    'extra', 'param','-b:v', '665k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '1', '-passlogfile',
+                    '-an', '/target/file',
+                ), array(
+                    '-y', '-i', __FILE__,
+                    'extra', 'param', '-b:v', '665k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '2', '-passlogfile',
+                    '-ac', '2', '-ar', '44100', '/target/file',
+                )), null, $formatExtra),
+            array(true, array(array(
+                    '-y', '-i', __FILE__,
+                    '-threads', 24, '-b:v', '663k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '1', '-passlogfile',
+                    '-an', '/target/file',
+                ), array(
+                    '-y', '-i', __FILE__,
+                    '-threads', 24,
+                    '-b:v', '663k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '2', '-passlogfile',
+                    '-ac', '2', '-ar', '44100', '/target/file',
+                )), null, $format),
+            array(true, array(array(
+                    '-y', '-i', __FILE__,
+                    'extra', 'param', '-threads', 24, '-b:v', '665k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '1', '-passlogfile',
+                    '-an', '/target/file',
+                ), array(
+                    '-y', '-i', __FILE__,
+                    'extra', 'param', '-threads', 24, '-b:v', '665k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '2', '-passlogfile',
+                    '-ac', '2', '-ar', '44100', '/target/file',
+                )), null, $formatExtra),
+            array(false, array(array(
+                    '-y', '-i', __FILE__, '-b:v', '666k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '1', '-passlogfile',
+                    '-an', '/target/file',
+                ), array(
+                    '-y', '-i', __FILE__,
+                    '-b:v', '666k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '2', '-passlogfile',
+                    '-ac', '2', '-ar', '44100', '/target/file',
+                )), $listeners, $progressableFormat),
+            array(true, array(array(
+                    '-y', '-i', __FILE__,
+                    '-threads', 24, '-b:v', '666k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '1', '-passlogfile',
+                    '-an', '/target/file',
+                ), array(
+                    '-y', '-i', __FILE__,
+                    '-threads', 24,
+                    '-b:v', '666k',
+                    '-refs', '6', '-coder', '1', '-sc_threshold', '40', '-flags', '+loop',
+                    '-me_range', '16', '-subq', '7', '-i_qfactor', '0.71', '-qcomp', '0.6',
+                    '-qdiff', '4', '-trellis', '1', '-b:a', '92k', '-pass', '2', '-passlogfile',
+                    '-ac', '2', '-ar', '44100', '/target/file',
+                )), $listeners, $progressableFormat),
+        );
+    }
+
+    public function getClassName()
+    {
+        return 'FFMpeg\Media\Video';
+    }
+}
+
+abstract class Prog implements ProgressableInterface, VideoInterface
+{
+}
--- a/tests/FFMpeg/Tests/TestCase.php
+++ b/tests/FFMpeg/Tests/TestCase.php
@ -0,0 +1,131 @@
+<?php
+
+namespace FFMpeg\Tests;
+
+class TestCase extends \PHPUnit_Framework_TestCase
+{
+    public function assertScalar($value)
+    {
+        $this->assertTrue(is_scalar($value));
+    }
+
+    public function getLoggerMock()
+    {
+        return $this->getMock('Psr\Log\LoggerInterface');
+    }
+
+    public function getCacheMock()
+    {
+        return $this->getMock('Doctrine\Common\Cache\Cache');
+    }
+
+    public function getTimeCodeMock()
+    {
+        return $this->getMockBuilder('FFMpeg\Coordinate\TimeCode')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    public function getDimensionMock()
+    {
+        return $this->getMockBuilder('FFMpeg\Coordinate\Dimension')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    public function getFramerateMock()
+    {
+        return $this->getMockBuilder('FFMpeg\Coordinate\Framerate')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    public function getFFMpegDriverMock()
+    {
+        return $this->getMockBuilder('FFMpeg\Driver\FFMpegDriver')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    public function getFFProbeDriverMock()
+    {
+        return $this->getMockBuilder('FFMpeg\Driver\FFProbeDriver')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    public function getFFProbeMock()
+    {
+        return $this->getMockBuilder('FFMpeg\FFProbe')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    public function getStreamMock()
+    {
+        return $this->getMockBuilder('FFMpeg\FFProbe\DataMapping\Stream')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    public function getFFProbeParserMock()
+    {
+        return $this->getMock('FFMpeg\FFProbe\OutputParserInterface');
+    }
+
+    public function getFFProbeOptionsTesterMock()
+    {
+        return $this->getMock('FFMpeg\FFProbe\OptionsTesterInterface');
+    }
+
+    public function getFFProbeMapperMock()
+    {
+        return $this->getMock('FFMpeg\FFProbe\MapperInterface');
+    }
+
+    public function getFFProbeOptionsTesterMockWithOptions(array $options)
+    {
+        $tester = $this->getFFProbeOptionsTesterMock();
+
+        $tester->expects($this->any())
+            ->method('has')
+            ->will($this->returnCallback(function ($option) use ($options) {
+                return in_array($option, $options);
+            }));
+
+        return $tester;
+    }
+
+    public function getConfigurationMock()
+    {
+        return $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+    }
+
+    public function getFormatMock()
+    {
+        return $this->getMockBuilder('FFMpeg\FFProbe\DataMapping\Format')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    public function getStreamCollectionMock()
+    {
+        return $this->getMockBuilder('FFMpeg\FFProbe\DataMapping\StreamCollection')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    protected function getAudioMock()
+    {
+        return $this->getMockBuilder('FFMpeg\Media\Audio')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+
+    protected function getVideoMock()
+    {
+        return $this->getMockBuilder('FFMpeg\Media\Video')
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+}