diff --git a/composer.json b/composer.json
index ececb30..a9ea690 100644
--- a/composer.json
+++ b/composer.json
@@ -7,8 +7,13 @@
       "email": "vintsukevich@gmail.com"
     }
   ],
+  "require": {
+    "php": "^8.1",
+    "ext-zlib": "*",
+    "ext-mbstring": "*"
+  },
   "require-dev": {
-    "phpunit/phpunit": "~4.0"
+    "phpunit/phpunit": "^11.0"
   },
   "autoload": {
     "psr-4": {
@@ -20,4 +25,4 @@
       "Vvval\\Binary\\Tests\\": "tests"
     }
   }
-}
\ No newline at end of file
+}
diff --git a/phpunit.xml b/phpunit.xml
index 94dc2bd..7d079ed 100644
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -1,18 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit backupGlobals="false"
-         backupStaticAttributes="false"
          colors="true"
-         verbose="true"
-         convertErrorsToExceptions="true"
-         convertNoticesToExceptions="true"
-         convertWarningsToExceptions="true"
          processIsolation="false"
          stopOnFailure="false"
-         stopOnError="false"
-         syntaxCheck="true">
+         stopOnError="false">
     <testsuites>
         <testsuite name="Application Tests">
             <directory>./tests/</directory>
         </testsuite>
     </testsuites>
