1
0
mirror of https://github.com/danog/file.git synced 2024-12-11 08:50:08 +01:00
file/test/HandleTest.php
2019-08-22 23:33:03 +02:00

391 lines
12 KiB
PHP

<?php
namespace Amp\File\Test;
use Amp\ByteStream\ClosedException;
use Amp\Delayed;
use Amp\File;
use Amp\PHPUnit\TestCase;
use Amp\Sync\Lock;
use Amp\TimeoutCancellationToken;
use function Amp\Promise\timeout;
abstract class HandleTest extends TestCase
{
protected function setUp()
{
Fixture::init();
File\StatCache::clear();
}
protected function tearDown()
{
Fixture::clear();
}
abstract protected function execute(callable $cb);
public function testWrite()
{
$this->execute(function () {
$path = Fixture::path() . "/write";
/** @var \Amp\File\Handle $handle */
$handle = yield File\open($path, "c+");
$this->assertSame(0, $handle->tell());
$handle->write("foo");
yield $handle->write("bar");
yield $handle->seek(0);
$contents = yield $handle->read();
$this->assertSame(6, $handle->tell());
$this->assertTrue($handle->eof());
$this->assertSame("foobar", $contents);
yield $handle->close();
});
}
public function testEmptyWrite()
{
$this->execute(function () {
$path = Fixture::path() . "/write";
$handle = yield File\open($path, "c+");
$this->assertSame(0, $handle->tell());
yield $handle->write("");
$this->assertSame(0, $handle->tell());
yield $handle->close();
});
}
public function testWriteAfterClose()
{
$this->execute(function () {
$path = Fixture::path() . "/write";
/** @var \Amp\File\Handle $handle */
$handle = yield File\open($path, "c+");
yield $handle->close();
$this->expectException(ClosedException::class);
yield $handle->write("bar");
});
}
public function testDoubleClose()
{
$this->execute(function () {
$path = Fixture::path() . "/write";
/** @var \Amp\File\Handle $handle */
$handle = yield File\open($path, "c+");
yield $handle->close();
$this->assertNull(yield $handle->close());
});
}
public function testWriteAfterEnd()
{
$this->execute(function () {
$path = Fixture::path() . "/write";
/** @var \Amp\File\Handle $handle */
$handle = yield File\open($path, "c+");
$this->assertSame(0, $handle->tell());
yield $handle->end("foo");
$this->expectException(ClosedException::class);
yield $handle->write("bar");
});
}
public function testWriteInAppendMode()
{
$this->execute(function () {
$path = Fixture::path() . "/write";
/** @var \Amp\File\Handle $handle */
$handle = yield File\open($path, "a+");
$this->assertSame(0, $handle->tell());
yield $handle->write("bar");
yield $handle->write("foo");
yield $handle->write("baz");
$this->assertSame(9, $handle->tell());
yield $handle->seek(0);
$this->assertSame(0, $handle->tell());
$this->assertSame("barfoobaz", yield $handle->read());
});
}
public function testReadingToEof()
{
$this->execute(function () {
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
$contents = "";
$position = 0;
$stat = yield File\stat(__FILE__);
$chunkSize = (int) \floor(($stat["size"] / 5));
while (!$handle->eof()) {
$chunk = yield $handle->read($chunkSize);
$contents .= $chunk;
$position += \strlen($chunk);
$this->assertSame($position, $handle->tell());
}
$this->assertNull(yield $handle->read());
$this->assertSame(yield File\get(__FILE__), $contents);
yield $handle->close();
});
}
public function testSequentialReads()
{
$this->execute(function () {
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
$contents = "";
$contents .= yield $handle->read(10);
$contents .= yield $handle->read(10);
$expected = \substr(yield File\get(__FILE__), 0, 20);
$this->assertSame($expected, $contents);
yield $handle->close();
});
}
public function testReadingFromOffset()
{
$this->execute(function () {
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
$this->assertSame(0, $handle->tell());
yield $handle->seek(10);
$this->assertSame(10, $handle->tell());
$chunk = yield $handle->read(90);
$this->assertSame(100, $handle->tell());
$expected = \substr(yield File\get(__FILE__), 10, 90);
$this->assertSame($expected, $chunk);
yield $handle->close();
});
}
/**
* @expectedException \Error
*/
public function testSeekThrowsOnInvalidWhence()
{
$this->execute(function () {
try {
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
yield $handle->seek(0, 99999);
} finally {
yield $handle->close();
}
});
}
public function testSeekSetCur()
{
$this->execute(function () {
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
$this->assertSame(0, $handle->tell());
yield $handle->seek(10);
$this->assertSame(10, $handle->tell());
yield $handle->seek(-10, \SEEK_CUR);
$this->assertSame(0, $handle->tell());
yield $handle->close();
});
}
public function testSeekSetEnd()
{
$this->execute(function () {
$size = yield File\size(__FILE__);
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
$this->assertSame(0, $handle->tell());
yield $handle->seek(-10, \SEEK_END);
$this->assertSame($size - 10, $handle->tell());
yield $handle->close();
});
}
public function testPath()
{
$this->execute(function () {
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
$this->assertSame(__FILE__, $handle->path());
yield $handle->close();
});
}
public function testMode()
{
$this->execute(function () {
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
$this->assertSame("r", $handle->mode());
yield $handle->close();
});
}
/**
* Try locking file exclusively.
*
* @param string $file File
* @param int $polling Polling interval
* @param int $timeout Lock timeout
* @return void
*/
private function tryLockExclusive(string $file, int $polling, int $timeout)
{
return File\lockExclusive($file, $polling, new TimeoutCancellationToken($timeout));
}
/**
* Try locking file in shared mode.
*
* @param string $file File
* @param int $polling Polling interval
* @param int $timeout Lock timeout
* @return void
*/
private function tryLockShared(string $file, int $polling, int $timeout)
{
return File\lockShared($file, $polling, new TimeoutCancellationToken($timeout));
}
public function testExclusiveLock()
{
$this->execute(function () {
$primary = null;
$secondary = null;
try {
try {
$primary = yield $this->tryLockExclusive(__FILE__, 100, 100);
$this->assertInstanceOf(Lock::class, $primary);
$unlocked = false;
$try = $this->tryLockShared(__FILE__, 100, 10000);
$try->onResolve(static function ($e, $secondaryUnlock) use (&$unlocked, &$secondary) {
if ($e) {
throw $e;
}
$unlocked = true;
$secondary = $secondaryUnlock;
});
$this->assertFalse($unlocked, "The lock wasn't acquired");
} finally {
if ($primary) {
$primary->release();
}
}
yield new Delayed(100 * 2);
$this->assertTrue($unlocked, "The lock wasn't released");
yield $try;
$this->assertInstanceOf(Lock::class, $secondary);
} finally {
if ($secondary) {
$secondary->release();
}
}
});
}
public function testSharedLock()
{
$this->execute(function () {
$primary = null;
$secondary = null;
try {
$primary = yield $this->tryLockShared(__FILE__, 100, 100);
$this->assertInstanceOf(Lock::class, $primary);
$secondary = yield $this->tryLockShared(__FILE__, 100, 100);
$this->assertInstanceOf(Lock::class, $secondary);
} finally {
if ($primary) {
$primary->release();
}
if ($secondary) {
$secondary->release();
}
}
});
}
public function testClose()
{
$this->execute(function () {
/** @var \Amp\File\Handle $handle */
$handle = yield File\open(__FILE__, "r");
yield $handle->close();
$this->expectException(ClosedException::class);
yield $handle->read();
});
}
/**
* @depends testWrite
*/
public function testTruncateToSmallerSize()
{
$this->execute(function () {
$path = Fixture::path() . "/write";
/** @var \Amp\File\Handle $handle */
$handle = yield File\open($path, "c+");
$handle->write("foo");
yield $handle->write("bar");
yield $handle->truncate(4);
yield $handle->seek(0);
$contents = yield $handle->read();
$this->assertTrue($handle->eof());
$this->assertSame("foob", $contents);
yield $handle->write("bar");
$this->assertSame(7, $handle->tell());
yield $handle->seek(0);
$contents = yield $handle->read();
$this->assertSame("foobbar", $contents);
yield $handle->close();
});
}
/**
* @depends testWrite
*/
public function testTruncateToLargerSize()
{
$this->execute(function () {
$path = Fixture::path() . "/write";
/** @var \Amp\File\Handle $handle */
$handle = yield File\open($path, "c+");
yield $handle->write("foo");
yield $handle->truncate(6);
$this->assertSame(3, $handle->tell());
yield $handle->seek(0);
$contents = yield $handle->read();
$this->assertTrue($handle->eof());
$this->assertSame("foo\0\0\0", $contents);
yield $handle->write("bar");
$this->assertSame(9, $handle->tell());
yield $handle->seek(0);
$contents = yield $handle->read();
$this->assertSame("foo\0\0\0bar", $contents);
yield $handle->close();
});
}
}