Drupal 8.0.0 beta 12. More info: https://www.drupal.org/node/2514176
This commit is contained in:
Pantheon Automation
Greg Anderson
commit
9921556621
13277 changed files with 1459781 additions and 0 deletions
178
core/vendor/guzzlehttp/streams/tests/AppendStreamTest.php
vendored
Normal file
178
core/vendor/guzzlehttp/streams/tests/AppendStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,178 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\AppendStream;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
|
||||
class AppendStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
/**
|
||||
* @expectedException \InvalidArgumentException
|
||||
* @expectedExceptionMessage Each stream must be readable
|
||||
*/
|
||||
public function testValidatesStreamsAreReadable()
|
||||
{
|
||||
$a = new AppendStream();
|
||||
$s = $this->getMockBuilder('GuzzleHttp\Stream\StreamInterface')
|
||||
->setMethods(['isReadable'])
|
||||
->getMockForAbstractClass();
|
||||
$s->expects($this->once())
|
||||
->method('isReadable')
|
||||
->will($this->returnValue(false));
|
||||
$a->addStream($s);
|
||||
}
|
||||
|
||||
public function testValidatesSeekType()
|
||||
{
|
||||
$a = new AppendStream();
|
||||
$this->assertFalse($a->seek(100, SEEK_CUR));
|
||||
}
|
||||
|
||||
public function testTriesToRewindOnSeek()
|
||||
{
|
||||
$a = new AppendStream();
|
||||
$s = $this->getMockBuilder('GuzzleHttp\Stream\StreamInterface')
|
||||
->setMethods(['isReadable', 'seek', 'isSeekable'])
|
||||
->getMockForAbstractClass();
|
||||
$s->expects($this->once())
|
||||
->method('isReadable')
|
||||
->will($this->returnValue(true));
|
||||
$s->expects($this->once())
|
||||
->method('isSeekable')
|
||||
->will($this->returnValue(true));
|
||||
$s->expects($this->once())
|
||||
->method('seek')
|
||||
->will($this->returnValue(false));
|
||||
$a->addStream($s);
|
||||
$this->assertFalse($a->seek(10));
|
||||
}
|
||||
|
||||
public function testSeeksToPositionByReading()
|
||||
{
|
||||
$a = new AppendStream([
|
||||
Stream::factory('foo'),
|
||||
Stream::factory('bar'),
|
||||
Stream::factory('baz'),
|
||||
]);
|
||||
|
||||
$this->assertTrue($a->seek(3));
|
||||
$this->assertEquals(3, $a->tell());
|
||||
$this->assertEquals('bar', $a->read(3));
|
||||
$a->seek(6);
|
||||
$this->assertEquals(6, $a->tell());
|
||||
$this->assertEquals('baz', $a->read(3));
|
||||
}
|
||||
|
||||
public function testDetachesEachStream()
|
||||
{
|
||||
$s1 = Stream::factory('foo');
|
||||
$s2 = Stream::factory('foo');
|
||||
$a = new AppendStream([$s1, $s2]);
|
||||
$this->assertSame('foofoo', (string) $a);
|
||||
$a->detach();
|
||||
$this->assertSame('', (string) $a);
|
||||
$this->assertSame(0, $a->getSize());
|
||||
}
|
||||
|
||||
public function testClosesEachStream()
|
||||
{
|
||||
$s1 = Stream::factory('foo');
|
||||
$a = new AppendStream([$s1]);
|
||||
$a->close();
|
||||
$this->assertSame('', (string) $a);
|
||||
}
|
||||
|
||||
public function testIsNotWritable()
|
||||
{
|
||||
$a = new AppendStream([Stream::factory('foo')]);
|
||||
$this->assertFalse($a->isWritable());
|
||||
$this->assertTrue($a->isSeekable());
|
||||
$this->assertTrue($a->isReadable());
|
||||
$this->assertFalse($a->write('foo'));
|
||||
}
|
||||
|
||||
public function testDoesNotNeedStreams()
|
||||
{
|
||||
$a = new AppendStream();
|
||||
$this->assertEquals('', (string) $a);
|
||||
}
|
||||
|
||||
public function testCanReadFromMultipleStreams()
|
||||
{
|
||||
$a = new AppendStream([
|
||||
Stream::factory('foo'),
|
||||
Stream::factory('bar'),
|
||||
Stream::factory('baz'),
|
||||
]);
|
||||
$this->assertFalse($a->eof());
|
||||
$this->assertSame(0, $a->tell());
|
||||
$this->assertEquals('foo', $a->read(3));
|
||||
$this->assertEquals('bar', $a->read(3));
|
||||
$this->assertEquals('baz', $a->read(3));
|
||||
$this->assertTrue($a->eof());
|
||||
$this->assertSame(9, $a->tell());
|
||||
$this->assertEquals('foobarbaz', (string) $a);
|
||||
}
|
||||
|
||||
public function testCanDetermineSizeFromMultipleStreams()
|
||||
{
|
||||
$a = new AppendStream([
|
||||
Stream::factory('foo'),
|
||||
Stream::factory('bar')
|
||||
]);
|
||||
$this->assertEquals(6, $a->getSize());
|
||||
|
||||
$s = $this->getMockBuilder('GuzzleHttp\Stream\StreamInterface')
|
||||
->setMethods(['isSeekable', 'isReadable'])
|
||||
->getMockForAbstractClass();
|
||||
$s->expects($this->once())
|
||||
->method('isSeekable')
|
||||
->will($this->returnValue(null));
|
||||
$s->expects($this->once())
|
||||
->method('isReadable')
|
||||
->will($this->returnValue(true));
|
||||
$a->addStream($s);
|
||||
$this->assertNull($a->getSize());
|
||||
}
|
||||
|
||||
public function testCatchesExceptionsWhenCastingToString()
|
||||
{
|
||||
$s = $this->getMockBuilder('GuzzleHttp\Stream\StreamInterface')
|
||||
->setMethods(['read', 'isReadable', 'eof'])
|
||||
->getMockForAbstractClass();
|
||||
$s->expects($this->once())
|
||||
->method('read')
|
||||
->will($this->throwException(new \RuntimeException('foo')));
|
||||
$s->expects($this->once())
|
||||
->method('isReadable')
|
||||
->will($this->returnValue(true));
|
||||
$s->expects($this->any())
|
||||
->method('eof')
|
||||
->will($this->returnValue(false));
|
||||
$a = new AppendStream([$s]);
|
||||
$this->assertFalse($a->eof());
|
||||
$this->assertSame('', (string) $a);
|
||||
}
|
||||
|
||||
public function testCanDetach()
|
||||
{
|
||||
$s = new AppendStream();
|
||||
$s->detach();
|
||||
}
|
||||
|
||||
public function testReturnsEmptyMetadata()
|
||||
{
|
||||
$s = new AppendStream();
|
||||
$this->assertEquals([], $s->getMetadata());
|
||||
$this->assertNull($s->getMetadata('foo'));
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \GuzzleHttp\Stream\Exception\CannotAttachException
|
||||
*/
|
||||
public function testCannotAttach()
|
||||
{
|
||||
$p = new AppendStream();
|
||||
$p->attach('a');
|
||||
}
|
||||
}
|
||||
186
core/vendor/guzzlehttp/streams/tests/AsyncReadStreamTest.php
vendored
Normal file
186
core/vendor/guzzlehttp/streams/tests/AsyncReadStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,186 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\AsyncReadStream;
|
||||
use GuzzleHttp\Stream\BufferStream;
|
||||
use GuzzleHttp\Stream\FnStream;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
|
||||
class AsyncReadStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
/**
|
||||
* @expectedException \InvalidArgumentException
|
||||
* @expectedExceptionMessage Buffer must be readable and writable
|
||||
*/
|
||||
public function testValidatesReadableBuffer()
|
||||
{
|
||||
new AsyncReadStream(FnStream::decorate(
|
||||
Stream::factory(),
|
||||
['isReadable' => function () { return false; }]
|
||||
));
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \InvalidArgumentException
|
||||
* @expectedExceptionMessage Buffer must be readable and writable
|
||||
*/
|
||||
public function testValidatesWritableBuffer()
|
||||
{
|
||||
new AsyncReadStream(FnStream::decorate(
|
||||
Stream::factory(),
|
||||
['isWritable' => function () { return false; }]
|
||||
));
|
||||
}
|
||||
|
||||
public function testValidatesHwmMetadata()
|
||||
{
|
||||
$a = new AsyncReadStream(Stream::factory(), [
|
||||
'drain' => function() {}
|
||||
]);
|
||||
$this->assertNull($this->readAttribute($a, 'drain'));
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \InvalidArgumentException
|
||||
* @expectedExceptionMessage pump must be callable
|
||||
*/
|
||||
public function testValidatesPumpIsCallable()
|
||||
{
|
||||
new AsyncReadStream(new BufferStream(), ['pump' => true]);
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \InvalidArgumentException
|
||||
* @expectedExceptionMessage drain must be callable
|
||||
*/
|
||||
public function testValidatesDrainIsCallable()
|
||||
{
|
||||
new AsyncReadStream(new BufferStream(), ['drain' => true]);
|
||||
}
|
||||
|
||||
public function testCanInitialize()
|
||||
{
|
||||
$buffer = new BufferStream();
|
||||
$a = new AsyncReadStream($buffer, [
|
||||
'size' => 10,
|
||||
'drain' => function () {},
|
||||
'pump' => function () {},
|
||||
]);
|
||||
$this->assertSame($buffer, $this->readAttribute($a, 'stream'));
|
||||
$this->assertTrue(is_callable($this->readAttribute($a, 'drain')));
|
||||
$this->assertTrue(is_callable($this->readAttribute($a, 'pump')));
|
||||
$this->assertTrue($a->isReadable());
|
||||
$this->assertFalse($a->isSeekable());
|
||||
$this->assertFalse($a->isWritable());
|
||||
$this->assertFalse($a->write('foo'));
|
||||
$this->assertEquals(10, $a->getSize());
|
||||
}
|
||||
|
||||
public function testReadsFromBufferWithNoDrainOrPump()
|
||||
{
|
||||
$buffer = new BufferStream();
|
||||
$a = new AsyncReadStream($buffer);
|
||||
$buffer->write('foo');
|
||||
$this->assertNull($a->getSize());
|
||||
$this->assertEquals('foo', $a->read(10));
|
||||
$this->assertEquals('', $a->read(10));
|
||||
}
|
||||
|
||||
public function testCallsPumpForMoreDataWhenRequested()
|
||||
{
|
||||
$called = 0;
|
||||
$buffer = new BufferStream();
|
||||
$a = new AsyncReadStream($buffer, [
|
||||
'pump' => function ($size) use (&$called) {
|
||||
$called++;
|
||||
return str_repeat('.', $size);
|
||||
}
|
||||
]);
|
||||
$buffer->write('foobar');
|
||||
$this->assertEquals('foo', $a->read(3));
|
||||
$this->assertEquals(0, $called);
|
||||
$this->assertEquals('bar.....', $a->read(8));
|
||||
$this->assertEquals(1, $called);
|
||||
$this->assertEquals('..', $a->read(2));
|
||||
$this->assertEquals(2, $called);
|
||||
}
|
||||
|
||||
public function testCallsDrainWhenNeeded()
|
||||
{
|
||||
$called = 0;
|
||||
$buffer = new BufferStream(5);
|
||||
$a = new AsyncReadStream($buffer, [
|
||||
'drain' => function (BufferStream $b) use (&$called, $buffer) {
|
||||
$this->assertSame($b, $buffer);
|
||||
$called++;
|
||||
}
|
||||
]);
|
||||
|
||||
$buffer->write('foobar');
|
||||
$this->assertEquals(6, $buffer->getSize());
|
||||
$this->assertEquals(0, $called);
|
||||
|
||||
$a->read(3);
|
||||
$this->assertTrue($this->readAttribute($a, 'needsDrain'));
|
||||
$this->assertEquals(3, $buffer->getSize());
|
||||
$this->assertEquals(0, $called);
|
||||
|
||||
$a->read(3);
|
||||
$this->assertEquals(0, $buffer->getSize());
|
||||
$this->assertFalse($this->readAttribute($a, 'needsDrain'));
|
||||
$this->assertEquals(1, $called);
|
||||
}
|
||||
|
||||
public function testCreatesBufferWithNoConfig()
|
||||
{
|
||||
list($buffer, $async) = AsyncReadStream::create();
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\BufferStream', $buffer);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\AsyncReadStream', $async);
|
||||
}
|
||||
|
||||
public function testCreatesBufferWithSpecifiedBuffer()
|
||||
{
|
||||
$buf = new BufferStream();
|
||||
list($buffer, $async) = AsyncReadStream::create(['buffer' => $buf]);
|
||||
$this->assertSame($buf, $buffer);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\AsyncReadStream', $async);
|
||||
}
|
||||
|
||||
public function testCreatesNullStream()
|
||||
{
|
||||
list($buffer, $async) = AsyncReadStream::create(['max_buffer' => 0]);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\NullStream', $buffer);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\AsyncReadStream', $async);
|
||||
}
|
||||
|
||||
public function testCreatesDroppingStream()
|
||||
{
|
||||
list($buffer, $async) = AsyncReadStream::create(['max_buffer' => 5]);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\DroppingStream', $buffer);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\AsyncReadStream', $async);
|
||||
$buffer->write('12345678910');
|
||||
$this->assertEquals(5, $buffer->getSize());
|
||||
}
|
||||
|
||||
public function testCreatesOnWriteStream()
|
||||
{
|
||||
$c = 0;
|
||||
$b = new BufferStream();
|
||||
list($buffer, $async) = AsyncReadStream::create([
|
||||
'buffer' => $b,
|
||||
'write' => function (BufferStream $buf, $data) use (&$c, $b) {
|
||||
$this->assertSame($buf, $b);
|
||||
$this->assertEquals('foo', $data);
|
||||
$c++;
|
||||
}
|
||||
]);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\FnStream', $buffer);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\AsyncReadStream', $async);
|
||||
$this->assertEquals(0, $c);
|
||||
$this->assertEquals(3, $buffer->write('foo'));
|
||||
$this->assertEquals(1, $c);
|
||||
$this->assertEquals(3, $buffer->write('foo'));
|
||||
$this->assertEquals(2, $c);
|
||||
$this->assertEquals('foofoo', (string) $buffer);
|
||||
}
|
||||
}
|
||||
69
core/vendor/guzzlehttp/streams/tests/BufferStreamTest.php
vendored
Normal file
69
core/vendor/guzzlehttp/streams/tests/BufferStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\BufferStream;
|
||||
|
||||
class BufferStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testHasMetadata()
|
||||
{
|
||||
$b = new BufferStream(10);
|
||||
$this->assertTrue($b->isReadable());
|
||||
$this->assertTrue($b->isWritable());
|
||||
$this->assertFalse($b->isSeekable());
|
||||
$this->assertEquals(null, $b->getMetadata('foo'));
|
||||
$this->assertEquals(10, $b->getMetadata('hwm'));
|
||||
$this->assertEquals([], $b->getMetadata());
|
||||
}
|
||||
|
||||
public function testRemovesReadDataFromBuffer()
|
||||
{
|
||||
$b = new BufferStream();
|
||||
$this->assertEquals(3, $b->write('foo'));
|
||||
$this->assertEquals(3, $b->getSize());
|
||||
$this->assertFalse($b->eof());
|
||||
$this->assertEquals('foo', $b->read(10));
|
||||
$this->assertTrue($b->eof());
|
||||
$this->assertEquals('', $b->read(10));
|
||||
}
|
||||
|
||||
public function testCanCastToStringOrGetContents()
|
||||
{
|
||||
$b = new BufferStream();
|
||||
$b->write('foo');
|
||||
$b->write('baz');
|
||||
$this->assertEquals('foo', $b->read(3));
|
||||
$b->write('bar');
|
||||
$this->assertEquals('bazbar', (string) $b);
|
||||
$this->assertFalse($b->tell());
|
||||
}
|
||||
|
||||
public function testDetachClearsBuffer()
|
||||
{
|
||||
$b = new BufferStream();
|
||||
$b->write('foo');
|
||||
$b->detach();
|
||||
$this->assertEquals(0, $b->tell());
|
||||
$this->assertTrue($b->eof());
|
||||
$this->assertEquals(3, $b->write('abc'));
|
||||
$this->assertEquals('abc', $b->read(10));
|
||||
}
|
||||
|
||||
public function testExceedingHighwaterMarkReturnsFalseButStillBuffers()
|
||||
{
|
||||
$b = new BufferStream(5);
|
||||
$this->assertEquals(3, $b->write('hi '));
|
||||
$this->assertFalse($b->write('hello'));
|
||||
$this->assertEquals('hi hello', (string) $b);
|
||||
$this->assertEquals(4, $b->write('test'));
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \GuzzleHttp\Stream\Exception\CannotAttachException
|
||||
*/
|
||||
public function testCannotAttach()
|
||||
{
|
||||
$p = new BufferStream();
|
||||
$p->attach('a');
|
||||
}
|
||||
}
|
||||
136
core/vendor/guzzlehttp/streams/tests/CachingStreamTest.php
vendored
Normal file
136
core/vendor/guzzlehttp/streams/tests/CachingStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,136 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
use GuzzleHttp\Stream\CachingStream;
|
||||
use GuzzleHttp\Stream\Utils;
|
||||
|
||||
/**
|
||||
* @covers GuzzleHttp\Stream\CachingStream
|
||||
*/
|
||||
class CachingStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
/** @var CachingStream */
|
||||
protected $body;
|
||||
|
||||
/** @var Stream */
|
||||
protected $decorated;
|
||||
|
||||
public function setUp()
|
||||
{
|
||||
$this->decorated = Stream::factory('testing');
|
||||
$this->body = new CachingStream($this->decorated);
|
||||
}
|
||||
|
||||
public function tearDown()
|
||||
{
|
||||
$this->decorated->close();
|
||||
$this->body->close();
|
||||
}
|
||||
|
||||
public function testUsesRemoteSizeIfPossible()
|
||||
{
|
||||
$body = Stream::factory('test');
|
||||
$caching = new CachingStream($body);
|
||||
$this->assertEquals(4, $caching->getSize());
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \RuntimeException
|
||||
* @expectedExceptionMessage Cannot seek to byte 10
|
||||
*/
|
||||
public function testCannotSeekPastWhatHasBeenRead()
|
||||
{
|
||||
$this->body->seek(10);
|
||||
}
|
||||
|
||||
public function testCannotUseSeekEnd()
|
||||
{
|
||||
$this->assertFalse($this->body->seek(2, SEEK_END));
|
||||
}
|
||||
|
||||
public function testRewindUsesSeek()
|
||||
{
|
||||
$a = Stream::factory('foo');
|
||||
$d = $this->getMockBuilder('GuzzleHttp\Stream\CachingStream')
|
||||
->setMethods(array('seek'))
|
||||
->setConstructorArgs(array($a))
|
||||
->getMock();
|
||||
$d->expects($this->once())
|
||||
->method('seek')
|
||||
->with(0)
|
||||
->will($this->returnValue(true));
|
||||
$d->seek(0);
|
||||
}
|
||||
|
||||
public function testCanSeekToReadBytes()
|
||||
{
|
||||
$this->assertEquals('te', $this->body->read(2));
|
||||
$this->body->seek(0);
|
||||
$this->assertEquals('test', $this->body->read(4));
|
||||
$this->assertEquals(4, $this->body->tell());
|
||||
$this->body->seek(2);
|
||||
$this->assertEquals(2, $this->body->tell());
|
||||
$this->body->seek(2, SEEK_CUR);
|
||||
$this->assertEquals(4, $this->body->tell());
|
||||
$this->assertEquals('ing', $this->body->read(3));
|
||||
}
|
||||
|
||||
public function testWritesToBufferStream()
|
||||
{
|
||||
$this->body->read(2);
|
||||
$this->body->write('hi');
|
||||
$this->body->seek(0);
|
||||
$this->assertEquals('tehiing', (string) $this->body);
|
||||
}
|
||||
|
||||
public function testSkipsOverwrittenBytes()
|
||||
{
|
||||
$decorated = Stream::factory(
|
||||
implode("\n", array_map(function ($n) {
|
||||
return str_pad($n, 4, '0', STR_PAD_LEFT);
|
||||
}, range(0, 25)))
|
||||
);
|
||||
|
||||
$body = new CachingStream($decorated);
|
||||
|
||||
$this->assertEquals("0000\n", Utils::readline($body));
|
||||
$this->assertEquals("0001\n", Utils::readline($body));
|
||||
// Write over part of the body yet to be read, so skip some bytes
|
||||
$this->assertEquals(5, $body->write("TEST\n"));
|
||||
$this->assertEquals(5, $this->readAttribute($body, 'skipReadBytes'));
|
||||
// Read, which skips bytes, then reads
|
||||
$this->assertEquals("0003\n", Utils::readline($body));
|
||||
$this->assertEquals(0, $this->readAttribute($body, 'skipReadBytes'));
|
||||
$this->assertEquals("0004\n", Utils::readline($body));
|
||||
$this->assertEquals("0005\n", Utils::readline($body));
|
||||
|
||||
// Overwrite part of the cached body (so don't skip any bytes)
|
||||
$body->seek(5);
|
||||
$this->assertEquals(5, $body->write("ABCD\n"));
|
||||
$this->assertEquals(0, $this->readAttribute($body, 'skipReadBytes'));
|
||||
$this->assertEquals("TEST\n", Utils::readline($body));
|
||||
$this->assertEquals("0003\n", Utils::readline($body));
|
||||
$this->assertEquals("0004\n", Utils::readline($body));
|
||||
$this->assertEquals("0005\n", Utils::readline($body));
|
||||
$this->assertEquals("0006\n", Utils::readline($body));
|
||||
$this->assertEquals(5, $body->write("1234\n"));
|
||||
$this->assertEquals(5, $this->readAttribute($body, 'skipReadBytes'));
|
||||
|
||||
// Seek to 0 and ensure the overwritten bit is replaced
|
||||
$body->seek(0);
|
||||
$this->assertEquals("0000\nABCD\nTEST\n0003\n0004\n0005\n0006\n1234\n0008\n0009\n", $body->read(50));
|
||||
|
||||
// Ensure that casting it to a string does not include the bit that was overwritten
|
||||
$this->assertContains("0000\nABCD\nTEST\n0003\n0004\n0005\n0006\n1234\n0008\n0009\n", (string) $body);
|
||||
}
|
||||
|
||||
public function testClosesBothStreams()
|
||||
{
|
||||
$s = fopen('php://temp', 'r');
|
||||
$a = Stream::factory($s);
|
||||
$d = new CachingStream($a);
|
||||
$d->close();
|
||||
$this->assertFalse(is_resource($s));
|
||||
}
|
||||
}
|
||||
26
core/vendor/guzzlehttp/streams/tests/DroppingStreamTest.php
vendored
Normal file
26
core/vendor/guzzlehttp/streams/tests/DroppingStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\BufferStream;
|
||||
use GuzzleHttp\Stream\DroppingStream;
|
||||
|
||||
class DroppingStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testBeginsDroppingWhenSizeExceeded()
|
||||
{
|
||||
$stream = new BufferStream();
|
||||
$drop = new DroppingStream($stream, 5);
|
||||
$this->assertEquals(3, $drop->write('hel'));
|
||||
$this->assertFalse($drop->write('lo'));
|
||||
$this->assertEquals(5, $drop->getSize());
|
||||
$this->assertEquals('hello', $drop->read(5));
|
||||
$this->assertEquals(0, $drop->getSize());
|
||||
$drop->write('12345678910');
|
||||
$this->assertEquals(5, $stream->getSize());
|
||||
$this->assertEquals(5, $drop->getSize());
|
||||
$this->assertEquals('12345', (string) $drop);
|
||||
$this->assertEquals(0, $drop->getSize());
|
||||
$drop->write('hello');
|
||||
$this->assertFalse($drop->write('test'));
|
||||
}
|
||||
}
|
||||
16
core/vendor/guzzlehttp/streams/tests/Exception/SeekExceptionTest.php
vendored
Normal file
16
core/vendor/guzzlehttp/streams/tests/Exception/SeekExceptionTest.php
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream\Exception;
|
||||
|
||||
use GuzzleHttp\Stream\Exception\SeekException;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
|
||||
class SeekExceptionTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testHasStream()
|
||||
{
|
||||
$s = Stream::factory('foo');
|
||||
$e = new SeekException($s, 10);
|
||||
$this->assertSame($s, $e->getStream());
|
||||
$this->assertContains('10', $e->getMessage());
|
||||
}
|
||||
}
|
||||
89
core/vendor/guzzlehttp/streams/tests/FnStreamTest.php
vendored
Normal file
89
core/vendor/guzzlehttp/streams/tests/FnStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
use GuzzleHttp\Stream\FnStream;
|
||||
|
||||
/**
|
||||
* @covers GuzzleHttp\Stream\FnStream
|
||||
*/
|
||||
class FnStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
/**
|
||||
* @expectedException \BadMethodCallException
|
||||
* @expectedExceptionMessage seek() is not implemented in the FnStream
|
||||
*/
|
||||
public function testThrowsWhenNotImplemented()
|
||||
{
|
||||
(new FnStream([]))->seek(1);
|
||||
}
|
||||
|
||||
public function testProxiesToFunction()
|
||||
{
|
||||
$s = new FnStream([
|
||||
'read' => function ($len) {
|
||||
$this->assertEquals(3, $len);
|
||||
return 'foo';
|
||||
}
|
||||
]);
|
||||
|
||||
$this->assertEquals('foo', $s->read(3));
|
||||
}
|
||||
|
||||
public function testCanCloseOnDestruct()
|
||||
{
|
||||
$called = false;
|
||||
$s = new FnStream([
|
||||
'close' => function () use (&$called) {
|
||||
$called = true;
|
||||
}
|
||||
]);
|
||||
unset($s);
|
||||
$this->assertTrue($called);
|
||||
}
|
||||
|
||||
public function testDoesNotRequireClose()
|
||||
{
|
||||
$s = new FnStream([]);
|
||||
unset($s);
|
||||
}
|
||||
|
||||
public function testDecoratesStream()
|
||||
{
|
||||
$a = Stream::factory('foo');
|
||||
$b = FnStream::decorate($a, []);
|
||||
$this->assertEquals(3, $b->getSize());
|
||||
$this->assertEquals($b->isWritable(), true);
|
||||
$this->assertEquals($b->isReadable(), true);
|
||||
$this->assertEquals($b->isSeekable(), true);
|
||||
$this->assertEquals($b->read(3), 'foo');
|
||||
$this->assertEquals($b->tell(), 3);
|
||||
$this->assertEquals($a->tell(), 3);
|
||||
$this->assertEquals($b->eof(), true);
|
||||
$this->assertEquals($a->eof(), true);
|
||||
$b->seek(0);
|
||||
$this->assertEquals('foo', (string) $b);
|
||||
$b->seek(0);
|
||||
$this->assertEquals('foo', $b->getContents());
|
||||
$this->assertEquals($a->getMetadata(), $b->getMetadata());
|
||||
$b->seek(0, SEEK_END);
|
||||
$b->write('bar');
|
||||
$this->assertEquals('foobar', (string) $b);
|
||||
$this->assertInternalType('resource', $b->detach());
|
||||
$b->close();
|
||||
}
|
||||
|
||||
public function testDecoratesWithCustomizations()
|
||||
{
|
||||
$called = false;
|
||||
$a = Stream::factory('foo');
|
||||
$b = FnStream::decorate($a, [
|
||||
'read' => function ($len) use (&$called, $a) {
|
||||
$called = true;
|
||||
return $a->read($len);
|
||||
}
|
||||
]);
|
||||
$this->assertEquals('foo', $b->read(3));
|
||||
$this->assertTrue($called);
|
||||
}
|
||||
}
|
||||
99
core/vendor/guzzlehttp/streams/tests/GuzzleStreamWrapperTest.php
vendored
Normal file
99
core/vendor/guzzlehttp/streams/tests/GuzzleStreamWrapperTest.php
vendored
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\GuzzleStreamWrapper;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
|
||||
/**
|
||||
* @covers GuzzleHttp\Stream\GuzzleStreamWrapper
|
||||
*/
|
||||
class GuzzleStreamWrapperTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testResource()
|
||||
{
|
||||
$stream = Stream::factory('foo');
|
||||
$handle = GuzzleStreamWrapper::getResource($stream);
|
||||
$this->assertSame('foo', fread($handle, 3));
|
||||
$this->assertSame(3, ftell($handle));
|
||||
$this->assertSame(3, fwrite($handle, 'bar'));
|
||||
$this->assertSame(0, fseek($handle, 0));
|
||||
$this->assertSame('foobar', fread($handle, 6));
|
||||
$this->assertTrue(feof($handle));
|
||||
|
||||
// This fails on HHVM for some reason
|
||||
if (!defined('HHVM_VERSION')) {
|
||||
$this->assertEquals([
|
||||
'dev' => 0,
|
||||
'ino' => 0,
|
||||
'mode' => 33206,
|
||||
'nlink' => 0,
|
||||
'uid' => 0,
|
||||
'gid' => 0,
|
||||
'rdev' => 0,
|
||||
'size' => 6,
|
||||
'atime' => 0,
|
||||
'mtime' => 0,
|
||||
'ctime' => 0,
|
||||
'blksize' => 0,
|
||||
'blocks' => 0,
|
||||
0 => 0,
|
||||
1 => 0,
|
||||
2 => 33206,
|
||||
3 => 0,
|
||||
4 => 0,
|
||||
5 => 0,
|
||||
6 => 0,
|
||||
7 => 6,
|
||||
8 => 0,
|
||||
9 => 0,
|
||||
10 => 0,
|
||||
11 => 0,
|
||||
12 => 0,
|
||||
], fstat($handle));
|
||||
}
|
||||
|
||||
$this->assertTrue(fclose($handle));
|
||||
$this->assertSame('foobar', (string) $stream);
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \InvalidArgumentException
|
||||
*/
|
||||
public function testValidatesStream()
|
||||
{
|
||||
$stream = $this->getMockBuilder('GuzzleHttp\Stream\StreamInterface')
|
||||
->setMethods(['isReadable', 'isWritable'])
|
||||
->getMockForAbstractClass();
|
||||
$stream->expects($this->once())
|
||||
->method('isReadable')
|
||||
->will($this->returnValue(false));
|
||||
$stream->expects($this->once())
|
||||
->method('isWritable')
|
||||
->will($this->returnValue(false));
|
||||
GuzzleStreamWrapper::getResource($stream);
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \PHPUnit_Framework_Error_Warning
|
||||
*/
|
||||
public function testReturnsFalseWhenStreamDoesNotExist()
|
||||
{
|
||||
fopen('guzzle://foo', 'r');
|
||||
}
|
||||
|
||||
public function testCanOpenReadonlyStream()
|
||||
{
|
||||
$stream = $this->getMockBuilder('GuzzleHttp\Stream\StreamInterface')
|
||||
->setMethods(['isReadable', 'isWritable'])
|
||||
->getMockForAbstractClass();
|
||||
$stream->expects($this->once())
|
||||
->method('isReadable')
|
||||
->will($this->returnValue(false));
|
||||
$stream->expects($this->once())
|
||||
->method('isWritable')
|
||||
->will($this->returnValue(true));
|
||||
$r = GuzzleStreamWrapper::getResource($stream);
|
||||
$this->assertInternalType('resource', $r);
|
||||
fclose($r);
|
||||
}
|
||||
}
|
||||
16
core/vendor/guzzlehttp/streams/tests/InflateStreamTest.php
vendored
Normal file
16
core/vendor/guzzlehttp/streams/tests/InflateStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\InflateStream;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
|
||||
class InflateStreamtest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testInflatesStreams()
|
||||
{
|
||||
$content = gzencode('test');
|
||||
$a = Stream::factory($content);
|
||||
$b = new InflateStream($a);
|
||||
$this->assertEquals('test', (string) $b);
|
||||
}
|
||||
}
|
||||
64
core/vendor/guzzlehttp/streams/tests/LazyOpenStreamTest.php
vendored
Normal file
64
core/vendor/guzzlehttp/streams/tests/LazyOpenStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\LazyOpenStream;
|
||||
|
||||
class LazyOpenStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
private $fname;
|
||||
|
||||
public function setup()
|
||||
{
|
||||
$this->fname = tempnam('/tmp', 'tfile');
|
||||
|
||||
if (file_exists($this->fname)) {
|
||||
unlink($this->fname);
|
||||
}
|
||||
}
|
||||
|
||||
public function tearDown()
|
||||
{
|
||||
if (file_exists($this->fname)) {
|
||||
unlink($this->fname);
|
||||
}
|
||||
}
|
||||
|
||||
public function testOpensLazily()
|
||||
{
|
||||
$l = new LazyOpenStream($this->fname, 'w+');
|
||||
$l->write('foo');
|
||||
$this->assertInternalType('array', $l->getMetadata());
|
||||
$this->assertFileExists($this->fname);
|
||||
$this->assertEquals('foo', file_get_contents($this->fname));
|
||||
$this->assertEquals('foo', (string) $l);
|
||||
}
|
||||
|
||||
public function testProxiesToFile()
|
||||
{
|
||||
file_put_contents($this->fname, 'foo');
|
||||
$l = new LazyOpenStream($this->fname, 'r');
|
||||
$this->assertEquals('foo', $l->read(4));
|
||||
$this->assertTrue($l->eof());
|
||||
$this->assertEquals(3, $l->tell());
|
||||
$this->assertTrue($l->isReadable());
|
||||
$this->assertTrue($l->isSeekable());
|
||||
$this->assertFalse($l->isWritable());
|
||||
$l->seek(1);
|
||||
$this->assertEquals('oo', $l->getContents());
|
||||
$this->assertEquals('foo', (string) $l);
|
||||
$this->assertEquals(3, $l->getSize());
|
||||
$this->assertInternalType('array', $l->getMetadata());
|
||||
$l->close();
|
||||
}
|
||||
|
||||
public function testDetachesUnderlyingStream()
|
||||
{
|
||||
file_put_contents($this->fname, 'foo');
|
||||
$l = new LazyOpenStream($this->fname, 'r');
|
||||
$r = $l->detach();
|
||||
$this->assertInternalType('resource', $r);
|
||||
fseek($r, 0);
|
||||
$this->assertEquals('foo', stream_get_contents($r));
|
||||
fclose($r);
|
||||
}
|
||||
}
|
||||
133
core/vendor/guzzlehttp/streams/tests/LimitStreamTest.php
vendored
Normal file
133
core/vendor/guzzlehttp/streams/tests/LimitStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Http;
|
||||
|
||||
use GuzzleHttp\Stream\FnStream;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
use GuzzleHttp\Stream\LimitStream;
|
||||
use GuzzleHttp\Stream\NoSeekStream;
|
||||
|
||||
/**
|
||||
* @covers GuzzleHttp\Stream\LimitStream
|
||||
*/
|
||||
class LimitStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
/** @var LimitStream */
|
||||
protected $body;
|
||||
|
||||
/** @var Stream */
|
||||
protected $decorated;
|
||||
|
||||
public function setUp()
|
||||
{
|
||||
$this->decorated = Stream::factory(fopen(__FILE__, 'r'));
|
||||
$this->body = new LimitStream($this->decorated, 10, 3);
|
||||
}
|
||||
|
||||
public function testReturnsSubset()
|
||||
{
|
||||
$body = new LimitStream(Stream::factory('foo'), -1, 1);
|
||||
$this->assertEquals('oo', (string) $body);
|
||||
$this->assertTrue($body->eof());
|
||||
$body->seek(0);
|
||||
$this->assertFalse($body->eof());
|
||||
$this->assertEquals('oo', $body->read(100));
|
||||
$this->assertTrue($body->eof());
|
||||
}
|
||||
|
||||
public function testReturnsSubsetWhenCastToString()
|
||||
{
|
||||
$body = Stream::factory('foo_baz_bar');
|
||||
$limited = new LimitStream($body, 3, 4);
|
||||
$this->assertEquals('baz', (string) $limited);
|
||||
}
|
||||
|
||||
public function testReturnsSubsetOfEmptyBodyWhenCastToString()
|
||||
{
|
||||
$body = Stream::factory('');
|
||||
$limited = new LimitStream($body, 0, 10);
|
||||
$this->assertEquals('', (string) $limited);
|
||||
}
|
||||
|
||||
public function testSeeksWhenConstructed()
|
||||
{
|
||||
$this->assertEquals(0, $this->body->tell());
|
||||
$this->assertEquals(3, $this->decorated->tell());
|
||||
}
|
||||
|
||||
public function testAllowsBoundedSeek()
|
||||
{
|
||||
$this->assertEquals(true, $this->body->seek(100));
|
||||
$this->assertEquals(10, $this->body->tell());
|
||||
$this->assertEquals(13, $this->decorated->tell());
|
||||
$this->assertEquals(true, $this->body->seek(0));
|
||||
$this->assertEquals(0, $this->body->tell());
|
||||
$this->assertEquals(3, $this->decorated->tell());
|
||||
$this->assertEquals(false, $this->body->seek(-10));
|
||||
$this->assertEquals(0, $this->body->tell());
|
||||
$this->assertEquals(3, $this->decorated->tell());
|
||||
$this->assertEquals(true, $this->body->seek(5));
|
||||
$this->assertEquals(5, $this->body->tell());
|
||||
$this->assertEquals(8, $this->decorated->tell());
|
||||
$this->assertEquals(false, $this->body->seek(1000, SEEK_END));
|
||||
}
|
||||
|
||||
public function testReadsOnlySubsetOfData()
|
||||
{
|
||||
$data = $this->body->read(100);
|
||||
$this->assertEquals(10, strlen($data));
|
||||
$this->assertFalse($this->body->read(1000));
|
||||
|
||||
$this->body->setOffset(10);
|
||||
$newData = $this->body->read(100);
|
||||
$this->assertEquals(10, strlen($newData));
|
||||
$this->assertNotSame($data, $newData);
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \GuzzleHttp\Stream\Exception\SeekException
|
||||
* @expectedExceptionMessage Could not seek the stream to position 2
|
||||
*/
|
||||
public function testThrowsWhenCurrentGreaterThanOffsetSeek()
|
||||
{
|
||||
$a = Stream::factory('foo_bar');
|
||||
$b = new NoSeekStream($a);
|
||||
$c = new LimitStream($b);
|
||||
$a->getContents();
|
||||
$c->setOffset(2);
|
||||
}
|
||||
|
||||
public function testClaimsConsumedWhenReadLimitIsReached()
|
||||
{
|
||||
$this->assertFalse($this->body->eof());
|
||||
$this->body->read(1000);
|
||||
$this->assertTrue($this->body->eof());
|
||||
}
|
||||
|
||||
public function testContentLengthIsBounded()
|
||||
{
|
||||
$this->assertEquals(10, $this->body->getSize());
|
||||
}
|
||||
|
||||
public function testGetContentsIsBasedOnSubset()
|
||||
{
|
||||
$body = new LimitStream(Stream::factory('foobazbar'), 3, 3);
|
||||
$this->assertEquals('baz', $body->getContents());
|
||||
}
|
||||
|
||||
public function testReturnsNullIfSizeCannotBeDetermined()
|
||||
{
|
||||
$a = new FnStream([
|
||||
'getSize' => function () { return null; },
|
||||
'tell' => function () { return 0; },
|
||||
]);
|
||||
$b = new LimitStream($a);
|
||||
$this->assertNull($b->getSize());
|
||||
}
|
||||
|
||||
public function testLengthLessOffsetWhenNoLimitSize()
|
||||
{
|
||||
$a = Stream::factory('foo_bar');
|
||||
$b = new LimitStream($a, -1, 4);
|
||||
$this->assertEquals(3, $b->getSize());
|
||||
}
|
||||
}
|
||||
41
core/vendor/guzzlehttp/streams/tests/NoSeekStreamTest.php
vendored
Normal file
41
core/vendor/guzzlehttp/streams/tests/NoSeekStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
use GuzzleHttp\Stream\NoSeekStream;
|
||||
|
||||
/**
|
||||
* @covers GuzzleHttp\Stream\NoSeekStream
|
||||
* @covers GuzzleHttp\Stream\StreamDecoratorTrait
|
||||
*/
|
||||
class NoSeekStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testCannotSeek()
|
||||
{
|
||||
$s = $this->getMockBuilder('GuzzleHttp\Stream\StreamInterface')
|
||||
->setMethods(['isSeekable', 'seek'])
|
||||
->getMockForAbstractClass();
|
||||
$s->expects($this->never())->method('seek');
|
||||
$s->expects($this->never())->method('isSeekable');
|
||||
$wrapped = new NoSeekStream($s);
|
||||
$this->assertFalse($wrapped->isSeekable());
|
||||
$this->assertFalse($wrapped->seek(2));
|
||||
}
|
||||
|
||||
public function testHandlesClose()
|
||||
{
|
||||
$s = Stream::factory('foo');
|
||||
$wrapped = new NoSeekStream($s);
|
||||
$wrapped->close();
|
||||
$this->assertFalse($wrapped->write('foo'));
|
||||
}
|
||||
|
||||
public function testCanAttach()
|
||||
{
|
||||
$s1 = Stream::factory('foo');
|
||||
$s2 = Stream::factory('bar');
|
||||
$wrapped = new NoSeekStream($s1);
|
||||
$wrapped->attach($s2->detach());
|
||||
$this->assertEquals('bar', (string) $wrapped);
|
||||
}
|
||||
}
|
||||
39
core/vendor/guzzlehttp/streams/tests/NullStreamTest.php
vendored
Normal file
39
core/vendor/guzzlehttp/streams/tests/NullStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\NullStream;
|
||||
|
||||
class NullStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testDoesNothing()
|
||||
{
|
||||
$b = new NullStream();
|
||||
$this->assertEquals('', $b->read(10));
|
||||
$this->assertEquals(4, $b->write('test'));
|
||||
$this->assertEquals('', (string) $b);
|
||||
$this->assertNull($b->getMetadata('a'));
|
||||
$this->assertEquals([], $b->getMetadata());
|
||||
$this->assertEquals(0, $b->getSize());
|
||||
$this->assertEquals('', $b->getContents());
|
||||
$this->assertEquals(0, $b->tell());
|
||||
|
||||
$this->assertTrue($b->isReadable());
|
||||
$this->assertTrue($b->isWritable());
|
||||
$this->assertTrue($b->isSeekable());
|
||||
$this->assertFalse($b->seek(10));
|
||||
|
||||
$this->assertTrue($b->eof());
|
||||
$b->detach();
|
||||
$this->assertTrue($b->eof());
|
||||
$b->close();
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \GuzzleHttp\Stream\Exception\CannotAttachException
|
||||
*/
|
||||
public function testCannotAttach()
|
||||
{
|
||||
$p = new NullStream();
|
||||
$p->attach('a');
|
||||
}
|
||||
}
|
||||
77
core/vendor/guzzlehttp/streams/tests/PumpStreamTest.php
vendored
Normal file
77
core/vendor/guzzlehttp/streams/tests/PumpStreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\LimitStream;
|
||||
use GuzzleHttp\Stream\PumpStream;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
|
||||
class PumpStreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testHasMetadataAndSize()
|
||||
{
|
||||
$p = new PumpStream(function () {}, [
|
||||
'metadata' => ['foo' => 'bar'],
|
||||
'size' => 100
|
||||
]);
|
||||
|
||||
$this->assertEquals('bar', $p->getMetadata('foo'));
|
||||
$this->assertEquals(['foo' => 'bar'], $p->getMetadata());
|
||||
$this->assertEquals(100, $p->getSize());
|
||||
}
|
||||
|
||||
public function testCanReadFromCallable()
|
||||
{
|
||||
$p = Stream::factory(function ($size) {
|
||||
return 'a';
|
||||
});
|
||||
$this->assertEquals('a', $p->read(1));
|
||||
$this->assertEquals(1, $p->tell());
|
||||
$this->assertEquals('aaaaa', $p->read(5));
|
||||
$this->assertEquals(6, $p->tell());
|
||||
}
|
||||
|
||||
public function testStoresExcessDataInBuffer()
|
||||
{
|
||||
$called = [];
|
||||
$p = Stream::factory(function ($size) use (&$called) {
|
||||
$called[] = $size;
|
||||
return 'abcdef';
|
||||
});
|
||||
$this->assertEquals('a', $p->read(1));
|
||||
$this->assertEquals('b', $p->read(1));
|
||||
$this->assertEquals('cdef', $p->read(4));
|
||||
$this->assertEquals('abcdefabc', $p->read(9));
|
||||
$this->assertEquals([1, 9, 3], $called);
|
||||
}
|
||||
|
||||
public function testInifiniteStreamWrappedInLimitStream()
|
||||
{
|
||||
$p = Stream::factory(function () { return 'a'; });
|
||||
$s = new LimitStream($p, 5);
|
||||
$this->assertEquals('aaaaa', (string) $s);
|
||||
}
|
||||
|
||||
public function testDescribesCapabilities()
|
||||
{
|
||||
$p = Stream::factory(function () {});
|
||||
$this->assertTrue($p->isReadable());
|
||||
$this->assertFalse($p->isSeekable());
|
||||
$this->assertFalse($p->isWritable());
|
||||
$this->assertNull($p->getSize());
|
||||
$this->assertFalse($p->write('aa'));
|
||||
$this->assertEquals('', $p->getContents());
|
||||
$this->assertEquals('', (string) $p);
|
||||
$p->close();
|
||||
$this->assertEquals('', $p->read(10));
|
||||
$this->assertTrue($p->eof());
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \GuzzleHttp\Stream\Exception\CannotAttachException
|
||||
*/
|
||||
public function testCannotAttach()
|
||||
{
|
||||
$p = Stream::factory(function () {});
|
||||
$p->attach('a');
|
||||
}
|
||||
}
|
||||
147
core/vendor/guzzlehttp/streams/tests/StreamDecoratorTraitTest.php
vendored
Normal file
147
core/vendor/guzzlehttp/streams/tests/StreamDecoratorTraitTest.php
vendored
Normal file
|
|
@ -0,0 +1,147 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\StreamInterface;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
use GuzzleHttp\Stream\StreamDecoratorTrait;
|
||||
|
||||
class Str implements StreamInterface
|
||||
{
|
||||
use StreamDecoratorTrait;
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers GuzzleHttp\Stream\StreamDecoratorTrait
|
||||
*/
|
||||
class StreamDecoratorTraitTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
private $a;
|
||||
private $b;
|
||||
private $c;
|
||||
|
||||
public function setUp()
|
||||
{
|
||||
$this->c = fopen('php://temp', 'r+');
|
||||
fwrite($this->c, 'foo');
|
||||
fseek($this->c, 0);
|
||||
$this->a = Stream::factory($this->c);
|
||||
$this->b = new Str($this->a);
|
||||
}
|
||||
|
||||
public function testCatchesExceptionsWhenCastingToString()
|
||||
{
|
||||
$s = $this->getMockBuilder('GuzzleHttp\Stream\StreamInterface')
|
||||
->setMethods(['read'])
|
||||
->getMockForAbstractClass();
|
||||
$s->expects($this->once())
|
||||
->method('read')
|
||||
->will($this->throwException(new \Exception('foo')));
|
||||
$msg = '';
|
||||
set_error_handler(function ($errNo, $str) use (&$msg) { $msg = $str; });
|
||||
echo new Str($s);
|
||||
restore_error_handler();
|
||||
$this->assertContains('foo', $msg);
|
||||
}
|
||||
|
||||
public function testToString()
|
||||
{
|
||||
$this->assertEquals('foo', (string) $this->b);
|
||||
}
|
||||
|
||||
public function testHasSize()
|
||||
{
|
||||
$this->assertEquals(3, $this->b->getSize());
|
||||
$this->assertSame($this->b, $this->b->setSize(2));
|
||||
$this->assertEquals(2, $this->b->getSize());
|
||||
}
|
||||
|
||||
public function testReads()
|
||||
{
|
||||
$this->assertEquals('foo', $this->b->read(10));
|
||||
}
|
||||
|
||||
public function testCheckMethods()
|
||||
{
|
||||
$this->assertEquals($this->a->isReadable(), $this->b->isReadable());
|
||||
$this->assertEquals($this->a->isWritable(), $this->b->isWritable());
|
||||
$this->assertEquals($this->a->isSeekable(), $this->b->isSeekable());
|
||||
}
|
||||
|
||||
public function testSeeksAndTells()
|
||||
{
|
||||
$this->assertTrue($this->b->seek(1));
|
||||
$this->assertEquals(1, $this->a->tell());
|
||||
$this->assertEquals(1, $this->b->tell());
|
||||
$this->assertTrue($this->b->seek(0));
|
||||
$this->assertEquals(0, $this->a->tell());
|
||||
$this->assertEquals(0, $this->b->tell());
|
||||
$this->assertTrue($this->b->seek(0, SEEK_END));
|
||||
$this->assertEquals(3, $this->a->tell());
|
||||
$this->assertEquals(3, $this->b->tell());
|
||||
}
|
||||
|
||||
public function testGetsContents()
|
||||
{
|
||||
$this->assertEquals('foo', $this->b->getContents());
|
||||
$this->assertEquals('', $this->b->getContents());
|
||||
$this->b->seek(1);
|
||||
$this->assertEquals('oo', $this->b->getContents(1));
|
||||
}
|
||||
|
||||
public function testCloses()
|
||||
{
|
||||
$this->b->close();
|
||||
$this->assertFalse(is_resource($this->c));
|
||||
}
|
||||
|
||||
public function testDetaches()
|
||||
{
|
||||
$this->b->detach();
|
||||
$this->assertFalse($this->b->isReadable());
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \GuzzleHttp\Stream\Exception\CannotAttachException
|
||||
*/
|
||||
public function testCannotAttachByDefault()
|
||||
{
|
||||
$this->b->attach('a');
|
||||
}
|
||||
|
||||
public function testWrapsMetadata()
|
||||
{
|
||||
$this->assertSame($this->b->getMetadata(), $this->a->getMetadata());
|
||||
$this->assertSame($this->b->getMetadata('uri'), $this->a->getMetadata('uri'));
|
||||
}
|
||||
|
||||
public function testWrapsWrites()
|
||||
{
|
||||
$this->b->seek(0, SEEK_END);
|
||||
$this->b->write('foo');
|
||||
$this->assertEquals('foofoo', (string) $this->a);
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \UnexpectedValueException
|
||||
*/
|
||||
public function testThrowsWithInvalidGetter()
|
||||
{
|
||||
$this->b->foo;
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \BadMethodCallException
|
||||
*/
|
||||
public function testThrowsWhenGetterNotImplemented()
|
||||
{
|
||||
$s = new BadStream();
|
||||
$s->stream;
|
||||
}
|
||||
}
|
||||
|
||||
class BadStream
|
||||
{
|
||||
use StreamDecoratorTrait;
|
||||
|
||||
public function __construct() {}
|
||||
}
|
||||
252
core/vendor/guzzlehttp/streams/tests/StreamTest.php
vendored
Normal file
252
core/vendor/guzzlehttp/streams/tests/StreamTest.php
vendored
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
|
||||
/**
|
||||
* @covers GuzzleHttp\Stream\Stream
|
||||
*/
|
||||
class StreamTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
/**
|
||||
* @expectedException \InvalidArgumentException
|
||||
*/
|
||||
public function testConstructorThrowsExceptionOnInvalidArgument()
|
||||
{
|
||||
new Stream(true);
|
||||
}
|
||||
|
||||
public function testConstructorInitializesProperties()
|
||||
{
|
||||
$handle = fopen('php://temp', 'r+');
|
||||
fwrite($handle, 'data');
|
||||
$stream = new Stream($handle);
|
||||
$this->assertTrue($stream->isReadable());
|
||||
$this->assertTrue($stream->isWritable());
|
||||
$this->assertTrue($stream->isSeekable());
|
||||
$this->assertEquals('php://temp', $stream->getMetadata('uri'));
|
||||
$this->assertInternalType('array', $stream->getMetadata());
|
||||
$this->assertEquals(4, $stream->getSize());
|
||||
$this->assertFalse($stream->eof());
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testStreamClosesHandleOnDestruct()
|
||||
{
|
||||
$handle = fopen('php://temp', 'r');
|
||||
$stream = new Stream($handle);
|
||||
unset($stream);
|
||||
$this->assertFalse(is_resource($handle));
|
||||
}
|
||||
|
||||
public function testConvertsToString()
|
||||
{
|
||||
$handle = fopen('php://temp', 'w+');
|
||||
fwrite($handle, 'data');
|
||||
$stream = new Stream($handle);
|
||||
$this->assertEquals('data', (string) $stream);
|
||||
$this->assertEquals('data', (string) $stream);
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testGetsContents()
|
||||
{
|
||||
$handle = fopen('php://temp', 'w+');
|
||||
fwrite($handle, 'data');
|
||||
$stream = new Stream($handle);
|
||||
$this->assertEquals('', $stream->getContents());
|
||||
$stream->seek(0);
|
||||
$this->assertEquals('data', $stream->getContents());
|
||||
$this->assertEquals('', $stream->getContents());
|
||||
}
|
||||
|
||||
public function testChecksEof()
|
||||
{
|
||||
$handle = fopen('php://temp', 'w+');
|
||||
fwrite($handle, 'data');
|
||||
$stream = new Stream($handle);
|
||||
$this->assertFalse($stream->eof());
|
||||
$stream->read(4);
|
||||
$this->assertTrue($stream->eof());
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testAllowsSettingManualSize()
|
||||
{
|
||||
$handle = fopen('php://temp', 'w+');
|
||||
fwrite($handle, 'data');
|
||||
$stream = new Stream($handle);
|
||||
$stream->setSize(10);
|
||||
$this->assertEquals(10, $stream->getSize());
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testGetSize()
|
||||
{
|
||||
$size = filesize(__FILE__);
|
||||
$handle = fopen(__FILE__, 'r');
|
||||
$stream = new Stream($handle);
|
||||
$this->assertEquals($size, $stream->getSize());
|
||||
// Load from cache
|
||||
$this->assertEquals($size, $stream->getSize());
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testEnsuresSizeIsConsistent()
|
||||
{
|
||||
$h = fopen('php://temp', 'w+');
|
||||
$this->assertEquals(3, fwrite($h, 'foo'));
|
||||
$stream = new Stream($h);
|
||||
$this->assertEquals(3, $stream->getSize());
|
||||
$this->assertEquals(4, $stream->write('test'));
|
||||
$this->assertEquals(7, $stream->getSize());
|
||||
$this->assertEquals(7, $stream->getSize());
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testProvidesStreamPosition()
|
||||
{
|
||||
$handle = fopen('php://temp', 'w+');
|
||||
$stream = new Stream($handle);
|
||||
$this->assertEquals(0, $stream->tell());
|
||||
$stream->write('foo');
|
||||
$this->assertEquals(3, $stream->tell());
|
||||
$stream->seek(1);
|
||||
$this->assertEquals(1, $stream->tell());
|
||||
$this->assertSame(ftell($handle), $stream->tell());
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testKeepsPositionOfResource()
|
||||
{
|
||||
$h = fopen(__FILE__, 'r');
|
||||
fseek($h, 10);
|
||||
$stream = Stream::factory($h);
|
||||
$this->assertEquals(10, $stream->tell());
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testCanDetachAndAttachStream()
|
||||
{
|
||||
$r = fopen('php://temp', 'w+');
|
||||
$stream = new Stream($r);
|
||||
$stream->write('foo');
|
||||
$this->assertTrue($stream->isReadable());
|
||||
$this->assertSame($r, $stream->detach());
|
||||
$this->assertNull($stream->detach());
|
||||
|
||||
$this->assertFalse($stream->isReadable());
|
||||
$this->assertFalse($stream->read(10));
|
||||
$this->assertFalse($stream->isWritable());
|
||||
$this->assertFalse($stream->write('bar'));
|
||||
$this->assertFalse($stream->isSeekable());
|
||||
$this->assertFalse($stream->seek(10));
|
||||
$this->assertFalse($stream->tell());
|
||||
$this->assertTrue($stream->eof());
|
||||
$this->assertNull($stream->getSize());
|
||||
$this->assertSame('', (string) $stream);
|
||||
$this->assertSame('', $stream->getContents());
|
||||
|
||||
$stream->attach($r);
|
||||
$stream->seek(0);
|
||||
$this->assertEquals('foo', $stream->getContents());
|
||||
$this->assertTrue($stream->isReadable());
|
||||
$this->assertTrue($stream->isWritable());
|
||||
$this->assertTrue($stream->isSeekable());
|
||||
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testCloseClearProperties()
|
||||
{
|
||||
$handle = fopen('php://temp', 'r+');
|
||||
$stream = new Stream($handle);
|
||||
$stream->close();
|
||||
|
||||
$this->assertEmpty($stream->getMetadata());
|
||||
$this->assertFalse($stream->isSeekable());
|
||||
$this->assertFalse($stream->isReadable());
|
||||
$this->assertFalse($stream->isWritable());
|
||||
$this->assertNull($stream->getSize());
|
||||
}
|
||||
|
||||
public function testCreatesWithFactory()
|
||||
{
|
||||
$stream = Stream::factory('foo');
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\Stream', $stream);
|
||||
$this->assertEquals('foo', $stream->getContents());
|
||||
$stream->close();
|
||||
}
|
||||
|
||||
public function testFactoryCreatesFromEmptyString()
|
||||
{
|
||||
$s = Stream::factory();
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\Stream', $s);
|
||||
}
|
||||
|
||||
public function testFactoryCreatesFromResource()
|
||||
{
|
||||
$r = fopen(__FILE__, 'r');
|
||||
$s = Stream::factory($r);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\Stream', $s);
|
||||
$this->assertSame(file_get_contents(__FILE__), (string) $s);
|
||||
}
|
||||
|
||||
public function testFactoryCreatesFromObjectWithToString()
|
||||
{
|
||||
$r = new HasToString();
|
||||
$s = Stream::factory($r);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\Stream', $s);
|
||||
$this->assertEquals('foo', (string) $s);
|
||||
}
|
||||
|
||||
public function testCreatePassesThrough()
|
||||
{
|
||||
$s = Stream::factory('foo');
|
||||
$this->assertSame($s, Stream::factory($s));
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \InvalidArgumentException
|
||||
*/
|
||||
public function testThrowsExceptionForUnknown()
|
||||
{
|
||||
Stream::factory(new \stdClass());
|
||||
}
|
||||
|
||||
public function testReturnsCustomMetadata()
|
||||
{
|
||||
$s = Stream::factory('foo', ['metadata' => ['hwm' => 3]]);
|
||||
$this->assertEquals(3, $s->getMetadata('hwm'));
|
||||
$this->assertArrayHasKey('hwm', $s->getMetadata());
|
||||
}
|
||||
|
||||
public function testCanSetSize()
|
||||
{
|
||||
$s = Stream::factory('', ['size' => 10]);
|
||||
$this->assertEquals(10, $s->getSize());
|
||||
}
|
||||
|
||||
public function testCanCreateIteratorBasedStream()
|
||||
{
|
||||
$a = new \ArrayIterator(['foo', 'bar', '123']);
|
||||
$p = Stream::factory($a);
|
||||
$this->assertInstanceOf('GuzzleHttp\Stream\PumpStream', $p);
|
||||
$this->assertEquals('foo', $p->read(3));
|
||||
$this->assertFalse($p->eof());
|
||||
$this->assertEquals('b', $p->read(1));
|
||||
$this->assertEquals('a', $p->read(1));
|
||||
$this->assertEquals('r12', $p->read(3));
|
||||
$this->assertFalse($p->eof());
|
||||
$this->assertEquals('3', $p->getContents());
|
||||
$this->assertTrue($p->eof());
|
||||
$this->assertEquals(9, $p->tell());
|
||||
}
|
||||
}
|
||||
|
||||
class HasToString
|
||||
{
|
||||
public function __toString() {
|
||||
return 'foo';
|
||||
}
|
||||
}
|
||||
155
core/vendor/guzzlehttp/streams/tests/UtilsTest.php
vendored
Normal file
155
core/vendor/guzzlehttp/streams/tests/UtilsTest.php
vendored
Normal file
|
|
@ -0,0 +1,155 @@
|
|||
<?php
|
||||
namespace GuzzleHttp\Tests\Stream;
|
||||
|
||||
use GuzzleHttp\Stream\FnStream;
|
||||
use GuzzleHttp\Stream\NoSeekStream;
|
||||
use GuzzleHttp\Stream\Stream;
|
||||
use GuzzleHttp\Stream\Utils;
|
||||
|
||||
class UtilsTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testCopiesToString()
|
||||
{
|
||||
$s = Stream::factory('foobaz');
|
||||
$this->assertEquals('foobaz', Utils::copyToString($s));
|
||||
$s->seek(0);
|
||||
$this->assertEquals('foo', Utils::copyToString($s, 3));
|
||||
$this->assertEquals('baz', Utils::copyToString($s, 3));
|
||||
$this->assertEquals('', Utils::copyToString($s));
|
||||
}
|
||||
|
||||
public function testCopiesToStringStopsWhenReadFails()
|
||||
{
|
||||
$s1 = Stream::factory('foobaz');
|
||||
$s1 = FnStream::decorate($s1, [
|
||||
'read' => function () {
|
||||
return false;
|
||||
}
|
||||
]);
|
||||
$result = Utils::copyToString($s1);
|
||||
$this->assertEquals('', $result);
|
||||
}
|
||||
|
||||
public function testCopiesToStream()
|
||||
{
|
||||
$s1 = Stream::factory('foobaz');
|
||||
$s2 = Stream::factory('');
|
||||
Utils::copyToStream($s1, $s2);
|
||||
$this->assertEquals('foobaz', (string) $s2);
|
||||
$s2 = Stream::factory('');
|
||||
$s1->seek(0);
|
||||
Utils::copyToStream($s1, $s2, 3);
|
||||
$this->assertEquals('foo', (string) $s2);
|
||||
Utils::copyToStream($s1, $s2, 3);
|
||||
$this->assertEquals('foobaz', (string) $s2);
|
||||
}
|
||||
|
||||
public function testStopsCopyToStreamWhenWriteFails()
|
||||
{
|
||||
$s1 = Stream::factory('foobaz');
|
||||
$s2 = Stream::factory('');
|
||||
$s2 = FnStream::decorate($s2, ['write' => function () { return 0; }]);
|
||||
Utils::copyToStream($s1, $s2);
|
||||
$this->assertEquals('', (string) $s2);
|
||||
}
|
||||
|
||||
public function testStopsCopyToSteamWhenWriteFailsWithMaxLen()
|
||||
{
|
||||
$s1 = Stream::factory('foobaz');
|
||||
$s2 = Stream::factory('');
|
||||
$s2 = FnStream::decorate($s2, ['write' => function () { return 0; }]);
|
||||
Utils::copyToStream($s1, $s2, 10);
|
||||
$this->assertEquals('', (string) $s2);
|
||||
}
|
||||
|
||||
public function testStopsCopyToSteamWhenReadFailsWithMaxLen()
|
||||
{
|
||||
$s1 = Stream::factory('foobaz');
|
||||
$s1 = FnStream::decorate($s1, ['read' => function () { return ''; }]);
|
||||
$s2 = Stream::factory('');
|
||||
Utils::copyToStream($s1, $s2, 10);
|
||||
$this->assertEquals('', (string) $s2);
|
||||
}
|
||||
|
||||
public function testReadsLines()
|
||||
{
|
||||
$s = Stream::factory("foo\nbaz\nbar");
|
||||
$this->assertEquals("foo\n", Utils::readline($s));
|
||||
$this->assertEquals("baz\n", Utils::readline($s));
|
||||
$this->assertEquals("bar", Utils::readline($s));
|
||||
}
|
||||
|
||||
public function testReadsLinesUpToMaxLength()
|
||||
{
|
||||
$s = Stream::factory("12345\n");
|
||||
$this->assertEquals("123", Utils::readline($s, 4));
|
||||
$this->assertEquals("45\n", Utils::readline($s));
|
||||
}
|
||||
|
||||
public function testReadsLineUntilFalseReturnedFromRead()
|
||||
{
|
||||
$s = $this->getMockBuilder('GuzzleHttp\Stream\Stream')
|
||||
->setMethods(['read', 'eof'])
|
||||
->disableOriginalConstructor()
|
||||
->getMock();
|
||||
$s->expects($this->exactly(2))
|
||||
->method('read')
|
||||
->will($this->returnCallback(function () {
|
||||
static $c = false;
|
||||
if ($c) {
|
||||
return false;
|
||||
}
|
||||
$c = true;
|
||||
return 'h';
|
||||
}));
|
||||
$s->expects($this->exactly(2))
|
||||
->method('eof')
|
||||
->will($this->returnValue(false));
|
||||
$this->assertEquals("h", Utils::readline($s));
|
||||
}
|
||||
|
||||
public function testCalculatesHash()
|
||||
{
|
||||
$s = Stream::factory('foobazbar');
|
||||
$this->assertEquals(md5('foobazbar'), Utils::hash($s, 'md5'));
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \GuzzleHttp\Stream\Exception\SeekException
|
||||
*/
|
||||
public function testCalculatesHashThrowsWhenSeekFails()
|
||||
{
|
||||
$s = new NoSeekStream(Stream::factory('foobazbar'));
|
||||
$s->read(2);
|
||||
Utils::hash($s, 'md5');
|
||||
}
|
||||
|
||||
public function testCalculatesHashSeeksToOriginalPosition()
|
||||
{
|
||||
$s = Stream::factory('foobazbar');
|
||||
$s->seek(4);
|
||||
$this->assertEquals(md5('foobazbar'), Utils::hash($s, 'md5'));
|
||||
$this->assertEquals(4, $s->tell());
|
||||
}
|
||||
|
||||
public function testOpensFilesSuccessfully()
|
||||
{
|
||||
$r = Utils::open(__FILE__, 'r');
|
||||
$this->assertInternalType('resource', $r);
|
||||
fclose($r);
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \RuntimeException
|
||||
* @expectedExceptionMessage Unable to open /path/to/does/not/exist using mode r
|
||||
*/
|
||||
public function testThrowsExceptionNotWarning()
|
||||
{
|
||||
Utils::open('/path/to/does/not/exist', 'r');
|
||||
}
|
||||
|
||||
public function testProxiesToFactory()
|
||||
{
|
||||
$this->assertEquals('foo', (string) Utils::create('foo'));
|
||||
}
|
||||
}
|
||||
Reference in a new issue