Add javadocs to SplitInfo, and make the unit tests a bit more specific with what they check

Author: pupnewfster

src/main/java/mekanism/common/lib/distribution/SplitInfo.java

@@ -2,23 +2,63 @@
 
 public abstract class SplitInfo<TYPE extends Number & Comparable<TYPE>> {
 
+    /**
+     * Number of targets to split the contents among.
+     */
     protected int toSplitAmong;
+    /**
+     * Represents whether the amount per target distribution has changed. This may happen if a target doesn't need as much as we are willing to offer it in the split.
+     */
     public boolean amountPerChanged = false;
+    /**
+     * Determines whether the number of targets to split amount should be decreased.
+     *
+     * @implNote This is only set to false briefly when handling accepting contents with remainders to allow them to accept some of the contents without being marked as
+     * fully accounted for.
+     */
     protected boolean decrementTargets = true;
 
     protected SplitInfo(int totalTargets) {
         this.toSplitAmong = totalTargets;
     }
 
+    /**
+     * Marks the given amount as being accounted for and "sent". Decrements {@link #getUnsent() how much we have left to send} and increments
+     * {@link #getTotalSent() how much we have sent}. If {@link #decrementTargets} is true, this also will reduce the number of targets to split among, and recalculate
+     * how much we can provide each target.
+     *
+     * @param amountNeeded Amount needed by the target and that we are accounting as having been sent to the target.
+     */
     public abstract void send(TYPE amountNeeded);
 
+    /**
+     * {@return the "share" each target should get when distributing in an even split}
+     */
     public abstract TYPE getShareAmount();
 
+    /**
+     * Gets the "share" including a potential remainder that targets should get when handling remainders. This is used for actually sending providing the split share to
+     * any targets that can accept more than we are able to offer in an even split. In general this number will either be equal to {@link #getShareAmount()} or greater
+     * than it by one while we still have an excess remainder.
+     *
+     * @return the "share" plus any potential remainder.
+     */
     public abstract TYPE getRemainderAmount();
 
+    /**
+     * {@return the amount of contents that has not been sent anywhere yet}
+     */
     public abstract TYPE getUnsent();
 
+    /**
+     * {@return true if the value is equal to zero}
+     *
+     * @param value Value to check
+     */
     public abstract boolean isZero(TYPE value);
 
+    /**
+     * {@return the total amount of contents that have been sent}
+     */
     public abstract TYPE getTotalSent();
 }

src/main/java/mekanism/common/lib/distribution/Target.java

@@ -83,6 +83,8 @@ public void sendRemainingSplit(SplitInfo<TYPE> splitInfo) {
                     splitInfo.decrementTargets = true;
                 }
             }
+            //TODO: If we remove buffers maybe we should evaluate not caring if we don't actually send the full excess remainder?
+            // Given ideally we wouldn't attempting to insert the excess remainder to handlers as a second call to the handler on the same tick
             if (!splitInfo.isZero(splitInfo.getUnsent())) {
                 //If we still have some of a remainder after trying to evenly distribute the remainder just send it to the first target willing to accept it
                 // This might happen if one of the destinations was only able to accept part of the remaining amount, though in general that case will be

src/test/java/mekanism/common/lib/distribution/DistributionTest.java

@@ -86,18 +86,26 @@ void testCorrectRemainder() {
     void testCorrectFallbackRemainder() {
         int toSend = 9;
         IntegerTarget availableAcceptors = new IntegerTarget();
-        availableAcceptors.addHandler(new SpecificAmountIntegerHandler(8));
-        availableAcceptors.addHandler(new LyingAmountIntegerHandler(1, 10));
+        IntegerHandler specificHandler = new SpecificAmountIntegerHandler(8);
+        IntegerHandler lyingHandler = new LyingAmountIntegerHandler(1, 10);
+        availableAcceptors.addHandler(specificHandler);
+        availableAcceptors.addHandler(lyingHandler);
         Assertions.assertEquals(toSend, EmitUtils.sendToAcceptors(availableAcceptors, toSend, toSend));
+        Assertions.assertEquals(1, lyingHandler.getAccepted());
+        Assertions.assertEquals(8, specificHandler.getAccepted());
     }
 
     @Test
     @DisplayName("Test to check if the remainder is able to be sent when having to fall back using the reversed order for the handlers")
     void testCorrectFallbackRemainderAltOrder() {
         int toSend = 9;
         IntegerTarget availableAcceptors = new IntegerTarget();
-        availableAcceptors.addHandler(new LyingAmountIntegerHandler(1, 10));
-        availableAcceptors.addHandler(new SpecificAmountIntegerHandler(8));
+        IntegerHandler specificHandler = new SpecificAmountIntegerHandler(8);
+        IntegerHandler lyingHandler = new LyingAmountIntegerHandler(1, 10);
+        availableAcceptors.addHandler(lyingHandler);
+        availableAcceptors.addHandler(specificHandler);
         Assertions.assertEquals(toSend, EmitUtils.sendToAcceptors(availableAcceptors, toSend, toSend));
+        Assertions.assertEquals(1, lyingHandler.getAccepted());
+        Assertions.assertEquals(8, specificHandler.getAccepted());
     }
 }