create-prisma-php-app 1.0.0

package/vendor/vlucas/phpdotenv/src/Validator.php

@@ -0,0 +1,209 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv;
+
+use Dotenv\Exception\ValidationException;
+use Dotenv\Repository\RepositoryInterface;
+use Dotenv\Util\Regex;
+use Dotenv\Util\Str;
+
+class Validator
+{
+    /**
+     * The environment repository instance.
+     *
+     * @var \Dotenv\Repository\RepositoryInterface
+     */
+    private $repository;
+
+    /**
+     * The variables to validate.
+     *
+     * @var string[]
+     */
+    private $variables;
+
+    /**
+     * Create a new validator instance.
+     *
+     * @param \Dotenv\Repository\RepositoryInterface $repository
+     * @param string[]                               $variables
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return void
+     */
+    public function __construct(RepositoryInterface $repository, array $variables)
+    {
+        $this->repository = $repository;
+        $this->variables = $variables;
+    }
+
+    /**
+     * Assert that each variable is present.
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return \Dotenv\Validator
+     */
+    public function required()
+    {
+        return $this->assert(
+            static function (?string $value) {
+                return $value !== null;
+            },
+            'is missing'
+        );
+    }
+
+    /**
+     * Assert that each variable is not empty.
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return \Dotenv\Validator
+     */
+    public function notEmpty()
+    {
+        return $this->assertNullable(
+            static function (string $value) {
+                return Str::len(\trim($value)) > 0;
+            },
+            'is empty'
+        );
+    }
+
+    /**
+     * Assert that each specified variable is an integer.
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return \Dotenv\Validator
+     */
+    public function isInteger()
+    {
+        return $this->assertNullable(
+            static function (string $value) {
+                return \ctype_digit($value);
+            },
+            'is not an integer'
+        );
+    }
+
+    /**
+     * Assert that each specified variable is a boolean.
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return \Dotenv\Validator
+     */
+    public function isBoolean()
+    {
+        return $this->assertNullable(
+            static function (string $value) {
+                if ($value === '') {
+                    return false;
+                }
+
+                return \filter_var($value, \FILTER_VALIDATE_BOOLEAN, \FILTER_NULL_ON_FAILURE) !== null;
+            },
+            'is not a boolean'
+        );
+    }
+
+    /**
+     * Assert that each variable is amongst the given choices.
+     *
+     * @param string[] $choices
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return \Dotenv\Validator
+     */
+    public function allowedValues(array $choices)
+    {
+        return $this->assertNullable(
+            static function (string $value) use ($choices) {
+                return \in_array($value, $choices, true);
+            },
+            \sprintf('is not one of [%s]', \implode(', ', $choices))
+        );
+    }
+
+    /**
+     * Assert that each variable matches the given regular expression.
+     *
+     * @param string $regex
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return \Dotenv\Validator
+     */
+    public function allowedRegexValues(string $regex)
+    {
+        return $this->assertNullable(
+            static function (string $value) use ($regex) {
+                return Regex::matches($regex, $value)->success()->getOrElse(false);
+            },
+            \sprintf('does not match "%s"', $regex)
+        );
+    }
+
+    /**
+     * Assert that the callback returns true for each variable.
+     *
+     * @param callable(?string):bool $callback
+     * @param string                 $message
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return \Dotenv\Validator
+     */
+    public function assert(callable $callback, string $message)
+    {
+        $failing = [];
+
+        foreach ($this->variables as $variable) {
+            if ($callback($this->repository->get($variable)) === false) {
+                $failing[] = \sprintf('%s %s', $variable, $message);
+            }
+        }
+
+        if (\count($failing) > 0) {
+            throw new ValidationException(\sprintf(
+                'One or more environment variables failed assertions: %s.',
+                \implode(', ', $failing)
+            ));
+        }
+
+        return $this;
+    }
+
+    /**
+     * Assert that the callback returns true for each variable.
+     *
+     * Skip checking null variable values.
+     *
+     * @param callable(string):bool $callback
+     * @param string                $message
+     *
+     * @throws \Dotenv\Exception\ValidationException
+     *
+     * @return \Dotenv\Validator
+     */
+    public function assertNullable(callable $callback, string $message)
+    {
+        return $this->assert(
+            static function (?string $value) use ($callback) {
+                if ($value === null) {
+                    return true;
+                }
+
+                return $callback($value);
+            },
+            $message
+        );
+    }
+}

