HasherTest::testFnv1AHashSpaceLookupsAreValidTargets() - Code Metrics - Inspection of "feat: add Fnv1-a hasher" - ericsizemore/consistent-hash - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( ddf3a0...f0c061 )

by Eric

created 2024-12-06 05:58 UTC

testFnv1AHashSpaceLookupsAreValidTargets() A

↳ Parent: HasherTest

Complexity

Conditions	3
Paths	4

Size

Total Lines	14
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	9
nc	4
nop	0
dl	0
loc	14
rs	9.9666
c	0
b	0
f	0

<?php

declare(strict_types=1);

/**
 * This file is part of Esi\ConsistentHash.
 *
 * (c) Eric Sizemore <[email protected]>
 * (c) Paul Annesley <[email protected]>
 *
 * This source file is subject to the MIT license. For the full copyright and
 * license information, please view the LICENSE file that was distributed with
 * this source code.
 */

namespace Esi\ConsistentHash\Tests\Hasher;

use Esi\ConsistentHash\ConsistentHash;
use Esi\ConsistentHash\Hasher\Crc32Hasher;
use Esi\ConsistentHash\Hasher\Fnv1AHasher;
use Esi\ConsistentHash\Hasher\Md5Hasher;
use Esi\ConsistentHash\Hasher\Murmur3Hasher;
use Esi\ConsistentHash\Hasher\Xxh32Hasher;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\UsesClass;
use PHPUnit\Framework\TestCase;

/**
 * @internal
 */
#[CoversClass(Crc32Hasher::class)]
#[CoversClass(Fnv1AHasher::class)]
#[CoversClass(Md5Hasher::class)]
#[CoversClass(Murmur3Hasher::class)]
#[CoversClass(Xxh32Hasher::class)]
#[UsesClass(ConsistentHash::class)]
class HasherTest extends TestCase
{
    public function testCrc32Hash(): void
    {
        $hasher  = new Crc32Hasher();
        $result1 = $hasher->hash('test');
        $result2 = $hasher->hash('test');
        $result3 = $hasher->hash('different');

        self::assertEquals($result1, $result2);
        self::assertNotEquals($result1, $result3); // fragile but worthwhile
    }

    public function testCrc32HashSpaceLookupsAreValidTargets(): void
    {
        $targets = [];
        foreach (range(1, 10) as $i) {
            $targets[] = \sprintf('target%s', $i);
        }

        $hashSpace = new ConsistentHash(new Crc32Hasher());
        $hashSpace->addTargets($targets);

        foreach (range(1, 10) as $i) {
            self::assertTrue(
                \in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
                'target must be in list of targets',
            );
        }
    }

    public function testFnv1AHash(): void
    {
        $hasher  = new Fnv1AHasher();
        $result1 = $hasher->hash('test');
        $result2 = $hasher->hash('test');
        $result3 = $hasher->hash('different');

        self::assertEquals($result1, $result2);
        self::assertNotEquals($result1, $result3); // fragile but worthwhile
    }

    public function testFnv1AHashSpaceLookupsAreValidTargets(): void
    {
        $targets = [];
        foreach (range(1, 10) as $i) {
            $targets[] = \sprintf('target%s', $i);
        }

        $hashSpace = new ConsistentHash(new Fnv1AHasher());
        $hashSpace->addTargets($targets);

        foreach (range(1, 10) as $i) {
            self::assertTrue(
                \in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
                'target must be in list of targets',
            );
        }
    }

    public function testMd5Hash(): void
    {
        $hasher  = new Md5Hasher();
        $result1 = $hasher->hash('test');
        $result2 = $hasher->hash('test');
        $result3 = $hasher->hash('different');

        self::assertEquals($result1, $result2);
        self::assertNotEquals($result1, $result3); // fragile but worthwhile
    }

