dependabot-composer 0.89.5 → 0.90.0

data/helpers/vendor/symfony/console/Tests/Input/InputOptionTest.php

@@ -0,0 +1,196 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Tests\Input;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Console\Input\InputOption;
+
+class InputOptionTest extends TestCase
+{
+    public function testConstructor()
+    {
+        $option = new InputOption('foo');
+        $this->assertEquals('foo', $option->getName(), '__construct() takes a name as its first argument');
+        $option = new InputOption('--foo');
+        $this->assertEquals('foo', $option->getName(), '__construct() removes the leading -- of the option name');
+    }
+
+    /**
+     * @expectedException        \InvalidArgumentException
+     * @expectedExceptionMessage Impossible to have an option mode VALUE_IS_ARRAY if the option does not accept a value.
+     */
+    public function testArrayModeWithoutValue()
+    {
+        new InputOption('foo', 'f', InputOption::VALUE_IS_ARRAY);
+    }
+
+    public function testShortcut()
+    {
+        $option = new InputOption('foo', 'f');
+        $this->assertEquals('f', $option->getShortcut(), '__construct() can take a shortcut as its second argument');
+        $option = new InputOption('foo', '-f|-ff|fff');
+        $this->assertEquals('f|ff|fff', $option->getShortcut(), '__construct() removes the leading - of the shortcuts');
+        $option = new InputOption('foo', array('f', 'ff', '-fff'));
+        $this->assertEquals('f|ff|fff', $option->getShortcut(), '__construct() removes the leading - of the shortcuts');
+        $option = new InputOption('foo');
+        $this->assertNull($option->getShortcut(), '__construct() makes the shortcut null by default');
+    }
+
+    public function testModes()
+    {
+        $option = new InputOption('foo', 'f');
+        $this->assertFalse($option->acceptValue(), '__construct() gives a "InputOption::VALUE_NONE" mode by default');
+        $this->assertFalse($option->isValueRequired(), '__construct() gives a "InputOption::VALUE_NONE" mode by default');
+        $this->assertFalse($option->isValueOptional(), '__construct() gives a "InputOption::VALUE_NONE" mode by default');
+
+        $option = new InputOption('foo', 'f', null);
+        $this->assertFalse($option->acceptValue(), '__construct() can take "InputOption::VALUE_NONE" as its mode');
+        $this->assertFalse($option->isValueRequired(), '__construct() can take "InputOption::VALUE_NONE" as its mode');
+        $this->assertFalse($option->isValueOptional(), '__construct() can take "InputOption::VALUE_NONE" as its mode');
+
+        $option = new InputOption('foo', 'f', InputOption::VALUE_NONE);
+        $this->assertFalse($option->acceptValue(), '__construct() can take "InputOption::VALUE_NONE" as its mode');
+        $this->assertFalse($option->isValueRequired(), '__construct() can take "InputOption::VALUE_NONE" as its mode');
+        $this->assertFalse($option->isValueOptional(), '__construct() can take "InputOption::VALUE_NONE" as its mode');
+
+        $option = new InputOption('foo', 'f', InputOption::VALUE_REQUIRED);
+        $this->assertTrue($option->acceptValue(), '__construct() can take "InputOption::VALUE_REQUIRED" as its mode');
+        $this->assertTrue($option->isValueRequired(), '__construct() can take "InputOption::VALUE_REQUIRED" as its mode');
+        $this->assertFalse($option->isValueOptional(), '__construct() can take "InputOption::VALUE_REQUIRED" as its mode');
+
+        $option = new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL);
+        $this->assertTrue($option->acceptValue(), '__construct() can take "InputOption::VALUE_OPTIONAL" as its mode');
+        $this->assertFalse($option->isValueRequired(), '__construct() can take "InputOption::VALUE_OPTIONAL" as its mode');
+        $this->assertTrue($option->isValueOptional(), '__construct() can take "InputOption::VALUE_OPTIONAL" as its mode');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Option mode "-1" is not valid.
+     */
+    public function testInvalidModes()
+    {
+        new InputOption('foo', 'f', '-1');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testEmptyNameIsInvalid()
+    {
+        new InputOption('');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testDoubleDashNameIsInvalid()
+    {
+        new InputOption('--');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testSingleDashOptionIsInvalid()
+    {
+        new InputOption('foo', '-');
+    }
+
+    public function testIsArray()
+    {
+        $option = new InputOption('foo', null, InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY);
+        $this->assertTrue($option->isArray(), '->isArray() returns true if the option can be an array');
+        $option = new InputOption('foo', null, InputOption::VALUE_NONE);
+        $this->assertFalse($option->isArray(), '->isArray() returns false if the option can not be an array');
+    }
+
+    public function testGetDescription()
+    {
+        $option = new InputOption('foo', 'f', null, 'Some description');
+        $this->assertEquals('Some description', $option->getDescription(), '->getDescription() returns the description message');
+    }
+
+    public function testGetDefault()
+    {
+        $option = new InputOption('foo', null, InputOption::VALUE_OPTIONAL, '', 'default');
+        $this->assertEquals('default', $option->getDefault(), '->getDefault() returns the default value');
+
+        $option = new InputOption('foo', null, InputOption::VALUE_REQUIRED, '', 'default');
+        $this->assertEquals('default', $option->getDefault(), '->getDefault() returns the default value');
+
+        $option = new InputOption('foo', null, InputOption::VALUE_REQUIRED);
+        $this->assertNull($option->getDefault(), '->getDefault() returns null if no default value is configured');
+
+        $option = new InputOption('foo', null, InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY);
+        $this->assertEquals(array(), $option->getDefault(), '->getDefault() returns an empty array if option is an array');
+
+        $option = new InputOption('foo', null, InputOption::VALUE_NONE);
+        $this->assertFalse($option->getDefault(), '->getDefault() returns false if the option does not take a value');
+    }
+
+    public function testSetDefault()
+    {
+        $option = new InputOption('foo', null, InputOption::VALUE_REQUIRED, '', 'default');
+        $option->setDefault(null);
+        $this->assertNull($option->getDefault(), '->setDefault() can reset the default value by passing null');
+        $option->setDefault('another');
+        $this->assertEquals('another', $option->getDefault(), '->setDefault() changes the default value');
+
+        $option = new InputOption('foo', null, InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY);
+        $option->setDefault(array(1, 2));
+        $this->assertEquals(array(1, 2), $option->getDefault(), '->setDefault() changes the default value');
+    }
+
+    /**
+     * @expectedException        \LogicException
+     * @expectedExceptionMessage Cannot set a default value when using InputOption::VALUE_NONE mode.
+     */
+    public function testDefaultValueWithValueNoneMode()
+    {
+        $option = new InputOption('foo', 'f', InputOption::VALUE_NONE);
+        $option->setDefault('default');
+    }
+
+    /**
+     * @expectedException        \LogicException
+     * @expectedExceptionMessage A default value for an array option must be an array.
+     */
+    public function testDefaultValueWithIsArrayMode()
+    {
+        $option = new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY);
+        $option->setDefault('default');
+    }
+
+    public function testEquals()
+    {
+        $option = new InputOption('foo', 'f', null, 'Some description');
+        $option2 = new InputOption('foo', 'f', null, 'Alternative description');
+        $this->assertTrue($option->equals($option2));
+
+        $option = new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL, 'Some description');
+        $option2 = new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL, 'Some description', true);
+        $this->assertFalse($option->equals($option2));
+
+        $option = new InputOption('foo', 'f', null, 'Some description');
+        $option2 = new InputOption('bar', 'f', null, 'Some description');
+        $this->assertFalse($option->equals($option2));
+
+        $option = new InputOption('foo', 'f', null, 'Some description');
+        $option2 = new InputOption('foo', '', null, 'Some description');
+        $this->assertFalse($option->equals($option2));
+
+        $option = new InputOption('foo', 'f', null, 'Some description');
+        $option2 = new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL, 'Some description');
+        $this->assertFalse($option->equals($option2));
+    }
+}

