8889841cPK     2[Ê6&p¥  ¥    AbstractGeneratorTest.phpnu „[µü¤        <?php

use Keygen\Keygen;
use PHPUnit\Framework\TestCase;
use Keygen\Generators\NumericGenerator;

/**
 * @coversDefaultClass Keygen\AbstractGenerator
 */
final class AbstractGeneratorTest extends TestCase
{
	protected $generator;

	protected function setUp()
	{
		$this->generator = new NumericGenerator;
	}

	/**
	 * @covers ::__get
	 * @covers ::__isset
	 */
	public function testGeneratorProperties()
	{
		$this->assertSame(16, $this->generator->length);
		$this->assertNull($this->generator->prefix);
		$this->assertNull($this->generator->suffix);
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @covers Keygen\Traits\KeyManipulation::length
	 * @covers Keygen\Traits\IntegerCasting::intCast
	 */
	public function testLengthWithValidNumericArgument()
	{
		$this->generator->length(24);
		$this->assertSame(24, $this->generator->length);

		$this->generator->length('12');
		$this->assertSame(12, $this->generator->length);

		$this->generator->length(32.0);
		$this->assertSame(32, $this->generator->length);

		$this->generator->length('40.0');
		$this->assertSame(40, $this->generator->length);
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @covers Keygen\Traits\KeyManipulation::length
	 * @covers Keygen\Traits\IntegerCasting::intCast
	 */
	public function testLengthWithFloatArgument()
	{
		$this->generator->length(24.4);
		$this->assertSame(24, $this->generator->length);
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @covers Keygen\Traits\KeyManipulation::length
	 * @covers Keygen\Traits\IntegerCasting::intCast
	 * @expectedException \InvalidArgumentException
	 * @expectedExceptionMessage The given value cannot be converted to an integer.
	 */
	public function testLengthWithNonNumericArgument()
	{
		$this->generator->length([5]);
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @covers Keygen\Traits\KeyManipulation::length
	 * @covers Keygen\Traits\IntegerCasting::intCast
	 * @expectedException \InvalidArgumentException
	 * @expectedExceptionMessage The given value cannot be converted to an integer.
	 */
	public function testLengthWithNonNumericStringArgument()
	{
		$this->generator->length('53.0bees');
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @covers Keygen\Traits\KeyManipulation::prefix
	 * @covers Keygen\Traits\IntegerCasting::affix
	 */
	public function testPrefixWithValidArgument()
	{
		$this->generator->prefix(123);
		$this->assertSame('123', $this->generator->prefix);

		$this->generator->prefix('TM-');
		$this->assertSame('TM-', $this->generator->prefix);

		$this->generator->prefix(true);
		$this->assertSame('1', $this->generator->prefix);

		$this->generator->prefix(false);
		$this->assertSame('', $this->generator->prefix);
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @covers Keygen\Traits\KeyManipulation::prefix
	 * @covers Keygen\Traits\IntegerCasting::affix
	 * @expectedException \InvalidArgumentException
	 * @expectedExceptionMessage The given prefix cannot be converted to a string.
	 */
	public function testPrefixWithNonScalarArgument()
	{
		$this->generator->prefix([123]);
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @covers Keygen\Traits\KeyManipulation::suffix
	 * @covers Keygen\Traits\IntegerCasting::affix
	 */
	public function testSuffixWithValidArgument()
	{
		$this->generator->suffix(123);
		$this->assertSame('123', $this->generator->suffix);

		$this->generator->suffix('.img');
		$this->assertSame('.img', $this->generator->suffix);

		$this->generator->suffix(true);
		$this->assertSame('1', $this->generator->suffix);

		$this->generator->suffix(false);
		$this->assertSame('', $this->generator->suffix);
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @covers Keygen\Traits\KeyManipulation::suffix
	 * @covers Keygen\Traits\IntegerCasting::affix
	 * @expectedException \InvalidArgumentException
	 * @expectedExceptionMessage The given suffix cannot be converted to a string.
	 */
	public function testSuffixWithNonScalarArgument()
	{
		$this->generator->suffix($this->generator);
	}

	/**
	 * @covers Keygen\Traits\MutableGenerator::mutable
	 * @covers Keygen\Traits\MutableGenerator::immutable
	 * @covers Keygen\Traits\FlattenArguments::flattenArguments
	 */
	public function testMutableProperties()
	{
		$this->assertEquals([], $this->generator->mutables);

		$this->generator->mutable('prefix', 'length')->mutable('prefix');
		$this->assertEquals(['length', 'prefix'], $this->generator->mutables);

		$this->generator->immutable('suffix', 'length')->immutable('suffix');
		$this->assertNotContains('length', $this->generator->mutables);
		$this->assertContains('prefix', $this->generator->mutables);
	}

	/**
	 * @covers Keygen\Traits\MutableGenerator::mutable
	 * @covers Keygen\Traits\FlattenArguments::flattenArguments
	 * @expectedException \InvalidArgumentException
	 * @expectedExceptionMessage Cannot add unknown property to mutables collection ('mutate').
	 */
	public function testInvalidMutableProperties()
	{
		$this->generator->mutable('prefix', 'mutate', 'length');
	}

	/**
	 * @covers Keygen\Traits\GeneratorMutation::mutate
	 * @covers Keygen\Traits\GeneratorMutation::dontMutate
	 * @covers Keygen\Traits\FlattenArguments::flattenArguments
	 * @covers Keygen\Traits\KeyManipulation::propagateMutation
	 */
	public function testObjectMutations()
	{
		$generator1 = (new NumericGenerator(10))->mutable('length');
		$generator2 = (new NumericGenerator(10))->mutable('length', 'prefix');

		$this->generator->mutate($generator2, $generator1);

		$this->assertEquals([$generator2, $generator1], $this->generator->mutates);

		$this->assertEquals(16, $this->generator->length);
		$this->assertEquals(10, $generator1->length);
		$this->assertEquals(10, $generator2->length);

		$this->generator->length(20)->prefix('IMG-');

		$this->assertEquals(20, $this->generator->length);
		$this->assertEquals(20, $generator1->length);
		$this->assertEquals(20, $generator2->length);

		$this->assertEquals('IMG-', $this->generator->prefix);
		$this->assertEquals(null, $generator1->prefix);
		$this->assertEquals('IMG-', $generator2->prefix);

		$this->generator->dontMutate($generator2);

		$this->assertContains($generator1, $this->generator->mutates);
		$this->assertNotContains($generator2, $this->generator->mutates);

		$generator1->length(10);

		$this->assertEquals(20, $this->generator->length);
		$this->assertEquals(10, $generator1->length);
		$this->assertEquals(20, $generator2->length);

		$this->generator->mutable('length');
		$generator1->length(24);

		// Root generator not mutable by sub-generators
		$this->assertEquals(20, $this->generator->length);

		$this->assertEquals(24, $generator1->length);
	}

	/**
	 * @covers Keygen\Traits\GeneratorMutation::mutate
	 * @covers Keygen\Traits\FlattenArguments::flattenArguments
	 * @expectedException \InvalidArgumentException
	 * @expectedExceptionMessage Mutable objects must be instances of Keygen\AbstractGenerator.
	 */
	public function testInvalidMutationObject()
	{
		$generator1 = (new NumericGenerator(10))->mutable('length');
		$generator2 = (new NumericGenerator(10))->mutable('length', 'prefix');

		$this->generator->mutate($generator2, $generator1, new \stdClass);
	}

	/**
	 * @covers ::__call
	 * @covers Keygen\Traits\KeyManipulation::__overloadMethods
	 * @expectedException \BadMethodCallException
	 * @expectedExceptionMessage Call to unknown method Keygen\Generators\NumericGenerator::degenerate()
	 */
	public function testUnknownMethodCall()
	{
		$this->generator->degenerate();
	}
}
PK     2[™êå|  |    GeneratorTest.phpnu „[µü¤        <?php

use Keygen\Generator;
use PHPUnit\Framework\TestCase;
use Keygen\Generators\NumericGenerator;

/**
 * @coversDefaultClass Generator
 * @covers GeneratorInterface
 */
final class GeneratorTest extends TestCase
{
	protected $generator;

	protected function setUp()
	{
		$this->generator = new NumericGenerator;
	}

	/**
	 * @covers ::generate
	 * @covers Keygen\Traits\KeyManipulation::getAdjustedKeyLength
	 */
	public function testGenerateMethod()
	{
		$ga = $this->generator->generate();
		$this->assertSame($this->generator->length, strlen($ga));

		$gb = $this->generator->prefix('TM-')->generate();
		$this->assertSame($this->generator->length, strlen($gb));
		$this->assertRegExp('/^TM-/', $gb);

		$gc = $this->generator->prefix('token::')->suffix('::123')->generate(true);
		$this->assertSame($this->generator->length + strlen($this->generator->prefix) + strlen($this->generator->suffix), strlen($gc));
		$this->assertRegExp('/^token::\d+?::123$/', $gc);

		$callable = function($s) { return strtoupper(substr($s, 8)); };

		$gd = $this->generator->generate('md5', $callable);
		$this->assertSame(24 + strlen($this->generator->prefix) + strlen($this->generator->suffix), strlen($gd));
		$this->assertRegExp('/^token::[A-F0-9]+?::123$/', $gd);

		$ge = $this->generator->prefix('')->suffix('')->generate(true, $callable);
		$this->assertSame($this->generator->length - 8, strlen($ge));
	}
}
PK     2[Žªr>ã  ã  !  Generators/TokenGeneratorTest.phpnu „[µü¤        <?php

use PHPUnit\Framework\TestCase;
use Keygen\Generators\TokenGenerator;

/**
 * @coversDefaultClass TokenGenerator
 */
final class TokenGeneratorTest extends TestCase
{
	protected $generator;

	protected function setUp()
	{
		$this->generator = new TokenGenerator;
	}

	/**
	 * @covers ::keygen
	 * @covers Keygen\Generator::generate
	 */
	public function testKeyGeneration()
	{
		$key = $this->generator->generate();
		$this->assertRegExp('/^[a-zA-Z0-9+\/]{16}$/', $key);
	}
}
PK     2[làÊÒ  Ò  &  Generators/RandomByteGeneratorTest.phpnu „[µü¤        <?php

use PHPUnit\Framework\TestCase;
use Keygen\Generators\RandomByteGenerator;

/**
 * @coversDefaultClass RandomByteGenerator
 */
final class RandomByteGeneratorTest extends TestCase
{
	protected $generator;

	protected function setUp()
	{
		$this->generator = new RandomByteGenerator;
	}

	/**
	 * @covers ::hex
	 * @covers ::keygen
	 * @covers ::generate
	 * @covers Keygen\Generator::generate
	 */
	public function testKeyGeneration()
	{
		$key = $this->generator->generate();
		$this->assertEquals(16, strlen($key));

		$this->assertFalse($this->generator->hex);
		$hexKey = $this->generator->hex()->generate();
		$this->assertRegExp('/^[a-f0-9]{16}$/', $hexKey);
		$this->assertFalse($this->generator->hex);
	}
}
PK     2[çÐ
ðß  ß  #  Generators/NumericGeneratorTest.phpnu „[µü¤        <?php

use PHPUnit\Framework\TestCase;
use Keygen\Generators\NumericGenerator;

/**
 * @coversDefaultClass NumericGenerator
 */
final class NumericGeneratorTest extends TestCase
{
	protected $generator;

	protected function setUp()
	{
		$this->generator = new NumericGenerator;
	}

	/**
	 * @covers ::keygen
	 * @covers Keygen\Generator::generate
	 */
	public function testKeyGeneration()
	{
		$key = $this->generator->generate();
		$this->assertRegExp('/^\d{16}$/', $key);
	}
}
PK     2[e‘é·ü  ü  (  Generators/AlphaNumericGeneratorTest.phpnu „[µü¤        <?php

use PHPUnit\Framework\TestCase;
use Keygen\Generators\AlphaNumericGenerator;

/**
 * @coversDefaultClass AlphaNumericGenerator
 */
final class AlphaNumericGeneratorTest extends TestCase
{
	protected $generator;

	protected function setUp()
	{
		$this->generator = new AlphaNumericGenerator;
	}

	/**
	 * @covers ::keygen
	 * @covers Keygen\Generator::generate
	 */
	public function testKeyGeneration()
	{
		$key = $this->generator->generate();
		$this->assertRegExp('/^[a-zA-Z0-9]{16}$/', $key);
	}
}
PK     2[ì²ã"—	  —	    KeygenTest.phpnu „[µü¤        <?php

use Keygen\Keygen;
use PHPUnit\Framework\TestCase;
use Keygen\Generators\TokenGenerator;
use Keygen\Generators\NumericGenerator;
use Keygen\Generators\RandomByteGenerator;
use Keygen\Generators\AlphaNumericGenerator;

/**
 * @coversDefaultClass Keygen
 */
final class KeygenTest extends TestCase
{
	protected $keygen;

	protected function setUp()
	{
		$this->keygen = new Keygen;
	}

	/**
	 * @covers Keygen\AbstractGenerator::__get
	 * @covers Keygen\AbstractGenerator::__isset
	 */
	public function testGeneratorProperties()
	{
		$this->assertSame(16, $this->keygen->length);
		$this->assertNull($this->keygen->prefix);
		$this->assertNull($this->keygen->suffix);
	}

	/**
	 * @covers ::__call
	 * @covers ::newGenerator
	 * @covers ::newGeneratorFromAlias
	 * @covers Keygen\GeneratorFactory::create
	 * @covers Keygen\AbstractGenerator::__call
	 * @covers Keygen\AbstractGenerator::__callStatic
	 */
	public function testGeneratorMethods()
	{
		$this->assertInstanceOf(TokenGenerator::class, Keygen::token());
		$this->assertInstanceOf(NumericGenerator::class, Keygen::numeric());
		$this->assertInstanceOf(RandomByteGenerator::class, Keygen::bytes());
		$this->assertInstanceOf(AlphaNumericGenerator::class, Keygen::alphanum());

		$this->assertInstanceOf(TokenGenerator::class, $this->keygen->token());
		$this->assertInstanceOf(NumericGenerator::class, $this->keygen->numeric());
		$this->assertInstanceOf(RandomByteGenerator::class, $this->keygen->bytes());
		$this->assertInstanceOf(AlphaNumericGenerator::class, $this->keygen->alphanum());

		$this->assertSame(16, Keygen::token()->length);
		$this->assertSame(32, Keygen::bytes(32)->length);
		$this->assertSame(20, Keygen::numeric(20)->length);
		$this->assertSame(12, Keygen::alphanum(12)->length);

		$this->assertSame(16, $this->keygen->token()->length);
		$this->assertSame(32, $this->keygen->bytes(32)->length);
		$this->assertSame(20, $this->keygen->numeric(20)->length);
		$this->assertSame(12, $this->keygen->alphanum(12)->length);
	}

	/**
	 * @covers ::__call
	 * @covers ::newGenerator
	 * @covers ::newGeneratorFromAlias
	 * @covers Keygen\GeneratorFactory::create
	 * @covers Keygen\AbstractGenerator::__call
	 * @covers Keygen\AbstractGenerator::__callStatic
	 * @expectedException \BadMethodCallException
	 * @expectedExceptionMessage Call to unknown method Keygen\Keygen::unknown()
	 */
	public function testInvalidGeneratorMethods()
	{
		$this->keygen->unknown();
	}
}
PK     2[Ìû^_½  ½    GeneratorFactoryTest.phpnu „[µü¤        <?php

use Keygen\GeneratorFactory;
use PHPUnit\Framework\TestCase;
use Keygen\Generators\TokenGenerator;
use Keygen\Generators\NumericGenerator;
use Keygen\Generators\RandomByteGenerator;
use Keygen\Generators\AlphaNumericGenerator;

/**
 * @coversDefaultClass Keygen\GeneratorFactory
 */
final class GeneratorFactoryTest extends TestCase
{
	/**
	 * @covers ::create
	 * @expectedException \InvalidArgumentException
	 * @expectedExceptionMessage Cannot create unknown generator type.
	 */
	public function testCreateGenerators()
	{
		$this->assertInstanceOf(TokenGenerator::class, GeneratorFactory::create('token'));
		$this->assertInstanceOf(NumericGenerator::class, GeneratorFactory::create('numeric'));
		$this->assertInstanceOf(RandomByteGenerator::class, GeneratorFactory::create('randombyte'));
		$this->assertInstanceOf(AlphaNumericGenerator::class, GeneratorFactory::create('alphanumeric'));

		$generator = GeneratorFactory::create('bytes');
	}
}
PK       2[Ê6&p¥  ¥                  AbstractGeneratorTest.phpnu „[µü¤        PK       2[™êå|  |              î  GeneratorTest.phpnu „[µü¤        PK       2[Žªr>ã  ã  !            «$  Generators/TokenGeneratorTest.phpnu „[µü¤        PK       2[làÊÒ  Ò  &            ß&  Generators/RandomByteGeneratorTest.phpnu „[µü¤        PK       2[çÐ
ðß  ß  #            *  Generators/NumericGeneratorTest.phpnu „[µü¤        PK       2[e‘é·ü  ü  (            9,  Generators/AlphaNumericGeneratorTest.phpnu „[µü¤        PK       2[ì²ã"—	  —	              .  KeygenTest.phpnu „[µü¤        PK       2[Ìû^_½  ½              b8  GeneratorFactoryTest.phpnu „[µü¤        PK      â  g<    