    public function testMd5HashSpaceLookupsAreValidTargets(): void
    {
        $targets = [];
        foreach (range(1, 10) as $i) {
            $targets[] = \sprintf('target%s', $i);
        }

        $hashSpace = new ConsistentHash(new Md5Hasher());
        $hashSpace->addTargets($targets);

        foreach (range(1, 10) as $i) {
            self::assertTrue(
                \in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
                'target must be in list of targets',
            );
        }
    }

    public function testMurmur3Hash(): void
    {
        $hasher  = new Murmur3Hasher();
        $result1 = $hasher->hash('test');
        $result2 = $hasher->hash('test');
        $result3 = $hasher->hash('different');

        self::assertEquals($result1, $result2);
        self::assertNotEquals($result1, $result3); // fragile but worthwhile
    }

    public function testMurmur3HashSpaceLookupsAreValidTargets(): void
    {
        $targets = [];
        foreach (range(1, 10) as $i) {
            $targets[] = \sprintf('target%s', $i);
        }

        $hashSpace = new ConsistentHash(new Murmur3Hasher());
        $hashSpace->addTargets($targets);

        foreach (range(1, 10) as $i) {
            self::assertTrue(
                \in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
                'target must be in list of targets',
            );
        }
    }

    public function testXxh32Hash(): void
    {
        $hasher  = new Xxh32Hasher();
        $result1 = $hasher->hash('test');
        $result2 = $hasher->hash('test');
        $result3 = $hasher->hash('different');

        self::assertEquals($result1, $result2);
        self::assertNotEquals($result1, $result3); // fragile but worthwhile
    }

