Wikibase\Lib\Tests\SimpleCacheTestCase

Complexity

Total Complexity

104

Size/Duplication

Total Lines	713
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

52 Methods

Rating	Name	Duplication	Size	Complexity
	createSimpleCache()	0	1	?
A	advanceTime()	0	3	1
A	setUp()	0	5	1
A	tearDown()	0	7	2
A	invalidKeys()	0	8	1
A	invalidArrayKeys()	0	21	1
A	invalidTtl()	0	14	1
A	validKeys()	0	6	1
A	validData()	0	11	1
A	testSet()	0	9	2
A	testSetTtl()	0	16	2
A	testSetExpiredTtl()	0	14	2
A	testGet()	0	11	2
A	testDelete()	0	10	2
A	testClear()	0	10	2
A	testSetMultiple()	0	10	2
A	testSetMultipleWithIntegerArrayKey()	0	9	2
A	testSetMultipleTtl()	0	17	2
A	testSetMultipleExpiredTtl()	0	9	2
A	testSetMultipleWithGenerator()	0	14	2
A	testGetMultiple()	0	28	5
A	testGetMultipleWithGenerator()	0	28	5
A	testDeleteMultiple()	0	14	2
A	testDeleteMultipleGenerator()	0	15	2
A	testHas()	0	9	2
A	testBasicUsageWithLongKey()	0	17	2
A	testGetInvalidKeys()	0	8	2
A	testGetMultipleInvalidKeys()	0	8	2
A	testGetMultipleNoIterable()	0	8	2
A	testSetInvalidKeys()	0	8	2
A	testSetMultipleInvalidKeys()	0	13	2
A	testSetMultipleNoIterable()	0	8	2
A	testHasInvalidKeys()	0	8	2
A	testDeleteInvalidKeys()	0	8	2
A	testDeleteMultipleInvalidKeys()	0	8	2
A	testDeleteMultipleNoIterable()	0	8	2
A	testSetInvalidTtl()	0	8	2
A	testSetMultipleInvalidTtl()	0	8	2
A	testNullOverwrite()	0	10	2
A	testDataTypeString()	0	10	2
A	testDataTypeInteger()	0	10	2
A	testDataTypeFloat()	0	11	2
A	testDataTypeBoolean()	0	11	2
A	testDataTypeArray()	0	11	2
A	testDataTypeObject()	0	12	2
A	testBinaryData()	0	15	3
A	testSetValidKeys()	0	8	2
A	testSetMultipleValidKeys()	0	15	3
A	testSetValidData()	0	8	2
A	testSetMultipleValidData()	0	14	3
A	testObjectAsDefaultValue()	0	9	2
A	testObjectDoesNotChangeInCache()	0	13	2

<?php

namespace Wikibase\Lib\Tests;

/*
 * This file was originally part of php-cache organization. It was copied in context of
 * https://phabricator.wikimedia.org/T237164#6234226.
 *
 * The original from which this file was copied is
 * https://github.com/php-cache/integration-tests/blob/e023fbe54c9821dfefbe04db0074ee8682f7f577/src/SimpleCacheTest.php
 *
 * See there for the original version of this comment.
 */

use PHPUnit\Framework\TestCase;
use Psr\SimpleCache\CacheInterface;

/**
 * All modifications to the original MIT-licensed file are made under
 * @license GPL-2.0-or-later
 */
abstract class SimpleCacheTestCase extends TestCase {

	/**
	 * @var array with functionName => reason.
	 */
	protected $skippedTests = [];

	/**
	 * @var CacheInterface
	 */
	protected $cache;

	/**
	 * @return CacheInterface that is used in the tests
	 */
	abstract public function createSimpleCache();

	/**
	 * Advance time perceived by the cache for the purposes of testing TTL.
	 *
	 * The default implementation sleeps for the specified duration,
	 * but subclasses are encouraged to override this,
	 * adjusting a mocked time possibly set up in {@link createSimpleCache()},
	 * to speed up the tests.
	 *
	 * @param int $seconds
	 */
	public function advanceTime( $seconds ) {
		sleep( $seconds );
	}

	protected function setUp(): void {
		parent::setUp();

		$this->cache = $this->createSimpleCache();
	}

