Cleanup phpunit configs and PSR-4 autoloading and namespaces for tests

tests/Unit/Filters/Audio/AudioFiltersTest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Audio;
+
+use FFMpeg\Filters\Audio\AudioFilters;
+use Tests\FFMpeg\Unit\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());
+    }
+}

tests/Unit/Filters/Audio/AudioResamplableFilterTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Audio;
+
+use FFMpeg\Filters\Audio\AudioResamplableFilter;
+use Tests\FFMpeg\Unit\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));
+    }
+}

tests/Unit/Filters/FiltersCollectionTest.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters;
+
+use FFMpeg\Filters\FiltersCollection;
+use FFMpeg\Filters\Audio\SimpleFilter;
+use Tests\FFMpeg\Unit\TestCase;
+
+class FiltersCollectionTest extends 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());
+    }
+
+    public function testEmptyIterator()
+    {
+        $coll = new FiltersCollection();
+        $this->assertInstanceOf('\ArrayIterator', $coll->getIterator());
+    }
+
+    public function testIteratorSort()
+    {
+        $coll = new FiltersCollection();
+        $coll->add(new SimpleFilter(array('a')));
+        $coll->add(new SimpleFilter(array('1'), 12));
+        $coll->add(new SimpleFilter(array('b')));
+        $coll->add(new SimpleFilter(array('2'), 12));
+        $coll->add(new SimpleFilter(array('c')));
+        $coll->add(new SimpleFilter(array('3'), 10));
+        $coll->add(new SimpleFilter(array('d')));
+        $coll->add(new SimpleFilter(array('4'), -2));
+        $coll->add(new SimpleFilter(array('e')));
+
+        $data = array();
+        $video = $this->getVideoMock();
+        $format = $this->getMock('FFMpeg\Format\AudioInterface');
+
+        foreach ($coll as $filter) {
+            $data = array_merge($data, $filter->apply($video, $format));
+        }
+
+        $this->assertEquals(array('1', '2', '3', 'a', 'b', 'c', 'd', 'e', '4'), $data);
+    }
+}

tests/Unit/Filters/Frame/DisplayRatioFixerFilterTest.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Frame;
+
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\Filters\Frame\DisplayRatioFixerFilter;
+use FFMpeg\Media\Frame;
+use FFMpeg\Coordinate\TimeCode;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+use FFMpeg\FFProbe\DataMapping\Stream;
+
+class DisplayRatioFixerFilterTest extends TestCase
+{
+    public function testApply()
+    {
+        $stream = new Stream(array('codec_type' => 'video', 'width' => 960, 'height' => 720));
+        $streams = new StreamCollection(array($stream));
+
+        $video = $this->getVideoMock(__FILE__);
+        $video->expects($this->once())
+                ->method('getStreams')
+                ->will($this->returnValue($streams));
+
+        $frame = new Frame($video, $this->getFFMpegDriverMock(), $this->getFFProbeMock(), new TimeCode(0, 0, 0, 0));
+        $filter = new DisplayRatioFixerFilter();
+        $this->assertEquals(array('-s', '960x720'), $filter->apply($frame));
+    }
+}

tests/Unit/Filters/Frame/FrameFiltersTest.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Frame;
+
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\Filters\Frame\FrameFilters;
+
+class FrameFiltersTest extends TestCase
+{
+    public function testResize()
+    {
+        $frame = $this->getFrameMock();
+        $filters = new FrameFilters($frame);
+
+        $frame->expects($this->once())
+            ->method('addFilter')
+            ->with($this->isInstanceOf('FFMpeg\Filters\Frame\DisplayRatioFixerFilter'));
+
+        $filters->fixDisplayRatio();
+    }
+}

