#1125 Create persistence of LimboPlayers in segment files (work in progress)

- Instead of one huge file or a file for each player, allow the user to define how many files he wants to distribute the LimboPlayers over. This is based on a function that creates a String (segment ID) based on the player's UUID.

src/test/java/fr/xephi/authme/data/limbo/persistence/SegmentConfigurationTest.java

@@ -0,0 +1,47 @@
+package fr.xephi.authme.data.limbo.persistence;
+
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.junit.Assert.fail;
+
+/**
+ * Test for {@link SegmentConfiguration}.
+ */
+public class SegmentConfigurationTest {
+
+    @Test
+    public void shouldHaveDistributionThatIsPowerOf2() {
+        // given
+        Set<Integer> allowedDistributions = ImmutableSet.of(1, 2, 4, 8, 16);
+
+        // when / then
+        for (SegmentConfiguration entry : SegmentConfiguration.values()) {
+            if (!allowedDistributions.contains(entry.getDistribution())) {
+                fail("Distribution must be a power of 2 and within [1, 16]. Offending item: " + entry);
+            }
+        }
+    }
+
+    @Test
+    public void shouldHaveDifferentSegmentSizes() {
+        // given
+        Set<Integer> sizes = new HashSet<>();
+
+        // when / then
+        for (SegmentConfiguration entry : SegmentConfiguration.values()) {
+            int segSize = (int) Math.pow(entry.getDistribution(), entry.getLength());
+            assertThat(entry + " must have a positive segment size",
+                segSize, greaterThan(0));
+
+            assertThat(entry + " has a segment size that was already encountered (" + segSize + ")",
+                sizes.add(segSize), equalTo(true));
+        }
+    }
+}

src/test/java/fr/xephi/authme/data/limbo/persistence/SegmentNameBuilderTest.java

@@ -0,0 +1,153 @@
+package fr.xephi.authme.data.limbo.persistence;
+
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.EIGHT;
+import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.FOUR;
+import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.ONE;
+import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.SIXTEEN;
+import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.SIXTY_FOUR;
+import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.THIRTY_TWO;
+import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.TWO;
+import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.TWO_FIFTY;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Test for {@link SegmentNameBuilder}.
+ */
+public class SegmentNameBuilderTest {
+
+    /**
+     * Checks that using a given segment size really produces as many segments as defined.
+     * E.g. if we partition with {@link SegmentConfiguration#EIGHT} we expect eight different buckets.
+     */
+    @Test
+    public void shouldCreatePromisedSizeOfSegments() {
+        for (SegmentConfiguration part : SegmentConfiguration.values()) {
+            // Perform this check only for `length` <= 5 because the test creates all hex numbers with `length` digits.
+            if (part.getLength() <= 5) {
+                checkTotalSegmentsProduced(part);
+            }
+        }
+    }
+
+    private void checkTotalSegmentsProduced(SegmentConfiguration part) {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(part);
+        Set<String> encounteredSegments = new HashSet<>();
+        int shift = part.getLength() * 4;
+        // e.g. (1 << 16) - 1 = 0xFFFF. (Number of digits = shift/4, since 16 = 2^4)
+        int max = (1 << shift) - 1;
+
+        // when
+        for (int i = 0; i <= max; ++i) {
+            String uuid = toPaddedHex(i, part.getLength());
+            encounteredSegments.add(nameBuilder.createSegmentName(uuid));
+        }
+
+        // then
+        assertThat(encounteredSegments, hasSize(part.getTotalSegments()));
+    }
+
+    private static String toPaddedHex(int dec, int padLength) {
+        String hexResult = Integer.toString(dec, 16);
+        while (hexResult.length() < padLength) {
+            hexResult = "0" + hexResult;
+        }
+        return hexResult;
+    }
+
+    @Test
+    public void shouldCreateOneSegment() {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(ONE);
+
+        // when / then
+        assertThat(nameBuilder.createSegmentName("abc"), equalTo("seg1-0"));
+        assertThat(nameBuilder.createSegmentName("f0e"), equalTo("seg1-0"));
+        assertThat(nameBuilder.createSegmentName("329"), equalTo("seg1-0"));
+    }
+
+    @Test
+    public void shouldCreateTwoSegments() {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(TWO);
+
+        // when / then
+        assertThat(nameBuilder.createSegmentName("f6c"), equalTo("seg2-1"));
+        assertThat(nameBuilder.createSegmentName("29f"), equalTo("seg2-0"));
+        assertThat(nameBuilder.createSegmentName("983"), equalTo("seg2-1"));
+    }
+
+    @Test
+    public void shouldCreateFourSegments() {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(FOUR);
+
+        // when / then
+        assertThat(nameBuilder.createSegmentName("f9cc"), equalTo("seg4-3"));
+        assertThat(nameBuilder.createSegmentName("84c9"), equalTo("seg4-2"));
+        assertThat(nameBuilder.createSegmentName("3799"), equalTo("seg4-0"));
+    }
+
+    @Test
+    public void shouldCreateEightSegments() {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(EIGHT);
+
+        // when / then
+        assertThat(nameBuilder.createSegmentName("fc9c"), equalTo("seg8-7"));
+        assertThat(nameBuilder.createSegmentName("90ad"), equalTo("seg8-4"));
+        assertThat(nameBuilder.createSegmentName("35e4"), equalTo("seg8-1"));
+        assertThat(nameBuilder.createSegmentName("a39f"), equalTo("seg8-5"));
+    }
+
+    @Test
+    public void shouldCreateSixteenSegments() {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(SIXTEEN);
+
+        // when / then
+        assertThat(nameBuilder.createSegmentName("fc9a054"), equalTo("seg16-f"));
+        assertThat(nameBuilder.createSegmentName("b0a945e"), equalTo("seg16-b"));
+        assertThat(nameBuilder.createSegmentName("7afebab"), equalTo("seg16-7"));
+    }
+
+    @Test
+    public void shouldCreateThirtyTwoSegments() {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(THIRTY_TWO);
+
+        // when / then
+        assertThat(nameBuilder.createSegmentName("f890c9"), equalTo("seg32-11101"));
+        assertThat(nameBuilder.createSegmentName("49c39a"), equalTo("seg32-01101"));
+        assertThat(nameBuilder.createSegmentName("b75d09"), equalTo("seg32-10010"));
+    }
+
+    @Test
+    public void shouldCreateSixtyFourSegments() {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(SIXTY_FOUR);
+
+        // when / then
+        assertThat(nameBuilder.createSegmentName("82f"), equalTo("seg64-203"));
+        assertThat(nameBuilder.createSegmentName("9b4"), equalTo("seg64-221"));
+        assertThat(nameBuilder.createSegmentName("068"), equalTo("seg64-012"));
+    }
+
+    @Test
+    public void shouldCreate256Segments() {
+        // given
+        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(TWO_FIFTY);
+
+        // when / then
+        assertThat(nameBuilder.createSegmentName("a813c"), equalTo("seg256-a8"));
+        assertThat(nameBuilder.createSegmentName("b4d01"), equalTo("seg256-b4"));
+        assertThat(nameBuilder.createSegmentName("7122f"), equalTo("seg256-71"));
+    }
+}