diff --git a/src/main/java/appeng/client/render/AppEngRenderItem.java b/src/main/java/appeng/client/render/AppEngRenderItem.java index 423832548..25313be30 100644 --- a/src/main/java/appeng/client/render/AppEngRenderItem.java +++ b/src/main/java/appeng/client/render/AppEngRenderItem.java @@ -30,12 +30,21 @@ import net.minecraft.item.ItemStack; import appeng.api.storage.data.IAEItemStack; import appeng.core.AEConfig; import appeng.core.localization.GuiText; +import appeng.util.ISlimReadableNumberConverter; +import appeng.util.IWideReadableNumberConverter; import appeng.util.ReadableNumberConverter; +/** + * @author AlgorithmX2 + * @author thatsIch + * @version rv2 + * @since rv0 + */ public class AppEngRenderItem extends RenderItem { - private static final ReadableNumberConverter NUMBER_CONVERTER = ReadableNumberConverter.INSTANCE; + private static final ISlimReadableNumberConverter SLIM_CONVERTER = ReadableNumberConverter.INSTANCE; + private static final IWideReadableNumberConverter WIDE_CONVERTER = ReadableNumberConverter.INSTANCE; public IAEItemStack aeStack; @@ -125,11 +134,11 @@ public class AppEngRenderItem extends RenderItem { if( AEConfig.instance.useTerminalUseLargeFont() ) { - return NUMBER_CONVERTER.toShortHumanReadableForm( originalSize ); + return SLIM_CONVERTER.toSlimReadableForm( originalSize ); } else { - return NUMBER_CONVERTER.toLongHumanReadableForm( originalSize ); + return WIDE_CONVERTER.toWideReadableForm( originalSize ); } } } diff --git a/src/main/java/appeng/client/render/blocks/RenderBlockCraftingCPUMonitor.java b/src/main/java/appeng/client/render/blocks/RenderBlockCraftingCPUMonitor.java index a68753efa..89ab5e687 100644 --- a/src/main/java/appeng/client/render/blocks/RenderBlockCraftingCPUMonitor.java +++ b/src/main/java/appeng/client/render/blocks/RenderBlockCraftingCPUMonitor.java @@ -37,13 +37,20 @@ import appeng.client.ClientHelper; import appeng.core.AELog; import appeng.tile.AEBaseTile; import appeng.tile.crafting.TileCraftingMonitorTile; +import appeng.util.IWideReadableNumberConverter; import appeng.util.Platform; import appeng.util.ReadableNumberConverter; +/** + * @author AlgorithmX2 + * @author thatsIch + * @version rv2 + * @since rv1 + */ public class RenderBlockCraftingCPUMonitor extends RenderBlockCraftingCPU { - private static final ReadableNumberConverter NUMBER_CONVERTER = ReadableNumberConverter.INSTANCE; + private static final IWideReadableNumberConverter NUMBER_CONVERTER = ReadableNumberConverter.INSTANCE; public RenderBlockCraftingCPUMonitor() { @@ -177,7 +184,7 @@ public class RenderBlockCraftingCPUMonitor extends RenderBlockCraftingCPU GL11.glScalef( 1.0f / 62.0f, 1.0f / 62.0f, 1.0f / 62.0f ); final long stackSize = ais.getStackSize(); - final String renderedStackSize = NUMBER_CONVERTER.toHumanReadableForm( stackSize ); + final String renderedStackSize = NUMBER_CONVERTER.toWideReadableForm( stackSize ); FontRenderer fr = Minecraft.getMinecraft().fontRenderer; int width = fr.getStringWidth( renderedStackSize ); diff --git a/src/main/java/appeng/parts/reporting/PartStorageMonitor.java b/src/main/java/appeng/parts/reporting/PartStorageMonitor.java index bf2cc2341..2a9409784 100644 --- a/src/main/java/appeng/parts/reporting/PartStorageMonitor.java +++ b/src/main/java/appeng/parts/reporting/PartStorageMonitor.java @@ -59,14 +59,21 @@ import appeng.core.AELog; import appeng.core.localization.PlayerMessages; import appeng.helpers.Reflected; import appeng.me.GridAccessException; +import appeng.util.IWideReadableNumberConverter; import appeng.util.Platform; import appeng.util.ReadableNumberConverter; import appeng.util.item.AEItemStack; +/** + * @author AlgorithmX2 + * @author thatsIch + * @version rv2 + * @since rv0 + */ public class PartStorageMonitor extends PartMonitor implements IPartStorageMonitor, IStackWatcherHost { - private static final ReadableNumberConverter NUMBER_CONVERTER = ReadableNumberConverter.INSTANCE; + private static final IWideReadableNumberConverter NUMBER_CONVERTER = ReadableNumberConverter.INSTANCE; IAEItemStack configuredItem; boolean isLocked; IStackWatcher myWatcher; @@ -341,7 +348,7 @@ public class PartStorageMonitor extends PartMonitor implements IPartStorageMonit GL11.glScalef( 1.0f / 62.0f, 1.0f / 62.0f, 1.0f / 62.0f ); final long stackSize = ais.getStackSize(); - final String renderedStackSize = NUMBER_CONVERTER.toHumanReadableForm( stackSize ); + final String renderedStackSize = NUMBER_CONVERTER.toWideReadableForm( stackSize ); FontRenderer fr = Minecraft.getMinecraft().fontRenderer; int width = fr.getStringWidth( renderedStackSize ); diff --git a/src/main/java/appeng/util/ISlimReadableNumberConverter.java b/src/main/java/appeng/util/ISlimReadableNumberConverter.java new file mode 100644 index 000000000..8c9a75d9a --- /dev/null +++ b/src/main/java/appeng/util/ISlimReadableNumberConverter.java @@ -0,0 +1,31 @@ +package appeng.util; + + +import javax.annotation.Nonnegative; + + +/** + * Limits a number converter to a char width of at max 3 characters. + * This is generally used for players, who activated the large font extension. + * + * @author thatsIch + * @version rv2 + * @since rv2 + */ +public interface ISlimReadableNumberConverter +{ + /** + * Converts a number into a human readable form. It will not round the number, but down it. + * Will try to cut the number down 1 decimal later, but rarely because of the 3 width limitation. + * Can only handle non negative numbers + * + * Example: + * 10000L -> 10K + * 9999L -> 9K, not 9.9K cause 4 width + * + * @param number to be converted number + * + * @return String in SI format cut down as far as possible + */ + String toSlimReadableForm( @Nonnegative long number ); +} diff --git a/src/main/java/appeng/util/IWideReadableNumberConverter.java b/src/main/java/appeng/util/IWideReadableNumberConverter.java new file mode 100644 index 000000000..b3fae6c2e --- /dev/null +++ b/src/main/java/appeng/util/IWideReadableNumberConverter.java @@ -0,0 +1,30 @@ +package appeng.util; + + +import javax.annotation.Nonnegative; + + +/** + * Limits a number converter to a char width of at max 4 characters + * + * @author thatsIch + * @version rv2 + * @since rv2 + */ +public interface IWideReadableNumberConverter +{ + /** + * Converts a number into a human readable form. It will not round the number, but down it. + * Will try to cut the number down 1 decimal later if width can be below 4. + * Can only handle non negative numbers + * + * Example: + * 10000L -> 10K + * 9999L -> 9999 + * + * @param number to be converted number + * + * @return String in SI format cut down as far as possible + */ + String toWideReadableForm( @Nonnegative long number ); +} diff --git a/src/main/java/appeng/util/ReadableNumberConverter.java b/src/main/java/appeng/util/ReadableNumberConverter.java index 6bda3b59b..4a6404e26 100644 --- a/src/main/java/appeng/util/ReadableNumberConverter.java +++ b/src/main/java/appeng/util/ReadableNumberConverter.java @@ -1,6 +1,12 @@ package appeng.util; +import java.math.RoundingMode; +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; +import java.text.Format; + + /** * Converter class to convert a large number into a SI system. * @@ -8,7 +14,7 @@ package appeng.util; * @version rv2 * @since rv2 */ -public enum ReadableNumberConverter +public enum ReadableNumberConverter implements ISlimReadableNumberConverter, IWideReadableNumberConverter { INSTANCE; @@ -17,125 +23,82 @@ public enum ReadableNumberConverter */ private static final int DIVISION_BASE = 1000; - /** - * for lg(1000) = 3, just saves some calculation - */ - private static final double LOG_DIVISION_BASE = Math.log( DIVISION_BASE ); - /** * String representation of the sorted postfixes */ private static final char[] ENCODED_POSTFIXES = "KMGTPE".toCharArray(); - /** - * if a result would be higher than this threshold, - * it is pushed into the next bigger group, - * so the display string is shorter - */ - private static final int SHORT_THRESHOLD = 100; + private final Format format; /** - * Converts a number into a human readable form. It will not round the number, but floor it. - * - * Example: 15555L -> 15.5K - * - * @param number to be converted number - * - * @return String in SI format cut down as far as possible + * Initializes the specific decimal format with special format for negative and positive numbers */ - public String toHumanReadableForm( long number ) + ReadableNumberConverter() { - final String sign = this.getSign( number ); - final long absNumber = Math.abs( number ); + final DecimalFormatSymbols symbols = new DecimalFormatSymbols(); + symbols.setDecimalSeparator( '.' ); + final DecimalFormat format = new DecimalFormat( ".#;0.#" ); + format.setDecimalFormatSymbols( symbols ); + format.setRoundingMode( RoundingMode.DOWN ); - if( absNumber < DIVISION_BASE ) - return Long.toString( number ); + this.format = format; + } - final int exp = (int) ( Math.log( absNumber ) / LOG_DIVISION_BASE ); - final char postFix = ENCODED_POSTFIXES[exp - 1]; - final int result = (int) ( absNumber / Math.pow( DIVISION_BASE, exp ) ); - - return String.format( "%s%d%s", sign, result, postFix ); + @Override + public String toSlimReadableForm( long number ) + { + return this.toReadableFormRestrictedByWidth( number, 3 ); } /** - * Gets character representation of the sign of a number + * restricts a string representation of a number to a specific width * - * @param number maybe signed number + * @param number to be formatted number + * @param width width limitation of the resulting number * - * @return '-' if the number is signed, else an empty character + * @return formatted number restricted by the width limitation */ - private String getSign( long number ) + private String toReadableFormRestrictedByWidth( long number, int width ) { - if( number < 0 ) + assert number >= 0; + + // handles low numbers more efficiently since no format is needed + final String numberString = Long.toString( number ); + int numberSize = numberString.length(); + if( numberSize <= width ) + return numberString; + + long base = number; + double last = base * 1000; + int exponent = -1; + String postFix = ""; + + while( numberSize > width ) { - return "-"; - } - else - { - return ""; + last = base; + base /= DIVISION_BASE; + + exponent++; + + // adds +1 due to the postfix + numberSize = Long.toString( base ).length() + 1; + postFix = String.valueOf( ENCODED_POSTFIXES[exponent] ); } + + final String withPrecision = this.format.format( last / DIVISION_BASE ) + postFix; + final String withoutPrecision = Long.toString( base ) + postFix; + + final String slimResult = ( withPrecision.length() <= width ) ? withPrecision : withoutPrecision; + + // post condition + assert slimResult.length() <= width; + + return slimResult; } - /** - * Converts a number into a human readable form. It will not round the number, but floor it. - * Will try to cut the number down 1 decimal earlier. This will limit the String size to 3 chars. - * - * Example: 900L -> 0.9K - * - * @param number to be converted number - * - * @return String in SI format cut down as far as possible - */ - public String toShortHumanReadableForm( long number ) + @Override + public String toWideReadableForm( final long number ) { - final String sign = this.getSign( number ); - final long absNumber = Math.abs( number ); - - if( absNumber < DIVISION_BASE ) - return Long.toString( number ); - - final int exp = (int) ( Math.log( absNumber ) / LOG_DIVISION_BASE ); - final int result = (int) ( absNumber / Math.pow( DIVISION_BASE, exp ) ); - if( result >= SHORT_THRESHOLD ) - { - final int shortResult = result / SHORT_THRESHOLD; - final char postFix = ENCODED_POSTFIXES[exp]; - - return String.format( "%s.%d%s", sign, shortResult, postFix ); - } - else - { - final char postFix = ENCODED_POSTFIXES[exp - 1]; - - return String.format( "%s%d%s", sign, result, postFix ); - } - } - - /** - * Converts a number into a human readable form. It will not round the number, but floor it. - * Will try to cut the number down 1 decimal later. - * - * Example: - * 10000L -> 10K - * 9999L -> 9999 - * - * @param number to be converted number - * - * @return String in SI format cut down as far as possible - */ - public String toLongHumanReadableForm( long number ) - { - final String sign = this.getSign( number ); - final long absNumber = Math.abs( number ); - - if( absNumber < 10 * DIVISION_BASE ) - return Long.toString( number ); - - final int exp = (int) ( Math.log( absNumber / 10 ) / LOG_DIVISION_BASE ); - final int result = (int) ( absNumber / Math.pow( DIVISION_BASE, exp ) ); - final char postFix = ENCODED_POSTFIXES[exp - 1]; - - return String.format( "%s%d%s", sign, result, postFix ); + return this.toReadableFormRestrictedByWidth( number, 4 ); } } diff --git a/src/test/java/appeng/util/LongReadableNumberConverterTest.java b/src/test/java/appeng/util/LongReadableNumberConverterTest.java deleted file mode 100644 index 48a2038a2..000000000 --- a/src/test/java/appeng/util/LongReadableNumberConverterTest.java +++ /dev/null @@ -1,138 +0,0 @@ -package appeng.util; - - -import org.junit.Test; - -import static org.junit.Assert.assertEquals; - - -/** - * Tests for {@link appeng.util.ReadableNumberConverter} - * - * @author thatsIch - * @version rv2 - * @since rv2 - */ -public class LongReadableNumberConverterTest -{ - private static final long NUMBER_LOW = 999L; - private static final long NUMBER_NORMAL = 9999L; - private static final long NUMBER_BORDER = 10000L; - private static final long NUMBER_KILO = 155555L; - private static final long NUMBER_KILO_BORDER = 9999999L; - private static final long NUMBER_MEGA_STEP = 10000000; - private static final long NUMBER_MEGA = 155555555L; - private static final long NUMBER_GIGA = 155555555555L; - private static final long NUMBER_TERA = 155555555555555L; - private static final long NUMBER_PETA = 155555555555555555L; - private static final long NUMBER_EXA = 1555555555555555555L; - private static final long NUMBER_NEGATIVE_LOW = -999L; - private static final long NUMBER_NEGATIVE_NORMAL = -9999L; - private static final long NUMBER_NEGATIVE_GIGA = -155555555555L; - - private static final String RESULT_LONG_LOW = "999"; - private static final String RESULT_LONG_NORMAL = "9999"; - private static final String RESULT_LONG_BORDER = "10K"; - private static final String RESULT_LONG_KILO = "155K"; - private static final String RESULT_LONG_KILO_BORDER = "9999K"; - private static final String RESULT_LONG_MEGA_STEP = "10M"; - private static final String RESULT_LONG_MEGA = "155M"; - private static final String RESULT_LONG_GIGA = "155G"; - private static final String RESULT_LONG_TERA = "155T"; - private static final String RESULT_LONG_PETA = "155P"; - private static final String RESULT_LONG_EXA = "1555P"; - private static final String RESULT_LONG_NEGATIVE_LOW = "-999"; - private static final String RESULT_LONG_NEGATIVE_NORMAL = "-9999"; - private static final String RESULT_LONG_NEGATIVE_GIGA = "-155G"; - - private final ReadableNumberConverter converter; - - public LongReadableNumberConverterTest() - { - this.converter = ReadableNumberConverter.INSTANCE; - } - - @Test - public void testConvertLongNormal() - { - assertEquals( RESULT_LONG_NORMAL, this.converter.toLongHumanReadableForm( NUMBER_NORMAL ) ); - } - - @Test - public void testConvertLongKiloBorder() - { - assertEquals( RESULT_LONG_KILO_BORDER, this.converter.toLongHumanReadableForm( NUMBER_KILO_BORDER ) ); - } - - @Test - public void testConvertLongMegaStep() - { - assertEquals( RESULT_LONG_MEGA_STEP, this.converter.toLongHumanReadableForm( NUMBER_MEGA_STEP ) ); - } - - @Test - public void testConvertLongLow() - { - assertEquals( RESULT_LONG_LOW, this.converter.toLongHumanReadableForm( NUMBER_LOW ) ); - } - - @Test - public void testConvertLongBorder() - { - assertEquals( RESULT_LONG_BORDER, this.converter.toLongHumanReadableForm( NUMBER_BORDER ) ); - } - - @Test - public void testConvertLongKilo() - { - assertEquals( RESULT_LONG_KILO, this.converter.toLongHumanReadableForm( NUMBER_KILO ) ); - } - - @Test - public void testConvertLongMega() - { - assertEquals( RESULT_LONG_MEGA, this.converter.toLongHumanReadableForm( NUMBER_MEGA ) ); - } - - @Test - public void testConvertLongGiga() - { - assertEquals( RESULT_LONG_GIGA, this.converter.toLongHumanReadableForm( NUMBER_GIGA ) ); - } - - @Test - public void testConvertLongTera() - { - assertEquals( RESULT_LONG_TERA, this.converter.toLongHumanReadableForm( NUMBER_TERA ) ); - } - - @Test - public void testConvertLongPeta() - { - assertEquals( RESULT_LONG_PETA, this.converter.toLongHumanReadableForm( NUMBER_PETA ) ); - } - - @Test - public void testConvertLongExa() - { - assertEquals( RESULT_LONG_EXA, this.converter.toLongHumanReadableForm( NUMBER_EXA ) ); - } - - @Test - public void testConvertLongNegativeLow() - { - assertEquals( RESULT_LONG_NEGATIVE_LOW, this.converter.toLongHumanReadableForm( NUMBER_NEGATIVE_LOW ) ); - } - - @Test - public void testConvertLongNegativeNormal() - { - assertEquals( RESULT_LONG_NEGATIVE_NORMAL, this.converter.toLongHumanReadableForm( NUMBER_NEGATIVE_NORMAL ) ); - } - - @Test - public void testConvertLongNegativeGiga() - { - assertEquals( RESULT_LONG_NEGATIVE_GIGA, this.converter.toLongHumanReadableForm( NUMBER_NEGATIVE_GIGA ) ); - } -} diff --git a/src/test/java/appeng/util/ReadableNumberConverterTest.java b/src/test/java/appeng/util/ReadableNumberConverterTest.java deleted file mode 100644 index 0d06527b7..000000000 --- a/src/test/java/appeng/util/ReadableNumberConverterTest.java +++ /dev/null @@ -1,147 +0,0 @@ -package appeng.util; - - -import org.junit.Test; - -import static org.junit.Assert.assertEquals; - - -/** - * Tests for {@link appeng.util.ReadableNumberConverter} - * - * @author thatsIch - * @version rv2 - * @since rv2 - */ -public final class ReadableNumberConverterTest -{ - private static final long NUMBER_NORMAL = 55L; - private static final long NUMBER_KILO = 155555L; - private static final long NUMBER_MEGA = 155555555L; - private static final long NUMBER_GIGA = 155555555555L; - private static final long NUMBER_TERA = 155555555555555L; - private static final long NUMBER_PETA = 155555555555555555L; - private static final long NUMBER_EXA = 1555555555555555555L; - private static final long NUMBER_NEGATIVE_GIGA = -155555555555L; - - private static final String RESULT_NORMAL = "55"; - private static final String RESULT_KILO = "155K"; - private static final String RESULT_MEGA = "155M"; - private static final String RESULT_GIGA = "155G"; - private static final String RESULT_TERA = "155T"; - private static final String RESULT_PETA = "155P"; - private static final String RESULT_EXA = "1E"; - private static final String RESULT_NEGATIVE_GIGA = "-155G"; - - private static final String RESULT_SHORT_NORMAL = "55"; - private static final String RESULT_SHORT_KILO = ".1M"; - private static final String RESULT_SHORT_MEGA = ".1G"; - private static final String RESULT_SHORT_GIGA = ".1T"; - private static final String RESULT_SHORT_TERA = ".1P"; - private static final String RESULT_SHORT_PETA = ".1E"; - private static final String RESULT_SHORT_EXA = "1E"; - private static final String RESULT_SHORT_NEGATIVE_GIGA = "-.1T"; - - private final ReadableNumberConverter converter; - - public ReadableNumberConverterTest() - { - this.converter = ReadableNumberConverter.INSTANCE; - } - - @Test - public void testConvertNormal() - { - assertEquals( RESULT_NORMAL, this.converter.toHumanReadableForm( NUMBER_NORMAL ) ); - } - - @Test - public void testConvertKilo() - { - assertEquals( RESULT_KILO, this.converter.toHumanReadableForm( NUMBER_KILO ) ); - } - - @Test - public void testConvertMega() - { - assertEquals( RESULT_MEGA, this.converter.toHumanReadableForm( NUMBER_MEGA ) ); - } - - @Test - public void testConvertGiga() - { - assertEquals( RESULT_GIGA, this.converter.toHumanReadableForm( NUMBER_GIGA ) ); - } - - @Test - public void testConvertTera() - { - assertEquals( RESULT_TERA, this.converter.toHumanReadableForm( NUMBER_TERA ) ); - } - - @Test - public void testConvertPeta() - { - assertEquals( RESULT_PETA, this.converter.toHumanReadableForm( NUMBER_PETA ) ); - } - - @Test - public void testConvertExa() - { - assertEquals( RESULT_EXA, this.converter.toHumanReadableForm( NUMBER_EXA ) ); - } - - @Test - public void testConvertNegativeGiga() - { - assertEquals( RESULT_NEGATIVE_GIGA, this.converter.toHumanReadableForm( NUMBER_NEGATIVE_GIGA ) ); - } - - @Test - public void testConvertShortNormal() - { - assertEquals( RESULT_SHORT_NORMAL, this.converter.toShortHumanReadableForm( NUMBER_NORMAL ) ); - } - - @Test - public void testConvertShortKilo() - { - assertEquals( RESULT_SHORT_KILO, this.converter.toShortHumanReadableForm( NUMBER_KILO ) ); - } - - @Test - public void testConvertShortMega() - { - assertEquals( RESULT_SHORT_MEGA, this.converter.toShortHumanReadableForm( NUMBER_MEGA ) ); - } - - @Test - public void testConvertShortGiga() - { - assertEquals( RESULT_SHORT_GIGA, this.converter.toShortHumanReadableForm( NUMBER_GIGA ) ); - } - - @Test - public void testConvertShortTera() - { - assertEquals( RESULT_SHORT_TERA, this.converter.toShortHumanReadableForm( NUMBER_TERA ) ); - } - - @Test - public void testConvertShortPeta() - { - assertEquals( RESULT_SHORT_PETA, this.converter.toShortHumanReadableForm( NUMBER_PETA ) ); - } - - @Test - public void testConvertShortExa() - { - assertEquals( RESULT_SHORT_EXA, this.converter.toShortHumanReadableForm( NUMBER_EXA ) ); - } - - @Test - public void testConvertShortNegativeGiga() - { - assertEquals( RESULT_SHORT_NEGATIVE_GIGA, this.converter.toShortHumanReadableForm( NUMBER_NEGATIVE_GIGA ) ); - } -} diff --git a/src/test/java/appeng/util/SlimReadableNumberConverterTest.java b/src/test/java/appeng/util/SlimReadableNumberConverterTest.java new file mode 100644 index 000000000..16413a319 --- /dev/null +++ b/src/test/java/appeng/util/SlimReadableNumberConverterTest.java @@ -0,0 +1,127 @@ +package appeng.util; + + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + + +/** + * Test for {@link ISlimReadableNumberConverter} + * + * @author thatsIch + * @version rv2 + * @since rv2 + */ +public final class SlimReadableNumberConverterTest +{ + private static final long NUMBER_NEG_999999 = -999999L; + private static final String RESULT_NEG_999999 = "-0M"; + + private static final long NUMBER_NEG_9999 = -9999L; + private static final String RESULT_NEG_9999 = "-9K"; + + private static final long NUMBER_NEG_999 = -999L; + private static final String RESULT_NEG_999 = "-0K"; + + private static final long NUMBER_0 = 0L; + private static final String RESULT_0 = "0"; + + private static final long NUMBER_999 = 999L; + private static final String RESULT_999 = "999"; + + private static final long NUMBER_9999 = 9999L; + private static final String RESULT_9999 = "9K"; + + private static final long NUMBER_10000 = 10000L; + private static final String RESULT_10000 = "10K"; + + private static final long NUMBER_10500 = 10500L; + private static final String RESULT_10500 = "10K"; + + private static final long NUMBER_155555 = 155555L; + private static final String RESULT_155555 = ".1M"; + + private static final long NUMBER_9999999 = 9999999L; + private static final String RESULT_9999999 = "9M"; + + private static final long NUMBER_10000000 = 10000000L; + private static final String RESULT_10000000 = "10M"; + + private static final long NUMBER_155555555 = 155555555L; + private static final String RESULT_155555555 = ".1G"; + + private final ISlimReadableNumberConverter converter = ReadableNumberConverter.INSTANCE; + + @Test( expected = AssertionError.class ) + public void testConvertNeg999999() + { + assertEquals( RESULT_NEG_999999, this.converter.toSlimReadableForm( NUMBER_NEG_999999 ) ); + } + + @Test( expected = AssertionError.class ) + public void testConvertNeg9999() + { + assertEquals( RESULT_NEG_9999, this.converter.toSlimReadableForm( NUMBER_NEG_9999 ) ); + } + + @Test( expected = AssertionError.class ) + public void testConvertNeg999() + { + assertEquals( RESULT_NEG_999, this.converter.toSlimReadableForm( NUMBER_NEG_999 ) ); + } + + @Test + public void testConvert0() + { + assertEquals( RESULT_0, this.converter.toSlimReadableForm( NUMBER_0 ) ); + } + + @Test + public void testConvert999() + { + assertEquals( RESULT_999, this.converter.toSlimReadableForm( NUMBER_999 ) ); + } + + @Test + public void testConvert9999() + { + assertEquals( RESULT_9999, this.converter.toSlimReadableForm( NUMBER_9999 ) ); + } + + @Test + public void testConvert10000() + { + assertEquals( RESULT_10000, this.converter.toSlimReadableForm( NUMBER_10000 ) ); + } + + @Test + public void testConvert10500() + { + assertEquals( RESULT_10500, this.converter.toSlimReadableForm( NUMBER_10500 ) ); + } + + @Test + public void testConvert155555() + { + assertEquals( RESULT_155555, this.converter.toSlimReadableForm( NUMBER_155555 ) ); + } + + @Test + public void testConvert9999999() + { + assertEquals( RESULT_9999999, this.converter.toSlimReadableForm( NUMBER_9999999 ) ); + } + + @Test + public void testConvert10000000() + { + assertEquals( RESULT_10000000, this.converter.toSlimReadableForm( NUMBER_10000000 ) ); + } + + @Test + public void testConvert155555555() + { + assertEquals( RESULT_155555555, this.converter.toSlimReadableForm( NUMBER_155555555 ) ); + } +} diff --git a/src/test/java/appeng/util/WideReadableNumberConverterTest.java b/src/test/java/appeng/util/WideReadableNumberConverterTest.java new file mode 100644 index 000000000..6b047af55 --- /dev/null +++ b/src/test/java/appeng/util/WideReadableNumberConverterTest.java @@ -0,0 +1,127 @@ +package appeng.util; + + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + + +/** + * Test for {@link IWideReadableNumberConverter} + * + * @author thatsIch + * @version rv2 + * @since rv2 + */ +public final class WideReadableNumberConverterTest +{ + private static final long NUMBER_NEG_999999 = -999999L; + private static final String RESULT_NEG_999999 = "-0M"; + + private static final long NUMBER_NEG_9999 = -9999L; + private static final String RESULT_NEG_9999 = "-9K"; + + private static final long NUMBER_NEG_999 = -999L; + private static final String RESULT_NEG_999 = "-999"; + + private static final long NUMBER_0 = 0L; + private static final String RESULT_0 = "0"; + + private static final long NUMBER_999 = 999L; + private static final String RESULT_999 = "999"; + + private static final long NUMBER_9999 = 9999L; + private static final String RESULT_9999 = "9999"; + + private static final long NUMBER_10000 = 10000L; + private static final String RESULT_10000 = "10K"; + + private static final long NUMBER_10500 = 10500L; + private static final String RESULT_10500 = "10K"; + + private static final long NUMBER_155555 = 155555L; + private static final String RESULT_155555 = "155K"; + + private static final long NUMBER_9999999 = 9999999L; + private static final String RESULT_9999999 = "9.9M"; + + private static final long NUMBER_10000000 = 10000000L; + private static final String RESULT_10000000 = "10M"; + + private static final long NUMBER_155555555 = 155555555L; + private static final String RESULT_155555555 = "155M"; + + private final IWideReadableNumberConverter converter = ReadableNumberConverter.INSTANCE; + + @Test( expected = AssertionError.class ) + public void testConvertNeg999999() + { + assertEquals( RESULT_NEG_999999, this.converter.toWideReadableForm( NUMBER_NEG_999999 ) ); + } + + @Test( expected = AssertionError.class ) + public void testConvertNeg9999() + { + assertEquals( RESULT_NEG_9999, this.converter.toWideReadableForm( NUMBER_NEG_9999 ) ); + } + + @Test( expected = AssertionError.class ) + public void testConvertNeg999() + { + assertEquals( RESULT_NEG_999, this.converter.toWideReadableForm( NUMBER_NEG_999 ) ); + } + + @Test + public void testConvert0() + { + assertEquals( RESULT_0, this.converter.toWideReadableForm( NUMBER_0 ) ); + } + + @Test + public void testConvert999() + { + assertEquals( RESULT_999, this.converter.toWideReadableForm( NUMBER_999 ) ); + } + + @Test + public void testConvert9999() + { + assertEquals( RESULT_9999, this.converter.toWideReadableForm( NUMBER_9999 ) ); + } + + @Test + public void testConvert10000() + { + assertEquals( RESULT_10000, this.converter.toWideReadableForm( NUMBER_10000 ) ); + } + + @Test + public void testConvert10500() + { + assertEquals( RESULT_10500, this.converter.toWideReadableForm( NUMBER_10500 ) ); + } + + @Test + public void testConvert155555() + { + assertEquals( RESULT_155555, this.converter.toWideReadableForm( NUMBER_155555 ) ); + } + + @Test + public void testConvert9999999() + { + assertEquals( RESULT_9999999, this.converter.toWideReadableForm( NUMBER_9999999 ) ); + } + + @Test + public void testConvert10000000() + { + assertEquals( RESULT_10000000, this.converter.toWideReadableForm( NUMBER_10000000 ) ); + } + + @Test + public void testConvert155555555() + { + assertEquals( RESULT_155555555, this.converter.toWideReadableForm( NUMBER_155555555 ) ); + } +}