    public function testXxh32HashSpaceLookupsAreValidTargets(): void
    {
        $targets = [];
        foreach (range(1, 10) as $i) {
            $targets[] = \sprintf('target%s', $i);
        }

        $hashSpace = new ConsistentHash(new Xxh32Hasher());
        $hashSpace->addTargets($targets);

        foreach (range(1, 10) as $i) {
            self::assertTrue(
                \in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
                'target must be in list of targets',
            );
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/**
6			* This file is part of Esi\ConsistentHash.
7			*
8			* (c) Eric Sizemore <[email protected]>
9			* (c) Paul Annesley <[email protected]>
10			*
11			* This source file is subject to the MIT license. For the full copyright and
12			* license information, please view the LICENSE file that was distributed with
13			* this source code.
14			*/
15
16			namespace Esi\ConsistentHash\Tests\Hasher;
17
18			use Esi\ConsistentHash\ConsistentHash;
19			use Esi\ConsistentHash\Hasher\Crc32Hasher;
20			use Esi\ConsistentHash\Hasher\Fnv1AHasher;
21			use Esi\ConsistentHash\Hasher\Md5Hasher;
22			use Esi\ConsistentHash\Hasher\Murmur3Hasher;
23			use Esi\ConsistentHash\Hasher\Xxh32Hasher;
24			use PHPUnit\Framework\Attributes\CoversClass;
25			use PHPUnit\Framework\Attributes\UsesClass;
26			use PHPUnit\Framework\TestCase;
27
28			/**
29			* @internal
30			*/
31			#[CoversClass(Crc32Hasher::class)]
32			#[CoversClass(Fnv1AHasher::class)]
33			#[CoversClass(Md5Hasher::class)]
34			#[CoversClass(Murmur3Hasher::class)]
35			#[CoversClass(Xxh32Hasher::class)]
36			#[UsesClass(ConsistentHash::class)]
37			class HasherTest extends TestCase
38			{
39			public function testCrc32Hash(): void
40			{
41			$hasher = new Crc32Hasher();
42			$result1 = $hasher->hash('test');
43			$result2 = $hasher->hash('test');
44			$result3 = $hasher->hash('different');
45
46			self::assertEquals($result1, $result2);
47			self::assertNotEquals($result1, $result3); // fragile but worthwhile
48			}
49
50			public function testCrc32HashSpaceLookupsAreValidTargets(): void
51			{
52			$targets = [];
53			foreach (range(1, 10) as $i) {
54			$targets[] = \sprintf('target%s', $i);
55			}
56
57			$hashSpace = new ConsistentHash(new Crc32Hasher());
58			$hashSpace->addTargets($targets);
59
60			foreach (range(1, 10) as $i) {
61			self::assertTrue(
62			\in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
63			'target must be in list of targets',
64			);
65			}
66			}
67
68			public function testFnv1AHash(): void
69			{
70			$hasher = new Fnv1AHasher();
71			$result1 = $hasher->hash('test');
72			$result2 = $hasher->hash('test');
73			$result3 = $hasher->hash('different');
74
75			self::assertEquals($result1, $result2);
76			self::assertNotEquals($result1, $result3); // fragile but worthwhile
77			}
78
79			public function testFnv1AHashSpaceLookupsAreValidTargets(): void
80			{
81			$targets = [];
82			foreach (range(1, 10) as $i) {
83			$targets[] = \sprintf('target%s', $i);
84			}
85
86			$hashSpace = new ConsistentHash(new Fnv1AHasher());
87			$hashSpace->addTargets($targets);
88
89			foreach (range(1, 10) as $i) {
90			self::assertTrue(
91			\in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
92			'target must be in list of targets',
93			);
94			}
95			}
96
97			public function testMd5Hash(): void
98			{
99			$hasher = new Md5Hasher();
100			$result1 = $hasher->hash('test');
101			$result2 = $hasher->hash('test');
102			$result3 = $hasher->hash('different');
103
104			self::assertEquals($result1, $result2);
105			self::assertNotEquals($result1, $result3); // fragile but worthwhile
106			}
107
108			public function testMd5HashSpaceLookupsAreValidTargets(): void
109			{
110			$targets = [];
111			foreach (range(1, 10) as $i) {
112			$targets[] = \sprintf('target%s', $i);
113			}
114
115			$hashSpace = new ConsistentHash(new Md5Hasher());
116			$hashSpace->addTargets($targets);
117
118			foreach (range(1, 10) as $i) {
119			self::assertTrue(
120			\in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
121			'target must be in list of targets',
122			);
123			}
124			}
125
126			public function testMurmur3Hash(): void
127			{
128			$hasher = new Murmur3Hasher();
129			$result1 = $hasher->hash('test');
130			$result2 = $hasher->hash('test');
131			$result3 = $hasher->hash('different');
132
133			self::assertEquals($result1, $result2);
134			self::assertNotEquals($result1, $result3); // fragile but worthwhile
135			}
136
137			public function testMurmur3HashSpaceLookupsAreValidTargets(): void
138			{
139			$targets = [];
140			foreach (range(1, 10) as $i) {
141			$targets[] = \sprintf('target%s', $i);
142			}
143
144			$hashSpace = new ConsistentHash(new Murmur3Hasher());
145			$hashSpace->addTargets($targets);
146
147			foreach (range(1, 10) as $i) {
148			self::assertTrue(
149			\in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
150			'target must be in list of targets',
151			);
152			}
153			}
154
155			public function testXxh32Hash(): void
156			{
157			$hasher = new Xxh32Hasher();
158			$result1 = $hasher->hash('test');
159			$result2 = $hasher->hash('test');
160			$result3 = $hasher->hash('different');
161
162			self::assertEquals($result1, $result2);
163			self::assertNotEquals($result1, $result3); // fragile but worthwhile
164			}
165
166			public function testXxh32HashSpaceLookupsAreValidTargets(): void
167			{
168			$targets = [];
169			foreach (range(1, 10) as $i) {
170			$targets[] = \sprintf('target%s', $i);
171			}
172
173			$hashSpace = new ConsistentHash(new Xxh32Hasher());
174			$hashSpace->addTargets($targets);
175
176			foreach (range(1, 10) as $i) {
177			self::assertTrue(
178			\in_array($hashSpace->lookup(\sprintf('r%s', $i)), $targets, true),
179			'target must be in list of targets',
180			);
181			}
182			}
183			}
184

ericsizemore / consistent-hash

Push — main ( ddf3a0...f0c061 )

testFnv1AHashSpaceLookupsAreValidTargets() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like