	protected function tearDown(): void {
		parent::tearDown();

		if ( $this->cache !== null ) {
			$this->cache->clear();
		}
	}

	/**
	 * Data provider for invalid cache keys.
	 *
	 * @return array
	 */
	public static function invalidKeys() {
		return array_merge(
			self::invalidArrayKeys(),
			[
				[ 2 ],
			]
		);
	}

	/**
	 * Data provider for invalid array keys.
	 *
	 * @return array
	 */
	public static function invalidArrayKeys() {
		return [
			[ '' ],
			[ true ],
			[ false ],
			[ null ],
			[ 2.5 ],
			[ '{str' ],
			[ 'rand{' ],
			[ 'rand{str' ],
			[ 'rand}str' ],
			[ 'rand(str' ],
			[ 'rand)str' ],
			[ 'rand/str' ],
			[ 'rand\\str' ],
			[ 'rand@str' ],
			[ 'rand:str' ],
			[ new \stdClass() ],
			[ [ 'array' ] ],
		];
	}

	/**
	 * @return array
	 */
	public static function invalidTtl() {
		return [
			[ '' ],
			[ true ],
			[ false ],
			[ 'abc' ],
			[ 2.5 ],
			[ ' 1' ], // can be casted to a int
			[ '12foo' ], // can be casted to a int
			[ '025' ], // can be interpreted as hex
			[ new \stdClass() ],
			[ [ 'array' ] ],
		];
	}

	/**
	 * Data provider for valid keys.
	 *
	 * @return array
	 */
	public static function validKeys() {
		return [
			[ 'AbC19_.' ],
			[ '1234567890123456789012345678901234567890123456789012345678901234' ],
		];
	}

	/**
	 * Data provider for valid data to store.
	 *
	 * @return array
	 */
	public static function validData() {
		return [
			[ 'AbC19_.' ],
			[ 4711 ],
			[ 47.11 ],
			[ true ],
			[ null ],
			[ [ 'key' => 'value' ] ],
			[ new \stdClass() ],
		];
	}

	public function testSet() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->set( 'key', 'value' );
		$this->assertTrue( $result, 'set() must return true if success' );
		$this->assertEquals( 'value', $this->cache->get( 'key' ) );
	}

	public function testSetTtl() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->set( 'key1', 'value', 1 );
		$this->assertTrue( $result, 'set() must return true if success' );
		$this->assertEquals( 'value', $this->cache->get( 'key1' ) );
		$this->advanceTime( 2 );
		$this->assertNull( $this->cache->get( 'key1' ), 'Value must expire after ttl.' );

		$this->cache->set( 'key2', 'value', new \DateInterval( 'PT1S' ) );
		$this->assertEquals( 'value', $this->cache->get( 'key2' ) );
		$this->advanceTime( 2 );
		$this->assertNull( $this->cache->get( 'key2' ), 'Value must expire after ttl.' );
	}

	public function testSetExpiredTtl() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key0', 'value' );
		$this->cache->set( 'key0', 'value', 0 );
		$this->assertNull( $this->cache->get( 'key0' ) );
		$this->assertFalse( $this->cache->has( 'key0' ) );

		$this->cache->set( 'key1', 'value', -1 );
		$this->assertNull( $this->cache->get( 'key1' ) );
		$this->assertFalse( $this->cache->has( 'key1' ) );
	}

	public function testGet() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertNull( $this->cache->get( 'key' ) );
		$this->assertEquals( 'foo', $this->cache->get( 'key', 'foo' ) );

		$this->cache->set( 'key', 'value' );
		$this->assertEquals( 'value', $this->cache->get( 'key', 'foo' ) );
	}

	public function testDelete() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertTrue( $this->cache->delete( 'key' ), 'Deleting a value that does not exist should return true' );
		$this->cache->set( 'key', 'value' );
		$this->assertTrue( $this->cache->delete( 'key' ), 'Delete must return true on success' );
		$this->assertNull( $this->cache->get( 'key' ), 'Values must be deleted on delete()' );
	}

	public function testClear() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertTrue( $this->cache->clear(), 'Clearing an empty cache should return true' );
		$this->cache->set( 'key', 'value' );
		$this->assertTrue( $this->cache->clear(), 'Delete must return true on success' );
		$this->assertNull( $this->cache->get( 'key' ), 'Values must be deleted on clear()' );
	}

	public function testSetMultiple() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->setMultiple( [ 'key0' => 'value0', 'key1' => 'value1' ] );