data/helpers/vendor/symfony/console/Tests/Input/InputTest.php

@@ -0,0 +1,149 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Tests\Input;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Console\Input\ArrayInput;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputDefinition;
+use Symfony\Component\Console\Input\InputOption;
+
+class InputTest extends TestCase
+{
+    public function testConstructor()
+    {
+        $input = new ArrayInput(array('name' => 'foo'), new InputDefinition(array(new InputArgument('name'))));
+        $this->assertEquals('foo', $input->getArgument('name'), '->__construct() takes a InputDefinition as an argument');
+    }
+
+    public function testOptions()
+    {
+        $input = new ArrayInput(array('--name' => 'foo'), new InputDefinition(array(new InputOption('name'))));
+        $this->assertEquals('foo', $input->getOption('name'), '->getOption() returns the value for the given option');
+
+        $input->setOption('name', 'bar');
+        $this->assertEquals('bar', $input->getOption('name'), '->setOption() sets the value for a given option');
+        $this->assertEquals(array('name' => 'bar'), $input->getOptions(), '->getOptions() returns all option values');
+
+        $input = new ArrayInput(array('--name' => 'foo'), new InputDefinition(array(new InputOption('name'), new InputOption('bar', '', InputOption::VALUE_OPTIONAL, '', 'default'))));
+        $this->assertEquals('default', $input->getOption('bar'), '->getOption() returns the default value for optional options');
+        $this->assertEquals(array('name' => 'foo', 'bar' => 'default'), $input->getOptions(), '->getOptions() returns all option values, even optional ones');
+
+        $input = new ArrayInput(array('--name' => 'foo', '--bar' => ''), new InputDefinition(array(new InputOption('name'), new InputOption('bar', '', InputOption::VALUE_OPTIONAL, '', 'default'))));
+        $this->assertEquals('', $input->getOption('bar'), '->getOption() returns null for options explicitly passed without value (or an empty value)');
+        $this->assertEquals(array('name' => 'foo', 'bar' => ''), $input->getOptions(), '->getOptions() returns all option values.');
+
+        $input = new ArrayInput(array('--name' => 'foo', '--bar' => null), new InputDefinition(array(new InputOption('name'), new InputOption('bar', '', InputOption::VALUE_OPTIONAL, '', 'default'))));
+        $this->assertNull($input->getOption('bar'), '->getOption() returns null for options explicitly passed without value (or an empty value)');
+        $this->assertEquals(array('name' => 'foo', 'bar' => null), $input->getOptions(), '->getOptions() returns all option values');
+    }
+
+    /**
+     * @expectedException        \InvalidArgumentException
+     * @expectedExceptionMessage The "foo" option does not exist.
+     */
+    public function testSetInvalidOption()
+    {
+        $input = new ArrayInput(array('--name' => 'foo'), new InputDefinition(array(new InputOption('name'), new InputOption('bar', '', InputOption::VALUE_OPTIONAL, '', 'default'))));
+        $input->setOption('foo', 'bar');
+    }
+
+    /**
+     * @expectedException        \InvalidArgumentException
+     * @expectedExceptionMessage The "foo" option does not exist.
+     */
+    public function testGetInvalidOption()
+    {
+        $input = new ArrayInput(array('--name' => 'foo'), new InputDefinition(array(new InputOption('name'), new InputOption('bar', '', InputOption::VALUE_OPTIONAL, '', 'default'))));
+        $input->getOption('foo');
+    }
+
+    public function testArguments()
+    {
+        $input = new ArrayInput(array('name' => 'foo'), new InputDefinition(array(new InputArgument('name'))));
+        $this->assertEquals('foo', $input->getArgument('name'), '->getArgument() returns the value for the given argument');
+
+        $input->setArgument('name', 'bar');
+        $this->assertEquals('bar', $input->getArgument('name'), '->setArgument() sets the value for a given argument');
+        $this->assertEquals(array('name' => 'bar'), $input->getArguments(), '->getArguments() returns all argument values');
+
+        $input = new ArrayInput(array('name' => 'foo'), new InputDefinition(array(new InputArgument('name'), new InputArgument('bar', InputArgument::OPTIONAL, '', 'default'))));
+        $this->assertEquals('default', $input->getArgument('bar'), '->getArgument() returns the default value for optional arguments');
+        $this->assertEquals(array('name' => 'foo', 'bar' => 'default'), $input->getArguments(), '->getArguments() returns all argument values, even optional ones');
+    }
+
+    /**
+     * @expectedException        \InvalidArgumentException
+     * @expectedExceptionMessage The "foo" argument does not exist.
+     */
+    public function testSetInvalidArgument()
+    {
+        $input = new ArrayInput(array('name' => 'foo'), new InputDefinition(array(new InputArgument('name'), new InputArgument('bar', InputArgument::OPTIONAL, '', 'default'))));
+        $input->setArgument('foo', 'bar');
+    }
+
+    /**
+     * @expectedException        \InvalidArgumentException
+     * @expectedExceptionMessage The "foo" argument does not exist.
+     */
+    public function testGetInvalidArgument()
+    {
+        $input = new ArrayInput(array('name' => 'foo'), new InputDefinition(array(new InputArgument('name'), new InputArgument('bar', InputArgument::OPTIONAL, '', 'default'))));
+        $input->getArgument('foo');
+    }
+
+    /**
+     * @expectedException        \RuntimeException
+     * @expectedExceptionMessage Not enough arguments (missing: "name").
+     */
+    public function testValidateWithMissingArguments()
+    {
+        $input = new ArrayInput(array());
+        $input->bind(new InputDefinition(array(new InputArgument('name', InputArgument::REQUIRED))));
+        $input->validate();
+    }
+
+    /**
+     * @expectedException        \RuntimeException
+     * @expectedExceptionMessage Not enough arguments (missing: "name").
+     */
+    public function testValidateWithMissingRequiredArguments()
+    {
+        $input = new ArrayInput(array('bar' => 'baz'));
+        $input->bind(new InputDefinition(array(new InputArgument('name', InputArgument::REQUIRED), new InputArgument('bar', InputArgument::OPTIONAL))));
+        $input->validate();
+    }
+
+    public function testValidate()
+    {
+        $input = new ArrayInput(array('name' => 'foo'));
+        $input->bind(new InputDefinition(array(new InputArgument('name', InputArgument::REQUIRED))));
+
+        $this->assertNull($input->validate());
+    }
+
+    public function testSetGetInteractive()
+    {
+        $input = new ArrayInput(array());
+        $this->assertTrue($input->isInteractive(), '->isInteractive() returns whether the input should be interactive or not');
+        $input->setInteractive(false);
+        $this->assertFalse($input->isInteractive(), '->setInteractive() changes the interactive flag');
+    }
+
+    public function testSetGetStream()
+    {
+        $input = new ArrayInput(array());
+        $stream = fopen('php://memory', 'r+', false);
+        $input->setStream($stream);
+        $this->assertSame($stream, $input->getStream());
+    }
+}