tests/Unit/Filters/Video/CropFilterTest.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Video;
+
+use FFMpeg\Coordinate\Dimension;
+use FFMpeg\Coordinate\Point;
+use FFMpeg\FFProbe\DataMapping\Stream;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+use FFMpeg\Filters\Video\CropFilter;
+use Tests\FFMpeg\Unit\TestCase;
+
+class CropFilterTest extends TestCase
+{
+
+    public function testCommandParamsAreCorrectAndStreamIsUpdated()
+    {
+        $stream = new Stream(array('width' => 320, 'height' => 240, 'codec_type' => 'video'));
+        $streams = new StreamCollection(array($stream));
+
+        $video = $this->getVideoMock();
+        $video->expects($this->once())
+            ->method('getStreams')
+            ->will($this->returnValue($streams));
+
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+
+        $dimension = new Dimension(200, 150);
+        $point = new Point(25, 35);
+        $filter = new CropFilter($point, $dimension);
+        $expected = array(
+            '-filter:v',
+            'crop=' . $dimension->getWidth() . ":" . $dimension->getHeight() . ":" . $point->getX() . ":" . $point->getY()
+        );
+        $this->assertEquals($expected, $filter->apply($video, $format));
+
+        $this->assertEquals(200, $stream->get('width'));
+        $this->assertEquals(150, $stream->get('height'));
+    }
+
+}

tests/Unit/Filters/Video/CustomFilterTest.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Video;
+
+use FFMpeg\Filters\Video\CustomFilter;
+use FFMpeg\Filters\Video\FrameRateFilter;
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\Coordinate\FrameRate;
+
+class CustomFilterTest extends TestCase
+{
+    public function testApplyCustomFilter()
+    {
+        $video = $this->getVideoMock();
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+
+        $filter = new CustomFilter('whatever i put would end up as a filter');
+        $this->assertEquals(array('-vf', 'whatever i put would end up as a filter'), $filter->apply($video, $format));
+    }
+}

tests/Unit/Filters/Video/FrameRateFilterTest.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Video;
+
+use FFMpeg\Filters\Video\FrameRateFilter;
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\Coordinate\FrameRate;
+
+class FrameRateFilterTest 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 FrameRateFilter($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 FrameRateFilter($framerate, $gop);
+        $this->assertEquals($expected, $filter->apply($video, $format));
+    }
+}

tests/Unit/Filters/Video/ResizeFilterTest.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Video;
+
+use FFMpeg\Filters\Video\ResizeFilter;
+use Tests\FFMpeg\Unit\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')),
+        );
+    }
+}

tests/Unit/Filters/Video/RotateFilterTest.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Video;
+
+use FFMpeg\FFProbe\DataMapping\Stream;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+use FFMpeg\Filters\Video\RotateFilter;
+use Tests\FFMpeg\Unit\TestCase;
+
+class RotateFilterTest extends TestCase
+{
+    /**
+     * @dataProvider provide90degresTranspositions
+     */
+    public function testApplyWithSizeTransformation($value)
+    {
+        $stream = new Stream(array('width' => 320, 'height' => 240, 'codec_type' => 'video'));
+        $streams = new StreamCollection(array($stream));
+
+        $video = $this->getVideoMock();
+        $video->expects($this->once())
+            ->method('getStreams')
+            ->will($this->returnValue($streams));
+
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+
+        $filter = new RotateFilter($value);
+        $this->assertEquals(array('-vf', $value, '-metadata:s:v:0', 'rotate=0'), $filter->apply($video, $format));
+
+        $this->assertEquals(240, $stream->get('width'));
+        $this->assertEquals(320, $stream->get('height'));
+    }
+
+    public function provide90degresTranspositions()
+    {
+        return array(
+            array(RotateFilter::ROTATE_90),
+            array(RotateFilter::ROTATE_270),
+        );
+    }
+
+    /**
+     * @dataProvider provideDegresWithoutTranspositions
+     */
+    public function testApplyWithoutSizeTransformation($value)
+    {
+        $video = $this->getVideoMock();
+        $video->expects($this->never())
+            ->method('getStreams');
+
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+
+        $filter = new RotateFilter($value);
+        $this->assertEquals(array('-vf', $value, '-metadata:s:v:0', 'rotate=0'), $filter->apply($video, $format));
+    }
+
+    public function provideDegresWithoutTranspositions()
+    {
+        return array(
+            array(RotateFilter::ROTATE_180),
+        );
+    }
+
+    /**
+     * @expectedException \FFMpeg\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Invalid angle value.
+     */
+    public function testApplyInvalidAngle()
+    {
+        new RotateFilter('90');
+    }
+}