array('key0' => 'value0', 'key1' => 'value1') is of type array<string,string,{"key0":"string","key1":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$this->assertTrue( $result, 'setMultiple() must return true if success' );
		$this->assertEquals( 'value0', $this->cache->get( 'key0' ) );
		$this->assertEquals( 'value1', $this->cache->get( 'key1' ) );
	}

	public function testSetMultipleWithIntegerArrayKey() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->setMultiple( [ '0' => 'value0' ] );

array('0' => 'value0') is of type array<string,string,{"0":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$this->assertTrue( $result, 'setMultiple() must return true if success' );
		$this->assertEquals( 'value0', $this->cache->get( '0' ) );
	}

	public function testSetMultipleTtl() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->setMultiple( [ 'key2' => 'value2', 'key3' => 'value3' ], 1 );

array('key2' => 'value2', 'key3' => 'value3') is of type array<string,string,{"key2":"string","key3":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$this->assertEquals( 'value2', $this->cache->get( 'key2' ) );
		$this->assertEquals( 'value3', $this->cache->get( 'key3' ) );
		$this->advanceTime( 2 );
		$this->assertNull( $this->cache->get( 'key2' ), 'Value must expire after ttl.' );
		$this->assertNull( $this->cache->get( 'key3' ), 'Value must expire after ttl.' );

		$this->cache->setMultiple( [ 'key4' => 'value4' ], new \DateInterval( 'PT1S' ) );

array('key4' => 'value4') is of type array<string,string,{"key4":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$this->assertEquals( 'value4', $this->cache->get( 'key4' ) );
		$this->advanceTime( 2 );
		$this->assertNull( $this->cache->get( 'key4' ), 'Value must expire after ttl.' );
	}

	public function testSetMultipleExpiredTtl() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->setMultiple( [ 'key0' => 'value0', 'key1' => 'value1' ], 0 );

array('key0' => 'value0', 'key1' => 'value1') is of type array<string,string,{"key0":"string","key1":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$this->assertNull( $this->cache->get( 'key0' ) );
		$this->assertNull( $this->cache->get( 'key1' ) );
	}

	public function testSetMultipleWithGenerator() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$gen = function () {
			yield 'key0' => 'value0';
			yield 'key1' => 'value1';
		};

		$this->cache->setMultiple( $gen() );
		$this->assertEquals( 'value0', $this->cache->get( 'key0' ) );
		$this->assertEquals( 'value1', $this->cache->get( 'key1' ) );
	}

	public function testGetMultiple() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->getMultiple( [ 'key0', 'key1' ] );

array('key0', 'key1') is of type array<integer,string,{"0":"string","1":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$keys = [];
		foreach ( $result as $i => $r ) {
			$keys[] = $i;
			$this->assertNull( $r );
		}
		sort( $keys );
		$this->assertSame( [ 'key0', 'key1' ], $keys );

		$this->cache->set( 'key3', 'value' );
		$result = $this->cache->getMultiple( [ 'key2', 'key3', 'key4' ], 'foo' );

array('key2', 'key3', 'key4') is of type array<integer,string,{"0":"string","1":"string","2":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$keys = [];
		foreach ( $result as $key => $r ) {
			$keys[] = $key;
			if ( $key === 'key3' ) {
				$this->assertEquals( 'value', $r );
			} else {
				$this->assertEquals( 'foo', $r );
			}
		}
		sort( $keys );
		$this->assertSame( [ 'key2', 'key3', 'key4' ], $keys );
	}

	public function testGetMultipleWithGenerator() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$gen = function () {
			yield 1 => 'key0';
			yield 1 => 'key1';
		};

		$this->cache->set( 'key0', 'value0' );
		$result = $this->cache->getMultiple( $gen() );
		$keys = [];
		foreach ( $result as $key => $r ) {
			$keys[] = $key;
			if ( $key === 'key0' ) {
				$this->assertEquals( 'value0', $r );
			} elseif ( $key === 'key1' ) {
				$this->assertNull( $r );
			} else {
				$this->assertFalse( true, 'This should not happend' );
			}
		}
		sort( $keys );
		$this->assertSame( [ 'key0', 'key1' ], $keys );
		$this->assertEquals( 'value0', $this->cache->get( 'key0' ) );
		$this->assertNull( $this->cache->get( 'key1' ) );
	}

	public function testDeleteMultiple() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertTrue( $this->cache->deleteMultiple( [] ), 'Deleting a empty array should return true' );