package/vendor/vlucas/phpdotenv/tests/Dotenv/DotenvTest.php

@@ -0,0 +1,387 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests;
+
+use Dotenv\Dotenv;
+use Dotenv\Exception\InvalidEncodingException;
+use Dotenv\Exception\InvalidPathException;
+use Dotenv\Loader\Loader;
+use Dotenv\Parser\Parser;
+use Dotenv\Repository\RepositoryBuilder;
+use Dotenv\Store\StoreBuilder;
+use PHPUnit\Framework\TestCase;
+
+final class DotenvTest extends TestCase
+{
+    /**
+     * @var string
+     */
+    private static $folder;
+
+    /**
+     * @beforeClass
+     *
+     * @return void
+     */
+    public static function setFolder()
+    {
+        self::$folder = \dirname(__DIR__).'/fixtures/env';
+    }
+
+    public function testDotenvThrowsExceptionIfUnableToLoadFile()
+    {
+        $dotenv = Dotenv::createMutable(__DIR__);
+
+        $this->expectException(InvalidPathException::class);
+        $this->expectExceptionMessage('Unable to read any of the environment file(s) at');
+
+        $dotenv->load();
+    }
+
+    public function testDotenvThrowsExceptionIfUnableToLoadFiles()
+    {
+        $dotenv = Dotenv::createMutable([__DIR__, __DIR__.'/foo/bar']);
+
+        $this->expectException(InvalidPathException::class);
+        $this->expectExceptionMessage('Unable to read any of the environment file(s) at');
+
+        $dotenv->load();
+    }
+
+    public function testDotenvThrowsExceptionWhenNoFiles()
+    {
+        $dotenv = Dotenv::createMutable([]);
+
+        $this->expectException(InvalidPathException::class);
+        $this->expectExceptionMessage('At least one environment file path must be provided.');
+
+        $dotenv->load();
+    }
+
+    public function testDotenvTriesPathsToLoad()
+    {
+        $dotenv = Dotenv::createMutable([__DIR__, self::$folder]);
+        self::assertCount(4, $dotenv->load());
+    }
+
+    public function testDotenvTriesPathsToLoadTwice()
+    {
+        $dotenv = Dotenv::createMutable([__DIR__, self::$folder]);
+        self::assertCount(4, $dotenv->load());
+
+        $dotenv = Dotenv::createImmutable([__DIR__, self::$folder]);
+        self::assertCount(0, $dotenv->load());
+    }
+
+    public function testDotenvTriesPathsToSafeLoad()
+    {
+        $dotenv = Dotenv::createMutable([__DIR__, self::$folder]);
+        self::assertCount(4, $dotenv->safeLoad());
+    }
+
+    public function testDotenvSkipsLoadingIfFileIsMissing()
+    {
+        $dotenv = Dotenv::createMutable(__DIR__);
+        self::assertSame([], $dotenv->safeLoad());
+    }
+
+    public function testDotenvLoadsEnvironmentVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder);
+        self::assertSame(
+            ['FOO' => 'bar', 'BAR' => 'baz', 'SPACED' => 'with spaces', 'NULL' => ''],
+            $dotenv->load()
+        );
+        self::assertSame('bar', $_SERVER['FOO']);
+        self::assertSame('baz', $_SERVER['BAR']);
+        self::assertSame('with spaces', $_SERVER['SPACED']);
+        self::assertEmpty($_SERVER['NULL']);
+    }
+
+    public function testDotenvLoadsEnvironmentVarsMultipleWithShortCircuitMode()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, ['.env', 'example.env']);
+
+        self::assertSame(
+            ['FOO' => 'bar', 'BAR' => 'baz', 'SPACED' => 'with spaces', 'NULL' => ''],
+            $dotenv->load()
+        );
+    }
+
+    public function testDotenvLoadsEnvironmentVarsMultipleWithoutShortCircuitMode()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, ['.env', 'example.env'], false);
+
+        self::assertSame(
+            ['FOO' => 'bar', 'BAR' => 'baz', 'SPACED' => 'with spaces', 'NULL' => '', 'EG' => 'example'],
+            $dotenv->load()
+        );
+    }
+
+    public function testCommentedDotenvLoadsEnvironmentVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'commented.env');
+        $dotenv->load();
+        self::assertSame('bar', $_SERVER['CFOO']);
+        self::assertFalse(isset($_SERVER['CBAR']));
+        self::assertFalse(isset($_SERVER['CZOO']));
+        self::assertSame('with spaces', $_SERVER['CSPACED']);
+        self::assertSame('a value with a # character', $_SERVER['CQUOTES']);
+        self::assertSame('a value with a # character & a quote " character inside quotes', $_SERVER['CQUOTESWITHQUOTE']);
+        self::assertEmpty($_SERVER['CNULL']);
+        self::assertEmpty($_SERVER['EMPTY']);
+        self::assertEmpty($_SERVER['EMPTY2']);
+        self::assertSame('foo', $_SERVER['FOOO']);
+    }
+
+    public function testQuotedDotenvLoadsEnvironmentVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'quoted.env');
+        $dotenv->load();
+        self::assertSame('bar', $_SERVER['QFOO']);
+        self::assertSame('baz', $_SERVER['QBAR']);
+        self::assertSame('with spaces', $_SERVER['QSPACED']);
+        self::assertEmpty(\getenv('QNULL'));
+
+        self::assertSame('pgsql:host=localhost;dbname=test', $_SERVER['QEQUALS']);
+        self::assertSame('test some escaped characters like a quote (") or maybe a backslash (\\)', $_SERVER['QESCAPED']);
+        self::assertSame('iiiiviiiixiiiiviiii\\n', $_SERVER['QSLASH']);
+        self::assertSame('iiiiviiiixiiiiviiii\\\\n', $_SERVER['SQSLASH']);
+    }
+
+    public function testLargeDotenvLoadsEnvironmentVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'large.env');
+        $dotenv->load();
+        self::assertSame(2730, \strlen($_SERVER['LARGE']));
+        self::assertSame(8192, \strlen($_SERVER['HUGE']));
+    }
+
+    public function testDotenvLoadsMultibyteVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'multibyte.env');
+        $dotenv->load();
+        self::assertSame('Ā ā Ă ă Ą ą Ć ć Ĉ ĉ Ċ ċ Č č Ď ď Đ đ Ē ē Ĕ ĕ Ė ė Ę ę Ě ě', $_SERVER['MB1']);
+        self::assertSame('行内支付', $_SERVER['MB2']);
+        self::assertSame('🚀', $_SERVER['APP_ENV']);
+    }
+
+    public function testDotenvLoadsMultibyteUTF8Vars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'multibyte.env', false, 'UTF-8');
+        $dotenv->load();
+        self::assertSame('Ā ā Ă ă Ą ą Ć ć Ĉ ĉ Ċ ċ Č č Ď ď Đ đ Ē ē Ĕ ĕ Ė ė Ę ę Ě ě', $_SERVER['MB1']);
+        self::assertSame('行内支付', $_SERVER['MB2']);
+        self::assertSame('🚀', $_SERVER['APP_ENV']);
+    }
+
+    public function testDotenvLoadWithInvalidEncoding()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'multibyte.env', false, 'UTF-88');
+
+        $this->expectException(InvalidEncodingException::class);
+        $this->expectExceptionMessage('Illegal character encoding [UTF-88] specified.');
+
+        $dotenv->load();
+    }
+
+    public function testDotenvLoadsMultibyteWindowsVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'windows.env', false, 'Windows-1252');
+        $dotenv->load();
+        self::assertSame('ñá', $_SERVER['MBW']);
+    }
+
+    public function testMultipleDotenvLoadsEnvironmentVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'multiple.env');
+        $dotenv->load();
+        self::assertSame('bar', $_SERVER['MULTI1']);
+        self::assertSame('foo', $_SERVER['MULTI2']);
+    }
+
+    public function testExportedDotenvLoadsEnvironmentVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'exported.env');
+        $dotenv->load();
+        self::assertSame('bar', $_SERVER['EFOO']);
+        self::assertSame('baz', $_SERVER['EBAR']);
+        self::assertSame('with spaces', $_SERVER['ESPACED']);
+        self::assertSame('123', $_SERVER['EDQUOTED']);
+        self::assertSame('456', $_SERVER['ESQUOTED']);
+        self::assertEmpty($_SERVER['ENULL']);
+    }
+
+    public function testDotenvLoadsEnvGlobals()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder);
+        $dotenv->load();
+        self::assertSame('bar', $_SERVER['FOO']);
+        self::assertSame('baz', $_SERVER['BAR']);
+        self::assertSame('with spaces', $_SERVER['SPACED']);
+        self::assertEmpty($_SERVER['NULL']);
+    }
+
+    public function testDotenvLoadsServerGlobals()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder);
+        $dotenv->load();
+        self::assertSame('bar', $_ENV['FOO']);
+        self::assertSame('baz', $_ENV['BAR']);
+        self::assertSame('with spaces', $_ENV['SPACED']);
+        self::assertEmpty($_ENV['NULL']);
+    }
+
+    public function testDotenvNestedEnvironmentVars()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'nested.env');
+        $dotenv->load();
+        self::assertSame('{$NVAR1} {$NVAR2}', $_ENV['NVAR3']); // not resolved
+        self::assertSame('Hellō World!', $_ENV['NVAR4']);
+        self::assertSame('$NVAR1 {NVAR2}', $_ENV['NVAR5']); // not resolved
+        self::assertSame('Special Value', $_ENV['N.VAR6']); // new '.' (dot) in var name
+        self::assertSame('Special Value', $_ENV['NVAR7']);  // nested '.' (dot) variable
+        self::assertSame('', $_ENV['NVAR8']); // nested variable is empty string
+        self::assertSame('', $_ENV['NVAR9']); // nested variable is empty string
+        self::assertSame('${NVAR888}', $_ENV['NVAR10']); // nested variable is not set
+        self::assertSame('NVAR1', $_ENV['NVAR11']);
+        self::assertSame('Hellō', $_ENV['NVAR12']);
+        self::assertSame('${${NVAR11}}', $_ENV['NVAR13']); // single quotes
+        self::assertSame('${NVAR1} ${NVAR2}', $_ENV['NVAR14']); // single quotes
+        self::assertSame('${NVAR1} ${NVAR2}', $_ENV['NVAR15']); // escaped
+    }
+
+    public function testDotenvNullFileArgumentUsesDefault()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, null);
+        $dotenv->load();
+        self::assertSame('bar', $_SERVER['FOO']);
+    }
+
+    /**
+     * The fixture data has whitespace between the key and in the value string.
+     *
+     * Test that these keys are trimmed down.
+     */
+    public function testDotenvTrimmedKeys()
+    {
+        $dotenv = Dotenv::createMutable(self::$folder, 'quoted.env');
+        $dotenv->load();
+        self::assertSame('no space', $_SERVER['QWHITESPACE']);
+    }
+
+    public function testDotenvLoadDoesNotOverwriteEnv()
+    {
+        \putenv('IMMUTABLE=true');
+        $dotenv = Dotenv::createImmutable(self::$folder, 'immutable.env');
+        $dotenv->load();
+        self::assertSame('true', \getenv('IMMUTABLE'));
+    }
+
+    public function testDotenvLoadAfterOverload()
+    {
+        \putenv('IMMUTABLE=true');
+        $dotenv = Dotenv::createUnsafeMutable(self::$folder, 'immutable.env');
+        $dotenv->load();
+        self::assertSame('false', \getenv('IMMUTABLE'));
+    }
+
+    public function testDotenvOverloadAfterLoad()
+    {
+        \putenv('IMMUTABLE=true');
+        $dotenv = Dotenv::createUnsafeImmutable(self::$folder, 'immutable.env');
+        $dotenv->load();
+        self::assertSame('true', \getenv('IMMUTABLE'));
+    }
+
+    public function testDotenvOverloadDoesOverwriteEnv()
+    {
+        $dotenv = Dotenv::createUnsafeMutable(self::$folder, 'mutable.env');
+        $dotenv->load();
+        self::assertSame('true', \getenv('MUTABLE'));
+    }
+
+    public function testDotenvAllowsSpecialCharacters()
+    {
+        $dotenv = Dotenv::createUnsafeMutable(self::$folder, 'specialchars.env');
+        $dotenv->load();
+        self::assertSame('$a6^C7k%zs+e^.jvjXk', \getenv('SPVAR1'));
+        self::assertSame('?BUty3koaV3%GA*hMAwH}B', \getenv('SPVAR2'));
+        self::assertSame('jdgEB4{QgEC]HL))&GcXxokB+wqoN+j>xkV7K?m$r', \getenv('SPVAR3'));
+        self::assertSame('22222:22#2^{', \getenv('SPVAR4'));
+        self::assertSame('test some escaped characters like a quote " or maybe a backslash \\', \getenv('SPVAR5'));
+        self::assertSame('secret!@', \getenv('SPVAR6'));
+        self::assertSame('secret!@#', \getenv('SPVAR7'));
+        self::assertSame('secret!@#', \getenv('SPVAR8'));
+    }
+
+    public function testMultilineLoading()
+    {
+        $dotenv = Dotenv::createUnsafeMutable(self::$folder, 'multiline.env');
+        $dotenv->load();
+        self::assertSame("test\n     test\"test\"\n     test", \getenv('TEST'));
+        self::assertSame("test\ntest", \getenv('TEST_ND'));
+        self::assertSame('test\\ntest', \getenv('TEST_NS'));
+
+        self::assertSame('https://vision.googleapis.com/v1/images:annotate?key=', \getenv('TEST_EQD'));
+        self::assertSame('https://vision.googleapis.com/v1/images:annotate?key=', \getenv('TEST_EQS'));
+    }
+
+    public function testEmptyLoading()
+    {
+        $dotenv = Dotenv::createImmutable(self::$folder, 'empty.env');
+        self::assertSame(['EMPTY_VAR' => null], $dotenv->load());
+    }
+
+    public function testUnicodeVarNames()
+    {
+        $dotenv = Dotenv::createImmutable(self::$folder, 'unicodevarnames.env');
+        $dotenv->load();
+        self::assertSame('Skybert', $_SERVER['AlbertÅberg']);
+        self::assertSame('2022-04-01T00:00', $_SERVER['ДатаЗакрытияРасчетногоПериода']);
+    }
+
+    public function testDirectConstructor()
+    {
+        $repository = RepositoryBuilder::createWithDefaultAdapters()->make();
+        $store = StoreBuilder::createWithDefaultName()->addPath(self::$folder)->make();
+
+        $dotenv = new Dotenv($store, new Parser(), new Loader(), $repository);
+
+        self::assertSame([
+            'FOO'    => 'bar',
+            'BAR'    => 'baz',
+            'SPACED' => 'with spaces',
+            'NULL'   => '',
+        ], $dotenv->load());
+    }
+
+    public function testDotenvParseExample1()
+    {
+        $output = Dotenv::parse(
+            "BASE_DIR=\"/var/webroot/project-root\"\nCACHE_DIR=\"\${BASE_DIR}/cache\"\nTMP_DIR=\"\${BASE_DIR}/tmp\"\n"
+        );
+
+        self::assertSame($output, [
+            'BASE_DIR'  => '/var/webroot/project-root',
+            'CACHE_DIR' => '/var/webroot/project-root/cache',
+            'TMP_DIR'   => '/var/webroot/project-root/tmp',
+        ]);
+    }
+
+    public function testDotenvParseExample2()
+    {
+        $output = Dotenv::parse("FOO=Bar\nBAZ=\"Hello \${FOO}\"");
+
+        self::assertSame($output, ['FOO' => 'Bar', 'BAZ' => 'Hello Bar']);
+    }
+
+    public function testDotenvParseEmptyCase()
+    {
+        $output = Dotenv::parse('');
+
+        self::assertSame($output, []);
+    }
+}