-</phpunit>
\ No newline at end of file
+</phpunit>
diff --git a/src/Binary.php b/src/Binary.php
new file mode 100644
index 0000000..70cecda
--- /dev/null
+++ b/src/Binary.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary;
+
+use Vvval\Binary\Binary\Reader;
+use Vvval\Binary\Binary\Writer;
+use Vvval\Binary\Handler\Handler;
+use Vvval\Binary\Handler\Mode;
+
+class Binary
+{
+    public static function reader(string $filename, bool $compression = false): Reader
+    {
+        $handler = new Handler($filename, Mode::READ, $compression);
+
+        return new Reader($handler, $filename);
+    }
+
+    public static function appender(string $filename, bool $compression = false): Writer
+    {
+        $handler = new Handler($filename, Mode::APPEND, $compression);
+
+        return new Writer($handler, $filename);
+    }
+
+    public static function writer(string $filename, bool $compression = false): Writer
+    {
+        $handler = new Handler($filename, Mode::WRITE, $compression);
+
+        return new Writer($handler, $filename);
+    }
+}
diff --git a/src/Binary/Reader.php b/src/Binary/Reader.php
new file mode 100644
index 0000000..3399127
--- /dev/null
+++ b/src/Binary/Reader.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Binary;
+
+use Vvval\Binary\Exceptions\ReadDataException;
+use Vvval\Binary\Handler\ReadableHandlerInterface;
+
+/**
+ * @internal
+ */
+class Reader
+{
+    private const FORMAT_LENGTH = 4;
+    private const FORMAT = 'L';
+
+    private ?ReadableHandlerInterface $handler;
+
+    public function __construct(
+        ReadableHandlerInterface $handler,
+        private readonly string $filename,
+    ) {
+        $this->handler = $handler;
+    }
+
+    public function finish(): void
+    {
+        unset($this->handler);
+    }
+
+    /**
+     * @return iterable<string>
+     * @throws ReadDataException
+     */
+    public function readAll(): iterable
+    {
+        while (true) {
+            $line = $this->readLine();
+            if ($line === null) {
+                $this->finish();
+                return;
+            }
+
+            yield $line;
+        }
+    }
+
+    /**
+     * @throws ReadDataException
+     */
+    public function readLine(): ?string
+    {
+        return $this->read();
+    }
+
+    public function __destruct()
+    {
+        $this->finish();
+    }
+
+    /**
+     * @throws ReadDataException
+     */
+    private function read(): ?string
+    {
+        if (empty($this->handler)) {
+            throw ReadDataException::handlerAlreadyClosed($this->filename);
+        }
+
+        $length = $this->handler->read(self::FORMAT_LENGTH);
+        if (empty($length)) {
+            return null;
+        }
+
+        if (mb_strlen($length) !== self::FORMAT_LENGTH) {
+            throw ReadDataException::dataCorrupted($this->filename);
+        }
+
+        $data = unpack(self::FORMAT . 'len', $length);
+        $line = $this->handler->read((int)$data['len']);
+
+        return $line !== false ? $line : null;
+    }
+}
diff --git a/src/Binary/Writer.php b/src/Binary/Writer.php
new file mode 100644
index 0000000..acb6129
--- /dev/null
+++ b/src/Binary/Writer.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Binary;
+
+use Vvval\Binary\Exceptions\BinaryException;
+use Vvval\Binary\Exceptions\WriteDataException;
+use Vvval\Binary\Handler\WriteableHandlerInterface;
+
+/**
+ * @internal
+ */
+class Writer
+{
+    private const FORMAT = 'L';
+
+    private ?WriteableHandlerInterface $handler;
+
+    public function __construct(
+        WriteableHandlerInterface $handler,
+        private readonly string $filename,
+    ) {
+        $this->handler = $handler;
+    }
+
+    public function finish(): void
+    {
+        unset($this->handler);
+    }
+
+    public function writeLine(string $data): int|false
+    {
+        if (empty($this->handler)) {
+            throw WriteDataException::handlerAlreadyClosed($this->filename);
+        }
+
+        $length = pack(self::FORMAT, mb_strlen($data));
+
+        return $this->handler->write($length, $data);
+    }
+
+    /**
+     * @throws BinaryException
+     */
+    public function __destruct()
+    {
+        $this->finish();
+    }
+}
diff --git a/src/BinaryGenerator.php b/src/BinaryGenerator.php
deleted file mode 100644
index 5ae94c5..0000000
--- a/src/BinaryGenerator.php
+++ /dev/null
@@ -1,207 +0,0 @@
-<?php
-/**
- * Lightweight tool to read/write tons of data directly in file, skipping memory usage
- *
- * @author  Valentin V
- * @license http://www.opensource.org/licenses/MIT
- * @link    https://github.com/vvval/binary
- * @version 0.1.0
- */
-namespace Vvval\Binary;
-
-use Vvval\Binary\Exceptions\HandlerException;
-use Vvval\Binary\Exceptions\ReadDataException;
-use Vvval\Binary\Exceptions\WriteDataException;
-
-class BinaryGenerator
-{
-    /**
-     * Open file flags.
-     */
-    const READ   = 'rb';
-    const WRITE  = 'wb';
-    const APPEND = 'ab';
-
-    private $filename = null;
-    private $compression = null;
-    private $handler = null;
-    private $mode = self::READ;
-
-    /**
-     * Start process.
-     *
-     * @param string $filename
-     * @param string $mode
-     * @param bool   $compression
-     * @throws HandlerException
-     */
-    public function start($filename, $mode, $compression = false)
-    {
-        if (!empty($this->handler)) {
-            throw new HandlerException("Binary generator has already been started, please finish it before next usage.");
-        }
-
-        $this->mode = $mode;
-        $this->filename = $filename;
-        $this->compression = $compression;
-
-        $this->handler = $this->open();
-
-        if (empty($this->handler)) {
-            throw new HandlerException("Error during opening \"$this->filename\" file.");
-        }
-    }
-
-    /**
-     * Finish process.
-     */
-    public function finish()
-    {
-        if (!empty($this->handler)) {
-            $this->close();
-            $this->handler = null;
-        }
-    }
-
-    /**
-     * Write part of data into file.
-     *
-     * @param string $data
-     * @return int
-     * @throws HandlerException
-     * @throws WriteDataException
-     */
-    public function writeData($data)
-    {
-        if (!$this->isWriteMode()) {
-            throw new WriteDataException("Unable to write data into \"$this->filename\" file, read mode is set.");
-        }
-
-        if (empty($this->handler)) {
-            throw new HandlerException("Unable to write data into \"$this->filename\" file, no resource is available.");
-        }
-
-        $packedLength = pack('L', mb_strlen($data));
-
-        return $this->write($packedLength, $data);
-    }
-
-    /**
-     * Write part of data.
-     *
-     * @return null|string
-     * @throws HandlerException
-     * @throws ReadDataException
-     */
-    public function readData()
-    {
-        if (!$this->isReadMode()) {
-            throw new ReadDataException("Unable to read data from \"$this->filename\" file, write mode is set.");
-        }
-
-        if (empty($this->handler)) {
-            throw new HandlerException("Unable to read data from \"$this->filename\" file, no resource is available.");
-        }
-
-        $length = $this->read(4);
-
-        if (empty($length)) {
-            return null;
-        }
-
-        if (mb_strlen($length) != 4) {
-            throw new ReadDataException("Unable to read data from \"$this->filename\" file, data is corrupted.");
-        }
-
-        $length = unpack('L', $length);
-
-        return $this->read((int)$length);
-    }
-
-    /**
-     * Open file and get handler.
-     *
-     * @return resource
-     */
-    private function open()
-    {
-        if (!empty($this->compression)) {
-            return gzopen($this->filename, $this->mode);
-        } else {
-            return fopen($this->filename, $this->mode);
-        }
-    }
-
-    /**
-     * Close handler file.
-     */
-    private function close()
-    {
-        if (!empty($this->compression)) {
-            gzclose($this->handler);
-        } else {
-            fclose($this->handler);
-        }
-    }
-
-    /**
-     * Read piece of data with the defined length.
-     *
-     * @param int $length
-     * @return string
-     */
-    private function read($length)
-    {
-        if (!empty($this->compression)) {
-            return gzread($this->handler, $length);
-        } else {
-            return fread($this->handler, $length);
-        }
-    }
-
-    /**
-     * Write data into file.
-     *
-     * @param int    $length
-     * @param string $data
-     * @return int
-     */
-    private function write($length, $data)
-    {
-        if (!empty($this->compression)) {
-            return gzwrite($this->handler, $length . $data);
-        } else {
-            return fwrite($this->handler, $length . $data);
-        }
-    }
-
-    /**
-     * If current file in read mode.
-     *
-     * @return bool
-     */
-    private function isReadMode()
-    {
-        return $this->mode === self::READ;
-    }
-
-    /**
-     * If current file in write mode.
-     *
-     * @return bool
-     */
-    private function isWriteMode()
-    {
-        return in_array($this->mode, [self::WRITE, self::APPEND]);
-    }
-
-    /**
-     * Check if file was closed.
-     */
-    public function __destruct()
-    {
-        if (!empty($this->handler)) {
-            throw new HandlerException("Binary generator hasn't finished \"$this->filename\" file yet.");
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Exceptions/BinaryException.php b/src/Exceptions/BinaryException.php
new file mode 100644
index 0000000..82891e2
--- /dev/null
+++ b/src/Exceptions/BinaryException.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Exceptions;
+
+use RuntimeException;
+
+class BinaryException extends RuntimeException
+{
+    public static function wrap(BinaryException $e): static
+    {
+        return new static($e->getMessage(), $e->getCode(), $e);
+    }
+}
diff --git a/src/Exceptions/ClosedHandlerException.php b/src/Exceptions/ClosedHandlerException.php
new file mode 100644
index 0000000..7d51564
--- /dev/null
+++ b/src/Exceptions/ClosedHandlerException.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Exceptions;
+
+class ClosedHandlerException extends BinaryException
+{
+    public function __construct(string $filename)
+    {
+        parent::__construct(sprintf('File handler "%s" is already closed.', $filename));
+    }
+}
diff --git a/src/Exceptions/GeneratorException.php b/src/Exceptions/GeneratorException.php
deleted file mode 100644
index eda7391..0000000
--- a/src/Exceptions/GeneratorException.php
+++ /dev/null
@@ -1,15 +0,0 @@
-<?php
-/**
- * Lightweight tool to read/write tons of data directly in file, skipping memory usage
- *
- * @author  Valentin V
- * @license http://www.opensource.org/licenses/MIT
- * @link    https://github.com/vvval/binary
- * @version 0.1.0
- */
-namespace Vvval\Binary\Exceptions;
-
-class GeneratorException extends \Exception
-{
-
-}
\ No newline at end of file
diff --git a/src/Exceptions/HandlerException.php b/src/Exceptions/HandlerException.php
deleted file mode 100644
index bc78116..0000000
--- a/src/Exceptions/HandlerException.php
+++ /dev/null
@@ -1,15 +0,0 @@
-<?php
-/**
- * Lightweight tool to read/write tons of data directly in file, skipping memory usage
- *
- * @author  Valentin V
- * @license http://www.opensource.org/licenses/MIT
- * @link    https://github.com/vvval/binary
- * @version 0.1.0
- */
-namespace Vvval\Binary\Exceptions;
-
-class HandlerException extends GeneratorException
-{
-
-}
\ No newline at end of file
diff --git a/src/Exceptions/OpenHandlerException.php b/src/Exceptions/OpenHandlerException.php
new file mode 100644
index 0000000..b94329d
--- /dev/null
+++ b/src/Exceptions/OpenHandlerException.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Exceptions;
+
+class OpenHandlerException extends BinaryException
+{
+    public function __construct(string $filename)
+    {
+        parent::__construct(sprintf('Unable to open "%s "file.', $filename));
+    }
+}
diff --git a/src/Exceptions/ReadDataException.php b/src/Exceptions/ReadDataException.php
index a29077d..fe4afef 100644
--- a/src/Exceptions/ReadDataException.php
+++ b/src/Exceptions/ReadDataException.php
@@ -1,15 +1,18 @@
 <?php
-/**
- * Lightweight tool to read/write tons of data directly in file, skipping memory usage
- *
- * @author  Valentin V
- * @license http://www.opensource.org/licenses/MIT
- * @link    https://github.com/vvval/binary
- * @version 0.1.0
- */
+
+declare(strict_types=1);
+
 namespace Vvval\Binary\Exceptions;
 
-class ReadDataException extends GeneratorException
+class ReadDataException extends BinaryException
 {
+    public static function handlerAlreadyClosed(string $filename): static
+    {
+        return new self(sprintf('Unable to read data from "%s" file, file handler is closed.', $filename));
+    }
 
-}
\ No newline at end of file
+    public static function dataCorrupted(string $filename): static
+    {
+        return new self(sprintf('Unable to read data from "%s" file, data is corrupted.', $filename));
+    }
+}
diff --git a/src/Exceptions/WriteDataException.php b/src/Exceptions/WriteDataException.php
index 070eec6..a3744f3 100644
--- a/src/Exceptions/WriteDataException.php
+++ b/src/Exceptions/WriteDataException.php
@@ -1,15 +1,13 @@
 <?php
-/**
- * Lightweight tool to read/write tons of data directly in file, skipping memory usage
- *
- * @author  Valentin V
- * @license http://www.opensource.org/licenses/MIT
- * @link    https://github.com/vvval/binary
- * @version 0.1.0
- */
+
+declare(strict_types=1);
+
 namespace Vvval\Binary\Exceptions;
 
-class WriteDataException extends GeneratorException
+class WriteDataException extends BinaryException
 {
-
-}
\ No newline at end of file
+    public static function handlerAlreadyClosed(string $filename): static
+    {
+        return new self(sprintf('Unable to write data to "%s" file, file handler is closed.', $filename));
+    }
+}
diff --git a/src/Handler/Handler.php b/src/Handler/Handler.php
new file mode 100644
index 0000000..4b00762
--- /dev/null
+++ b/src/Handler/Handler.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Handler;
+
+use Vvval\Binary\Exceptions\ClosedHandlerException;
+use Vvval\Binary\Exceptions\OpenHandlerException;
+use Vvval\Binary\Exceptions\ReadDataException;
+use Vvval\Binary\Exceptions\WriteDataException;
+
+/**
+ * @internal
+ */
+class Handler implements ReadableHandlerInterface, WriteableHandlerInterface
+{
+    /** @var resource|null */
+    private $handler;
+    private Status $status;
+
+    public function __construct(
+        private readonly string $filename,
+        private readonly Mode $mode,
+        private readonly bool $compression = false,
+    ) {
+        $this->status = Status::PENDING;
+    }
+
+    public function read(int $length): string|false
+    {
+        try {
+            $this->open();
+        } catch (ClosedHandlerException) {
+            throw ReadDataException::handlerAlreadyClosed($this->filename);
+        } catch (OpenHandlerException $e) {
+            throw ReadDataException::wrap($e);
+        }
+
+        return $this->compression
+            ? gzread($this->handler, $length)
+            : fread($this->handler, $length);
+    }
+
+    public function write(string $length, string $data): int|false
+    {
+        try {
+            $this->open();
+        } catch (ClosedHandlerException) {
+            throw WriteDataException::handlerAlreadyClosed($this->filename);
+        } catch (OpenHandlerException $e) {
+            throw WriteDataException::wrap($e);
+        }
+
+        return $this->compression
+            ? gzwrite($this->handler, $length . $data)
+            : fwrite($this->handler, $length . $data);
+    }
+
+    public function __destruct()
+    {
+        $this->close();
+    }
+
+    private function open(): void
+    {
+        if ($this->status === Status::CLOSED) {
+            throw new ClosedHandlerException($this->filename);
+        }
+
+        if ($this->status === Status::OPENED) {
+            return;
+        }
+
+        $handler = $this->compression
+            ? gzopen($this->filename, $this->mode->value)
+            : fopen($this->filename, $this->mode->value);
+
+        if (!$handler) {
+            throw new OpenHandlerException($this->filename);
+        }
+
+        $this->handler = $handler;
+        $this->status = Status::OPENED;
+    }
+
+    private function close(): void
+    {
+        if ($this->status === Status::CLOSED) {
+            return;
+        }
+
+        if ($this->status === Status::OPENED) {
+            if (!empty($this->compression)) {
+                gzclose($this->handler);
+            } else {
+                fclose($this->handler);
+            }
+        }
+
+        $this->handler = null;
+        $this->status = Status::CLOSED;
+    }
+}
diff --git a/src/Handler/HandlerInterface.php b/src/Handler/HandlerInterface.php
new file mode 100644
index 0000000..28cb96f
--- /dev/null
+++ b/src/Handler/HandlerInterface.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Handler;
+
+interface HandlerInterface
+{
+}
diff --git a/src/Handler/Mode.php b/src/Handler/Mode.php
new file mode 100644
index 0000000..fb658fe
--- /dev/null
+++ b/src/Handler/Mode.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Handler;
+
+/**
+ * @internal
+ */
+enum Mode: string
+{
+    case READ = 'rb';
+    case WRITE = 'wb';
+    case APPEND = 'ab';
+}
diff --git a/src/Handler/ReadableHandlerInterface.php b/src/Handler/ReadableHandlerInterface.php
new file mode 100644
index 0000000..04d765f
--- /dev/null
+++ b/src/Handler/ReadableHandlerInterface.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Handler;
+
+use Vvval\Binary\Exceptions\ReadDataException;
+
+interface ReadableHandlerInterface extends HandlerInterface
+{
+    /**
+     * @throws ReadDataException
+     */
+    public function read(int $length): string|false;
+}
diff --git a/src/Handler/Status.php b/src/Handler/Status.php
new file mode 100644
index 0000000..0491975
--- /dev/null
+++ b/src/Handler/Status.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Handler;
+
+/**
+ * @internal
+ */
+enum Status
+{
+    case PENDING;
+    case OPENED;
+    case CLOSED;
+}
diff --git a/src/Handler/WriteableHandlerInterface.php b/src/Handler/WriteableHandlerInterface.php
new file mode 100644
index 0000000..3059324
--- /dev/null
+++ b/src/Handler/WriteableHandlerInterface.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vvval\Binary\Handler;
+
+use Vvval\Binary\Exceptions\WriteDataException;
+
+interface WriteableHandlerInterface extends HandlerInterface
+{
+    /**
+     * @throws WriteDataException
+     */
+    public function write(string $length, string $data): int|false;
+}
diff --git a/tests/BinaryTest.php b/tests/BinaryTest.php
index 6f01f70..5aa1030 100644
--- a/tests/BinaryTest.php
+++ b/tests/BinaryTest.php
@@ -1,32 +1,86 @@
 <?php
-/**
- * Created by PhpStorm.
- * User: Valentin
- * Date: 01.02.2016
- * Time: 13:19
- */
 
-namespace Vvval\Binary\Tests;
+declare(strict_types=1);
 
-use Vvval\Binary\BinaryGenerator;
+use PHPUnit\Framework\TestCase;
+use Vvval\Binary\Binary;
+use Vvval\Binary\Exceptions\ReadDataException;
+use Vvval\Binary\Exceptions\WriteDataException;
 
-class BinaryTest extends \PHPUnit_Framework_TestCase
+class BinaryTest extends TestCase
 {
-    private $writeFile = 'binary.write.txt';
-    private $appendFile = 'binary.append.txt';
+    private const STUB_FILENAME = __DIR__ . '/assets/stub.txt';
+    private const FILENAME = __DIR__ . '/assets/testable.txt';
 
-    /**
-     * If data file exists.
-     */
-    public function testBinaryWrite()
+    protected function setUp(): void
     {
-        $binary = new BinaryGenerator();
+        copy(self::STUB_FILENAME, self::FILENAME);
+    }
+
+    protected function tearDown(): void
+    {
+        unlink(self::FILENAME);
+    }
+
+    public function testReadSingleLine(): void
+    {
+        $reader = Binary::reader(self::FILENAME);
+
+        $this->assertSame('hello', $reader->readLine());
+        $this->assertSame('world', $reader->readLine());
+        $this->assertNull($reader->readLine());
+    }
+
+    public function testReadAllLines(): void
+    {
+        $reader = Binary::reader(self::FILENAME);
+        $lines = [...$reader->readAll()];
+
+        $this->assertSame(['hello', 'world'], $lines);
+    }
+
+    public function testCantReadClosedFile(): void
+    {
+        $this->expectException(ReadDataException::class);
 
-        $binary->start($this->writeFile, BinaryGenerator::WRITE);
-        $binary->writeData('some data.1');
-        $binary->writeData('some data.2');
-        $binary->finish();
+        $reader = Binary::reader(self::FILENAME);
+        $reader->finish();
+        $reader->readLine();
+    }
+
+    public function testWriteSingleLine(): void
+    {
+        $writer = Binary::writer(self::FILENAME);
+        $writer->writeLine('world');
+        $writer->finish();
+
+        $reader = Binary::reader(self::FILENAME);
+
+        $this->assertSame('world', $reader->readLine());
+        $this->assertNull($reader->readLine());
+    }
+
+    public function testAppendSingleLine(): void
+    {
+        $writer = Binary::appender(self::FILENAME);
+        $writer->writeLine('!');
+        $writer->finish();
+
+        $reader = Binary::reader(self::FILENAME);
+
+        $this->assertSame('hello', $reader->readLine());
+        $this->assertSame('world', $reader->readLine());
+        $this->assertSame('!', $reader->readLine());
+        $this->assertNull($reader->readLine());
+    }
+
+
+    public function testCantWriteToClosedFile(): void
+    {
+        $this->expectException(WriteDataException::class);
 
-        $this->assertFileExists($this->writeFile);
+        $writer = Binary::writer(self::FILENAME);
+        $writer->finish();
+        $writer->writeLine('!');
     }
-}
\ No newline at end of file
+}
diff --git a/tests/assets/.empty b/tests/assets/.empty
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/assets/stub.txt b/tests/assets/stub.txt
new file mode 100644
index 0000000..a3176ca
Binary files /dev/null and b/tests/assets/stub.txt differ