array() is of type array, but the function expects a object<Psr\SimpleCache\iterable>.

		$this->assertTrue( $this->cache->deleteMultiple( [ 'key' ] ), 'Deleting a value that does not exist should return true' );

array('key') is of type array<integer,string,{"0":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$this->cache->set( 'key0', 'value0' );
		$this->cache->set( 'key1', 'value1' );
		$this->assertTrue( $this->cache->deleteMultiple( [ 'key0', 'key1' ] ), 'Delete must return true on success' );

array('key0', 'key1') is of type array<integer,string,{"0":"string","1":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$this->assertNull( $this->cache->get( 'key0' ), 'Values must be deleted on deleteMultiple()' );
		$this->assertNull( $this->cache->get( 'key1' ), 'Values must be deleted on deleteMultiple()' );
	}

	public function testDeleteMultipleGenerator() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$gen = function () {
			yield 1 => 'key0';
			yield 1 => 'key1';
		};
		$this->cache->set( 'key0', 'value0' );
		$this->assertTrue( $this->cache->deleteMultiple( $gen() ), 'Deleting a generator should return true' );

		$this->assertNull( $this->cache->get( 'key0' ), 'Values must be deleted on deleteMultiple()' );
		$this->assertNull( $this->cache->get( 'key1' ), 'Values must be deleted on deleteMultiple()' );
	}

	public function testHas() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertFalse( $this->cache->has( 'key0' ) );
		$this->cache->set( 'key0', 'value0' );
		$this->assertTrue( $this->cache->has( 'key0' ) );
	}

	public function testBasicUsageWithLongKey() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$key = str_repeat( 'a', 300 );

		$this->assertFalse( $this->cache->has( $key ) );
		$this->assertTrue( $this->cache->set( $key, 'value' ) );

		$this->assertTrue( $this->cache->has( $key ) );
		$this->assertSame( 'value', $this->cache->get( $key ) );

		$this->assertTrue( $this->cache->delete( $key ) );

		$this->assertFalse( $this->cache->has( $key ) );
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testGetInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->get( $key );
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testGetMultipleInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$result = $this->cache->getMultiple( [ 'key1', $key, 'key2' ] );

array('key1', $key, 'key2') is of type array<integer,?,{"0":"string","1":"?","2":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

$result is not used, you could remove the assignment.

	}

	public function testGetMultipleNoIterable() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$result = $this->cache->getMultiple( 'key' );

'key' is of type string, but the function expects a object<Psr\SimpleCache\iterable>.

$result is not used, you could remove the assignment.

	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testSetInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->set( $key, 'foobar' );
	}

	/**
	 * @dataProvider invalidArrayKeys
	 */
	public function testSetMultipleInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$values = function () use ( $key ) {
			yield 'key1' => 'foo';
			yield $key => 'bar';
			yield 'key2' => 'baz';
		};
		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->setMultiple( $values() );
	}

	public function testSetMultipleNoIterable() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->setMultiple( 'key' );

'key' is of type string, but the function expects a object<Psr\SimpleCache\iterable>.

	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testHasInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->has( $key );
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testDeleteInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->delete( $key );
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testDeleteMultipleInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->deleteMultiple( [ 'key1', $key, 'key2' ] );

array('key1', $key, 'key2') is of type array<integer,?,{"0":"string","1":"?","2":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

	}

	public function testDeleteMultipleNoIterable() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->deleteMultiple( 'key' );