data/helpers/vendor/symfony/console/Tests/Input/StringInputTest.php

@@ -0,0 +1,87 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Tests\Input;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Console\Input\InputDefinition;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Input\StringInput;
+
+class StringInputTest extends TestCase
+{
+    /**
+     * @dataProvider getTokenizeData
+     */
+    public function testTokenize($input, $tokens, $message)
+    {
+        $input = new StringInput($input);
+        $r = new \ReflectionClass('Symfony\Component\Console\Input\ArgvInput');
+        $p = $r->getProperty('tokens');
+        $p->setAccessible(true);
+        $this->assertEquals($tokens, $p->getValue($input), $message);
+    }
+
+    public function testInputOptionWithGivenString()
+    {
+        $definition = new InputDefinition(
+            array(new InputOption('foo', null, InputOption::VALUE_REQUIRED))
+        );
+
+        // call to bind
+        $input = new StringInput('--foo=bar');
+        $input->bind($definition);
+        $this->assertEquals('bar', $input->getOption('foo'));
+    }
+
+    public function getTokenizeData()
+    {
+        return array(
+            array('', array(), '->tokenize() parses an empty string'),
+            array('foo', array('foo'), '->tokenize() parses arguments'),
+            array('  foo  bar  ', array('foo', 'bar'), '->tokenize() ignores whitespaces between arguments'),
+            array('"quoted"', array('quoted'), '->tokenize() parses quoted arguments'),
+            array("'quoted'", array('quoted'), '->tokenize() parses quoted arguments'),
+            array("'a\rb\nc\td'", array("a\rb\nc\td"), '->tokenize() parses whitespace chars in strings'),
+            array("'a'\r'b'\n'c'\t'd'", array('a', 'b', 'c', 'd'), '->tokenize() parses whitespace chars between args as spaces'),
+            array('\"quoted\"', array('"quoted"'), '->tokenize() parses escaped-quoted arguments'),
+            array("\'quoted\'", array('\'quoted\''), '->tokenize() parses escaped-quoted arguments'),
+            array('-a', array('-a'), '->tokenize() parses short options'),
+            array('-azc', array('-azc'), '->tokenize() parses aggregated short options'),
+            array('-awithavalue', array('-awithavalue'), '->tokenize() parses short options with a value'),
+            array('-a"foo bar"', array('-afoo bar'), '->tokenize() parses short options with a value'),
+            array('-a"foo bar""foo bar"', array('-afoo barfoo bar'), '->tokenize() parses short options with a value'),
+            array('-a\'foo bar\'', array('-afoo bar'), '->tokenize() parses short options with a value'),
+            array('-a\'foo bar\'\'foo bar\'', array('-afoo barfoo bar'), '->tokenize() parses short options with a value'),
+            array('-a\'foo bar\'"foo bar"', array('-afoo barfoo bar'), '->tokenize() parses short options with a value'),
+            array('--long-option', array('--long-option'), '->tokenize() parses long options'),
+            array('--long-option=foo', array('--long-option=foo'), '->tokenize() parses long options with a value'),
+            array('--long-option="foo bar"', array('--long-option=foo bar'), '->tokenize() parses long options with a value'),
+            array('--long-option="foo bar""another"', array('--long-option=foo baranother'), '->tokenize() parses long options with a value'),
+            array('--long-option=\'foo bar\'', array('--long-option=foo bar'), '->tokenize() parses long options with a value'),
+            array("--long-option='foo bar''another'", array('--long-option=foo baranother'), '->tokenize() parses long options with a value'),
+            array("--long-option='foo bar'\"another\"", array('--long-option=foo baranother'), '->tokenize() parses long options with a value'),
+            array('foo -a -ffoo --long bar', array('foo', '-a', '-ffoo', '--long', 'bar'), '->tokenize() parses when several arguments and options'),
+        );
+    }
+
+    public function testToString()
+    {
+        $input = new StringInput('-f foo');
+        $this->assertEquals('-f foo', (string) $input);
+
+        $input = new StringInput('-f --bar=foo "a b c d"');
+        $this->assertEquals('-f --bar=foo '.escapeshellarg('a b c d'), (string) $input);
+
+        $input = new StringInput('-f --bar=foo \'a b c d\' '."'A\nB\\'C'");
+        $this->assertEquals('-f --bar=foo '.escapeshellarg('a b c d').' '.escapeshellarg("A\nB'C"), (string) $input);
+    }
+}

