mirror of
https://github.com/Karaka-Management/phpOMS.git
synced 2026-01-12 10:18:39 +00:00
378 lines
11 KiB
PHP
378 lines
11 KiB
PHP
<?php
|
|
/**
|
|
* Orange Management
|
|
*
|
|
* PHP Version 7.2
|
|
*
|
|
* @package tests
|
|
* @copyright Dennis Eichhorn
|
|
* @license OMS License 1.0
|
|
* @version 1.0.0
|
|
* @link https://orange-management.org
|
|
*/
|
|
declare(strict_types=1);
|
|
|
|
namespace phpOMS\tests\Stdlib\Map;
|
|
|
|
use phpOMS\Stdlib\Map\KeyType;
|
|
use phpOMS\Stdlib\Map\MultiMap;
|
|
use phpOMS\Stdlib\Map\OrderType;
|
|
|
|
/**
|
|
* @internal
|
|
*/
|
|
class MultiMapTest extends \PHPUnit\Framework\TestCase
|
|
{
|
|
public function testAttributes() : void
|
|
{
|
|
$map = new MultiMap();
|
|
self::assertInstanceOf('\phpOMS\Stdlib\Map\MultiMap', $map);
|
|
|
|
/* Testing members */
|
|
self::assertObjectHasAttribute('values', $map);
|
|
self::assertObjectHasAttribute('keys', $map);
|
|
}
|
|
|
|
public function testDefault() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
/* Testing default values */
|
|
self::assertNull($map->get('someKey'));
|
|
self::assertEquals(0, $map->count());
|
|
|
|
self::assertEmpty($map->keys());
|
|
self::assertEmpty($map->values());
|
|
self::assertEmpty($map->getSiblings('someKey'));
|
|
self::assertFalse($map->removeKey('someKey'));
|
|
self::assertFalse($map->remap('old', 'new'));
|
|
self::assertFalse($map->remove('someKey'));
|
|
}
|
|
|
|
public function testBasicAddAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val1');
|
|
self::assertEquals(1, $map->count());
|
|
self::assertTrue($inserted);
|
|
self::assertEquals('val1', $map->get('a'));
|
|
self::assertEquals('val1', $map->get('b'));
|
|
}
|
|
|
|
public function testOverwriteAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val1');
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
self::assertEquals(1, $map->count());
|
|
self::assertTrue($inserted);
|
|
self::assertEquals('val2', $map->get('a'));
|
|
self::assertEquals('val2', $map->get('b'));
|
|
}
|
|
|
|
public function testOverwritePartialFalseAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
self::assertEquals(2, $map->count());
|
|
self::assertTrue($inserted);
|
|
self::assertEquals('val2', $map->get('a'));
|
|
self::assertEquals('val2', $map->get('b'));
|
|
self::assertEquals('val3', $map->get('c'));
|
|
}
|
|
|
|
public function testOverwriteFalseFalseAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
$inserted = $map->add(['a', 'c'], 'val4', false);
|
|
self::assertEquals(2, $map->count());
|
|
self::assertFalse($inserted);
|
|
self::assertEquals('val2', $map->get('a'));
|
|
self::assertEquals('val2', $map->get('b'));
|
|
self::assertEquals('val3', $map->get('c'));
|
|
}
|
|
|
|
public function testSetAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
|
|
$set = $map->set('d', 'val4');
|
|
self::assertFalse($set);
|
|
self::assertEquals(2, $map->count());
|
|
|
|
$set = $map->set('b', 'val4');
|
|
self::assertEquals(2, $map->count());
|
|
self::assertTrue($set);
|
|
self::assertEquals('val4', $map->get('b'));
|
|
self::assertEquals('val4', $map->get('a'));
|
|
self::assertEquals('val3', $map->get('c'));
|
|
}
|
|
|
|
public function testRemapAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
|
|
$set = $map->set('d', 'val4');
|
|
$set = $map->set('b', 'val4');
|
|
|
|
$remap = $map->remap('b', 'd');
|
|
self::assertEquals(2, $map->count());
|
|
self::assertFalse($remap);
|
|
|
|
$remap = $map->remap('d', 'b');
|
|
self::assertEquals(2, $map->count());
|
|
self::assertFalse($remap);
|
|
|
|
$remap = $map->remap('d', 'e');
|
|
self::assertEquals(2, $map->count());
|
|
self::assertFalse($remap);
|
|
|
|
$remap = $map->remap('b', 'c');
|
|
self::assertEquals(2, $map->count());
|
|
self::assertTrue($remap);
|
|
self::assertEquals('val3', $map->get('b'));
|
|
self::assertEquals('val4', $map->get('a'));
|
|
self::assertEquals('val3', $map->get('c'));
|
|
}
|
|
|
|
public function testMapInfoAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
|
|
$set = $map->set('d', 'val4');
|
|
$set = $map->set('b', 'val4');
|
|
|
|
self::assertCount(3, $map->keys());
|
|
self::assertCount(2, $map->values());
|
|
|
|
self::assertIsArray($map->keys());
|
|
self::assertIsArray($map->values());
|
|
}
|
|
|
|
public function testSiblingsAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
|
|
$set = $map->set('d', 'val4');
|
|
$set = $map->set('b', 'val4');
|
|
|
|
$siblings = $map->getSiblings('d');
|
|
self::assertEmpty($siblings);
|
|
self::assertCount(0, $siblings);
|
|
|
|
$siblings = $map->getSiblings('b');
|
|
self::assertCount(1, $siblings);
|
|
self::assertEquals(['a'], $siblings);
|
|
}
|
|
|
|
public function testRemoveAny() : void
|
|
{
|
|
$map = new MultiMap();
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
|
|
$set = $map->set('d', 'val4');
|
|
$set = $map->set('b', 'val4');
|
|
|
|
$removed = $map->remove('d');
|
|
self::assertFalse($removed);
|
|
|
|
$removed = $map->remove('c');
|
|
self::assertTrue($removed);
|
|
self::assertCount(2, $map->keys());
|
|
self::assertCount(1, $map->values());
|
|
|
|
$removed = $map->removeKey('d');
|
|
self::assertFalse($removed);
|
|
|
|
$removed = $map->removeKey('a');
|
|
self::assertTrue($removed);
|
|
self::assertCount(1, $map->keys());
|
|
self::assertCount(1, $map->values());
|
|
}
|
|
|
|
public function testBasicAddExact() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val1');
|
|
self::assertEquals(1, $map->count());
|
|
self::assertTrue($inserted);
|
|
self::assertEquals('val1', $map->get(['a', 'b']));
|
|
self::assertEquals('val1', $map->get(['b', 'a']));
|
|
}
|
|
|
|
public function testBasicAddExactOrdered() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE, OrderType::STRICT);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val1');
|
|
self::assertEquals(1, $map->count());
|
|
self::assertTrue($inserted);
|
|
self::assertEquals('val1', $map->get(['a', 'b']));
|
|
self::assertNull($map->get(['b', 'a']));
|
|
}
|
|
|
|
public function testOverwriteExact() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val1');
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
self::assertEquals(1, $map->count());
|
|
self::assertTrue($inserted);
|
|
self::assertEquals('val2', $map->get(['a', 'b']));
|
|
}
|
|
|
|
public function testOverwritePartialFalseExact() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
self::assertEquals(2, $map->count());
|
|
self::assertTrue($inserted);
|
|
self::assertEquals('val2', $map->get(['a', 'b']));
|
|
self::assertEquals('val3', $map->get(['c', 'a']));
|
|
}
|
|
|
|
public function testOverwriteFalseFalseExact() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
$inserted = $map->add(['a', 'c'], 'val4', false);
|
|
self::assertEquals(2, $map->count());
|
|
self::assertFalse($inserted);
|
|
self::assertEquals('val2', $map->get(['a', 'b']));
|
|
self::assertEquals('val3', $map->get(['a', 'c']));
|
|
}
|
|
|
|
public function testSetExact() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
|
|
$set = $map->set('d', 'val4');
|
|
self::assertFalse($set);
|
|
self::assertEquals(2, $map->count());
|
|
|
|
$set = $map->set(['a', 'b'], 'val4');
|
|
self::assertEquals(2, $map->count());
|
|
self::assertTrue($set);
|
|
self::assertEquals('val4', $map->get(['a', 'b']));
|
|
self::assertEquals('val4', $map->get(['b', 'a']));
|
|
}
|
|
|
|
public function testSetExactOrdered() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE, OrderType::STRICT);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
|
|
$set = $map->set('c', 'val4');
|
|
self::assertFalse($set);
|
|
self::assertEquals(2, $map->count());
|
|
|
|
$set = $map->set(['a', 'b'], 'val4');
|
|
self::assertEquals(2, $map->count());
|
|
self::assertTrue($set);
|
|
self::assertEquals('val4', $map->get(['a', 'b']));
|
|
|
|
$set = $map->set(['b', 'a'], 'val5');
|
|
self::assertEquals(2, $map->count());
|
|
self::assertFalse($set);
|
|
}
|
|
|
|
public function testRemapExact() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$remap = $map->remap(['a', 'b'], ['c', 'd']);
|
|
|
|
self::assertFalse($remap);
|
|
}
|
|
|
|
public function testSiblingsExact() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
self::assertEquals([['a', 'b'], ['b', 'a']], $map->getSiblings(['a', 'b']));
|
|
}
|
|
|
|
public function testSiblingsExactOrdered() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE, OrderType::STRICT);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
self::assertEquals([], $map->getSiblings(['a', 'b']));
|
|
}
|
|
|
|
public function testRemoveExact() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
|
|
self::assertCount(2, $map->keys());
|
|
self::assertCount(2, $map->values());
|
|
|
|
$removed = $map->remove('d');
|
|
self::assertFalse($removed);
|
|
|
|
$removed = $map->remove(['a', 'b']);
|
|
self::assertTrue($removed);
|
|
self::assertCount(1, $map->keys());
|
|
self::assertCount(1, $map->values());
|
|
|
|
self::assertFalse($map->removeKey(['a', 'b']));
|
|
}
|
|
|
|
public function testRemoveExactOrdered() : void
|
|
{
|
|
$map = new MultiMap(KeyType::MULTIPLE, OrderType::STRICT);
|
|
|
|
$inserted = $map->add(['a', 'b'], 'val2');
|
|
$inserted = $map->add(['a', 'c'], 'val3', false);
|
|
|
|
self::assertCount(2, $map->keys());
|
|
self::assertCount(2, $map->values());
|
|
|
|
$removed = $map->remove(['b', 'a']);
|
|
self::assertFalse($removed);
|
|
|
|
$removed = $map->remove(['a', 'b']);
|
|
self::assertTrue($removed);
|
|
self::assertCount(1, $map->keys());
|
|
self::assertCount(1, $map->values());
|
|
|
|
self::assertFalse($map->removeKey(['a', 'b']));
|
|
}
|
|
}
|