tests/Unit/Filters/Video/SynchronizeFilterTest.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Video;
+
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\Filters\Video\SynchronizeFilter;
+
+class SynchronizeFilterTest extends TestCase
+{
+    public function testApply()
+    {
+        $video = $this->getVideoMock();
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+
+        $filter = new SynchronizeFilter();
+        $this->assertEquals(array('-async', '1', '-metadata:s:v:0', 'start_time=0'), $filter->apply($video, $format));
+    }
+}

tests/Unit/Filters/Video/VideoFiltersTest.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Video;
+
+use Tests\FFMpeg\Unit\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\FrameRateFilter'))
+            ->will($this->returnCallback(function ($filter) use (&$capturedFilter) {
+                $capturedFilter = $filter;
+            }));
+
+        $filters->framerate($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();
+    }
+}

tests/Unit/Filters/Video/WatermarkFilterTest.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\Filters\Video;
+
+use FFMpeg\FFProbe\DataMapping\Stream;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+use FFMpeg\Filters\Video\RotateFilter;
+use FFMpeg\Filters\Video\WatermarkFilter;
+use Tests\FFMpeg\Unit\TestCase;
+
+class WatermarkFilterTest extends TestCase
+{
+    public function testApplyWatermark()
+    {
+        $stream = new Stream(array('width' => 320, 'height' => 240, 'codec_type' => 'video'));
+        $streams = new StreamCollection(array($stream));
+
+        $video = $this->getVideoMock();
+
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+
+        $filter = new WatermarkFilter(__DIR__ . '/../../../files/watermark.png');
+        $this->assertEquals(array('-vf', 'movie='.__DIR__ .'/../../../files/watermark.png [watermark]; [in][watermark] overlay=0:0 [out]'), $filter->apply($video, $format));
+
+        // check size of video is unchanged
+        $this->assertEquals(320, $stream->get('width'));
+        $this->assertEquals(240, $stream->get('height'));
+    }
+
+    public function testDifferentCoordinaates()
+    {
+        $video = $this->getVideoMock();
+        $format = $this->getMock('FFMpeg\Format\VideoInterface');
+
+        // test position absolute
+        $filter = new WatermarkFilter(__DIR__ . '/../../../files/watermark.png', array(
+            'position' => 'absolute',
+            'x' => 10, 'y' => 5
+        ));
+        $this->assertEquals(array('-vf', 'movie='.__DIR__ .'/../../../files/watermark.png [watermark]; [in][watermark] overlay=10:5 [out]'), $filter->apply($video, $format));
+
+        // test position relative
+        $filter = new WatermarkFilter(__DIR__ . '/../../../files/watermark.png', array(
+            'position' => 'relative',
+            'bottom' => 10, 'left' => 5
+        ));
+        $this->assertEquals(array('-vf', 'movie='.__DIR__ .'/../../../files/watermark.png [watermark]; [in][watermark] overlay=5:main_h - 10 - overlay_h [out]'), $filter->apply($video, $format));
+
+        // test position relative
+        $filter = new WatermarkFilter(__DIR__ . '/../../../files/watermark.png', array(
+            'position' => 'relative',
+            'bottom' => 5, 'right' => 4
+        ));
+        $this->assertEquals(array('-vf', 'movie='.__DIR__ .'/../../../files/watermark.png [watermark]; [in][watermark] overlay=main_w - 4 - overlay_w:main_h - 5 - overlay_h [out]'), $filter->apply($video, $format));
+
+        // test position relative
+        $filter = new WatermarkFilter(__DIR__ . '/../../../files/watermark.png', array(
+            'position' => 'relative',
+            'left' => 5, 'top' => 11
+        ));
+        $this->assertEquals(array('-vf', 'movie='.__DIR__ .'/../../../files/watermark.png [watermark]; [in][watermark] overlay=5:11 [out]'), $filter->apply($video, $format));
+    }
+}