data/helpers/vendor/symfony/console/Tests/Logger/ConsoleLoggerTest.php

@@ -0,0 +1,215 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Tests\Logger;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+use Psr\Log\LogLevel;
+use Symfony\Component\Console\Logger\ConsoleLogger;
+use Symfony\Component\Console\Output\BufferedOutput;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Tests\Fixtures\DummyOutput;
+
+/**
+ * Console logger test.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class ConsoleLoggerTest extends TestCase
+{
+    /**
+     * @var DummyOutput
+     */
+    protected $output;
+
+    /**
+     * @return LoggerInterface
+     */
+    public function getLogger()
+    {
+        $this->output = new DummyOutput(OutputInterface::VERBOSITY_VERBOSE);
+
+        return new ConsoleLogger($this->output, array(
+            LogLevel::EMERGENCY => OutputInterface::VERBOSITY_NORMAL,
+            LogLevel::ALERT => OutputInterface::VERBOSITY_NORMAL,
+            LogLevel::CRITICAL => OutputInterface::VERBOSITY_NORMAL,
+            LogLevel::ERROR => OutputInterface::VERBOSITY_NORMAL,
+            LogLevel::WARNING => OutputInterface::VERBOSITY_NORMAL,
+            LogLevel::NOTICE => OutputInterface::VERBOSITY_NORMAL,
+            LogLevel::INFO => OutputInterface::VERBOSITY_NORMAL,
+            LogLevel::DEBUG => OutputInterface::VERBOSITY_NORMAL,
+        ));
+    }
+
+    /**
+     * Return the log messages in order.
+     *
+     * @return string[]
+     */
+    public function getLogs()
+    {
+        return $this->output->getLogs();
+    }
+
+    /**
+     * @dataProvider provideOutputMappingParams
+     */
+    public function testOutputMapping($logLevel, $outputVerbosity, $isOutput, $addVerbosityLevelMap = array())
+    {
+        $out = new BufferedOutput($outputVerbosity);
+        $logger = new ConsoleLogger($out, $addVerbosityLevelMap);
+        $logger->log($logLevel, 'foo bar');
+        $logs = $out->fetch();
+        $this->assertEquals($isOutput ? "[$logLevel] foo bar".PHP_EOL : '', $logs);
+    }
+
+    public function provideOutputMappingParams()
+    {
+        $quietMap = array(LogLevel::EMERGENCY => OutputInterface::VERBOSITY_QUIET);
+
+        return array(
+            array(LogLevel::EMERGENCY, OutputInterface::VERBOSITY_NORMAL, true),
+            array(LogLevel::WARNING, OutputInterface::VERBOSITY_NORMAL, true),
+            array(LogLevel::INFO, OutputInterface::VERBOSITY_NORMAL, false),
+            array(LogLevel::DEBUG, OutputInterface::VERBOSITY_NORMAL, false),
+            array(LogLevel::INFO, OutputInterface::VERBOSITY_VERBOSE, false),
+            array(LogLevel::INFO, OutputInterface::VERBOSITY_VERY_VERBOSE, true),
+            array(LogLevel::DEBUG, OutputInterface::VERBOSITY_VERY_VERBOSE, false),
+            array(LogLevel::DEBUG, OutputInterface::VERBOSITY_DEBUG, true),
+            array(LogLevel::ALERT, OutputInterface::VERBOSITY_QUIET, false),
+            array(LogLevel::EMERGENCY, OutputInterface::VERBOSITY_QUIET, false),
+            array(LogLevel::ALERT, OutputInterface::VERBOSITY_QUIET, false, $quietMap),
+            array(LogLevel::EMERGENCY, OutputInterface::VERBOSITY_QUIET, true, $quietMap),
+        );
+    }
+
+    public function testHasErrored()
+    {
+        $logger = new ConsoleLogger(new BufferedOutput());
+
+        $this->assertFalse($logger->hasErrored());
+
+        $logger->warning('foo');
+        $this->assertFalse($logger->hasErrored());
+
+        $logger->error('bar');
+        $this->assertTrue($logger->hasErrored());
+    }
+
+    public function testImplements()
+    {
+        $this->assertInstanceOf('Psr\Log\LoggerInterface', $this->getLogger());
+    }
+
+    /**
+     * @dataProvider provideLevelsAndMessages
+     */
+    public function testLogsAtAllLevels($level, $message)
+    {
+        $logger = $this->getLogger();
+        $logger->{$level}($message, array('user' => 'Bob'));
+        $logger->log($level, $message, array('user' => 'Bob'));
+
+        $expected = array(
+            $level.' message of level '.$level.' with context: Bob',
+            $level.' message of level '.$level.' with context: Bob',
+        );
+        $this->assertEquals($expected, $this->getLogs());
+    }
+
+    public function provideLevelsAndMessages()
+    {
+        return array(
+            LogLevel::EMERGENCY => array(LogLevel::EMERGENCY, 'message of level emergency with context: {user}'),
+            LogLevel::ALERT => array(LogLevel::ALERT, 'message of level alert with context: {user}'),
+            LogLevel::CRITICAL => array(LogLevel::CRITICAL, 'message of level critical with context: {user}'),
+            LogLevel::ERROR => array(LogLevel::ERROR, 'message of level error with context: {user}'),
+            LogLevel::WARNING => array(LogLevel::WARNING, 'message of level warning with context: {user}'),
+            LogLevel::NOTICE => array(LogLevel::NOTICE, 'message of level notice with context: {user}'),
+            LogLevel::INFO => array(LogLevel::INFO, 'message of level info with context: {user}'),
+            LogLevel::DEBUG => array(LogLevel::DEBUG, 'message of level debug with context: {user}'),
+        );
+    }
+
+    /**
+     * @expectedException \Psr\Log\InvalidArgumentException
+     */
+    public function testThrowsOnInvalidLevel()
+    {
+        $logger = $this->getLogger();
+        $logger->log('invalid level', 'Foo');
+    }
+
+    public function testContextReplacement()
+    {
+        $logger = $this->getLogger();
+        $logger->info('{Message {nothing} {user} {foo.bar} a}', array('user' => 'Bob', 'foo.bar' => 'Bar'));
+
+        $expected = array('info {Message {nothing} Bob Bar a}');
+        $this->assertEquals($expected, $this->getLogs());
+    }
+
+    public function testObjectCastToString()
+    {
+        if (method_exists($this, 'createPartialMock')) {
+            $dummy = $this->createPartialMock('Symfony\Component\Console\Tests\Logger\DummyTest', array('__toString'));
+        } else {
+            $dummy = $this->getMock('Symfony\Component\Console\Tests\Logger\DummyTest', array('__toString'));
+        }
+        $dummy->method('__toString')->will($this->returnValue('DUMMY'));
+
+        $this->getLogger()->warning($dummy);
+
+        $expected = array('warning DUMMY');
+        $this->assertEquals($expected, $this->getLogs());
+    }
+
+    public function testContextCanContainAnything()
+    {
+        $context = array(
+            'bool' => true,
+            'null' => null,
+            'string' => 'Foo',
+            'int' => 0,
+            'float' => 0.5,
+            'nested' => array('with object' => new DummyTest()),
+            'object' => new \DateTime(),
+            'resource' => fopen('php://memory', 'r'),
+        );
+
+        $this->getLogger()->warning('Crazy context data', $context);
+
+        $expected = array('warning Crazy context data');
+        $this->assertEquals($expected, $this->getLogs());
+    }
+
+    public function testContextExceptionKeyCanBeExceptionOrOtherValues()
+    {
+        $logger = $this->getLogger();
+        $logger->warning('Random message', array('exception' => 'oops'));
+        $logger->critical('Uncaught Exception!', array('exception' => new \LogicException('Fail')));
+
+        $expected = array(
+            'warning Random message',
+            'critical Uncaught Exception!',
+        );
+        $this->assertEquals($expected, $this->getLogs());
+    }
+}
+
+class DummyTest
+{
+    public function __toString()
+    {
+    }
+}