'key' is of type string, but the function expects a object<Psr\SimpleCache\iterable>.

	}

	/**
	 * @dataProvider invalidTtl
	 */
	public function testSetInvalidTtl( $ttl ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->set( 'key', 'value', $ttl );
	}

	/**
	 * @dataProvider invalidTtl
	 */
	public function testSetMultipleInvalidTtl( $ttl ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->setMultiple( [ 'key' => 'value' ], $ttl );

array('key' => 'value') is of type array<string,string,{"key":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

	}

	public function testNullOverwrite() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', 5 );
		$this->cache->set( 'key', null );

		$this->assertNull( $this->cache->get( 'key' ), 'Setting null to a key must overwrite previous value' );
	}

	public function testDataTypeString() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', '5' );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( '5' === $result, 'Wrong data type. If we store a string we must get an string back.' );
		$this->assertTrue( is_string( $result ), 'Wrong data type. If we store a string we must get an string back.' );
	}

	public function testDataTypeInteger() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', 5 );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( 5 === $result, 'Wrong data type. If we store an int we must get an int back.' );
		$this->assertTrue( is_int( $result ), 'Wrong data type. If we store an int we must get an int back.' );
	}

	public function testDataTypeFloat() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$float = 1.23456789;
		$this->cache->set( 'key', $float );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( is_float( $result ), 'Wrong data type. If we store float we must get an float back.' );
		$this->assertEquals( $float, $result );
	}

	public function testDataTypeBoolean() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', false );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( is_bool( $result ), 'Wrong data type. If we store boolean we must get an boolean back.' );
		$this->assertFalse( $result );
		$this->assertTrue( $this->cache->has( 'key' ), 'has() should return true when true are stored. ' );
	}

	public function testDataTypeArray() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$array = [ 'a' => 'foo', 2 => 'bar' ];
		$this->cache->set( 'key', $array );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( is_array( $result ), 'Wrong data type. If we store array we must get an array back.' );
		$this->assertEquals( $array, $result );
	}

	public function testDataTypeObject() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$object = new \stdClass();
		$object->a = 'foo';
		$this->cache->set( 'key', $object );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( is_object( $result ), 'Wrong data type. If we store object we must get an object back.' );
		$this->assertEquals( $object, $result );
	}

	public function testBinaryData() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$data = '';
		for ( $i = 0; $i < 256; $i++ ) {
			$data .= chr( $i );
		}

		$array = [ 'a' => 'foo', 2 => 'bar' ];

$array is not used, you could remove the assignment.

		$this->cache->set( 'key', $data );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( $data === $result, 'Binary data must survive a round trip.' );
	}

	/**
	 * @dataProvider validKeys
	 */
	public function testSetValidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( $key, 'foobar' );
		$this->assertEquals( 'foobar', $this->cache->get( $key ) );
	}

	/**
	 * @dataProvider validKeys
	 */
	public function testSetMultipleValidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->setMultiple( [ $key => 'foobar' ] );

array($key => 'foobar') is of type array<?,string>, but the function expects a object<Psr\SimpleCache\iterable>.

		$result = $this->cache->getMultiple( [ $key ] );

array($key) is of type array<integer,?,{"0":"?"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$keys = [];
		foreach ( $result as $i => $r ) {
			$keys[] = $i;
			$this->assertEquals( $key, $i );
			$this->assertEquals( 'foobar', $r );
		}
		$this->assertSame( [ $key ], $keys );
	}

	/**
	 * @dataProvider validData
	 */
	public function testSetValidData( $data ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', $data );
		$this->assertEquals( $data, $this->cache->get( 'key' ) );
	}

	/**
	 * @dataProvider validData
	 */
	public function testSetMultipleValidData( $data ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->setMultiple( [ 'key' => $data ] );

array('key' => $data) is of type array<string,?,{"key":"?"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$result = $this->cache->getMultiple( [ 'key' ] );

array('key') is of type array<integer,string,{"0":"string"}>, but the function expects a object<Psr\SimpleCache\iterable>.

		$keys = [];
		foreach ( $result as $i => $r ) {
			$keys[] = $i;
			$this->assertEquals( $data, $r );
		}
		$this->assertSame( [ 'key' ], $keys );
	}

	public function testObjectAsDefaultValue() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$obj = new \stdClass();
		$obj->foo = 'value';
		$this->assertEquals( $obj, $this->cache->get( 'key', $obj ) );
	}

	public function testObjectDoesNotChangeInCache() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$obj = new \stdClass();
		$obj->foo = 'value';
		$this->cache->set( 'key', $obj );
		$obj->foo = 'changed';

		$cacheObject = $this->cache->get( 'key' );
		$this->assertEquals( 'value', $cacheObject->foo, 'Object in cache should not have their values changed.' );
	}
}