package/vendor/vlucas/phpdotenv/tests/Dotenv/Loader/LoaderTest.php

@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Loader;
+
+use Dotenv\Exception\InvalidFileException;
+use Dotenv\Loader\Loader;
+use Dotenv\Loader\LoaderInterface;
+use Dotenv\Parser\Parser;
+use Dotenv\Repository\Adapter\ArrayAdapter;
+use Dotenv\Repository\Adapter\EnvConstAdapter;
+use Dotenv\Repository\Adapter\ServerConstAdapter;
+use Dotenv\Repository\RepositoryBuilder;
+use PHPUnit\Framework\TestCase;
+
+final class LoaderTest extends TestCase
+{
+    public function testParserInstanceOf()
+    {
+        self::assertInstanceOf(LoaderInterface::class, new Loader());
+    }
+
+    public function testLoaderWithNoReaders()
+    {
+        $repository = RepositoryBuilder::createWithNoAdapters()->addWriter(ArrayAdapter::class)->make();
+        $loader = new Loader();
+
+        $content = "NVAR1=\"Hello\"\nNVAR2=\"World!\"\nNVAR3=\"{\$NVAR1} {\$NVAR2}\"\nNVAR4=\"\${NVAR1} \${NVAR2}\"";
+        $expected = ['NVAR1' => 'Hello', 'NVAR2' => 'World!', 'NVAR3' => '{$NVAR1} {$NVAR2}', 'NVAR4' => '${NVAR1} ${NVAR2}'];
+
+        self::assertSame($expected, $loader->load($repository, (new Parser())->parse($content)));
+    }
+
+    public function testLoaderWithAllowList()
+    {
+        $adapter = ArrayAdapter::create()->get();
+        $repository = RepositoryBuilder::createWithNoAdapters()->addReader($adapter)->addWriter($adapter)->allowList(['FOO'])->make();
+        $loader = new Loader();
+
+        self::assertSame(['FOO' => 'Hello'], $loader->load($repository, (new Parser())->parse("FOO=\"Hello\"\nBAR=\"World!\"\n")));
+        self::assertTrue($adapter->read('FOO')->isDefined());
+        self::assertSame('Hello', $adapter->read('FOO')->get());
+        self::assertFalse($adapter->read('BAR')->isDefined());
+    }
+
+    public function testLoaderWithGarbage()
+    {
+        $adapter = ArrayAdapter::create()->get();
+        $repository = RepositoryBuilder::createWithNoAdapters()->make();
+        $loader = new Loader();
+
+        $this->expectException(InvalidFileException::class);
+        $this->expectExceptionMessage('Failed to parse dotenv file. Encountered unexpected whitespace at ["""].');
+
+        $loader->load($repository, (new Parser())->parse('FOO="""'));
+    }
+
+    /**
+     * @return array<int,\Dotenv\Repository\Adapter\AdapterInterface|string>[]
+     */
+    public static function providesAdapters()
+    {
+        return [
+            [ArrayAdapter::create()->get()],
+            [EnvConstAdapter::class],
+            [ServerConstAdapter::class],
+        ];
+    }
+
+    /**
+     * @dataProvider providesAdapters
+     *
+     * @param \Dotenv\Repository\Adapter\AdapterInterface|string $adapter
+     */
+    public function testLoaderWithSpecificAdapter($adapter)
+    {
+        $repository = RepositoryBuilder::createWithNoAdapters()->addReader($adapter)->addWriter($adapter)->make();
+        $loader = new Loader();
+
+        $content = "NVAR1=\"Hello\"\nNVAR2=\"World!\"\nNVAR3=\"{\$NVAR1} {\$NVAR2}\"\nNVAR4=\"\${NVAR1} \${NVAR2}\"";
+        $expected = ['NVAR1' => 'Hello', 'NVAR2' => 'World!', 'NVAR3' => '{$NVAR1} {$NVAR2}', 'NVAR4' => 'Hello World!'];
+
+        self::assertSame($expected, $loader->load($repository, (new Parser())->parse($content)));
+    }
+}