From ab04f462db66899843b02b39a05ac1db64abf85b Mon Sep 17 00:00:00 2001 From: crast Date: Wed, 20 Mar 2013 15:59:03 -0600 Subject: [PATCH] Substantially more comprehensive unit tests. Check all the interesting implementation details in metadatavalues which were never tested before, as well as making sure we document things thoroughly. --- .../org/bukkit/metadata/MetadataValueAdapter.java | 2 +- .../bukkit/metadata/MetadataValueAdapterTest.java | 73 +++++++++++++++++--- 2 files changed, 64 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/bukkit/metadata/MetadataValueAdapter.java b/src/main/java/org/bukkit/metadata/MetadataValueAdapter.java index 354b6dc..c4b8b39 100644 --- a/src/main/java/org/bukkit/metadata/MetadataValueAdapter.java +++ b/src/main/java/org/bukkit/metadata/MetadataValueAdapter.java @@ -9,7 +9,7 @@ import org.bukkit.util.NumberConversions; * * This provides all the conversion functions for MetadataValue * so that writing an implementation of MetadataValue is as simple - * as implementing value() and invalidate() + * as implementing value() and invalidate(). * */ public abstract class MetadataValueAdapter implements MetadataValue { diff --git a/src/test/java/org/bukkit/metadata/MetadataValueAdapterTest.java b/src/test/java/org/bukkit/metadata/MetadataValueAdapterTest.java index 5ae7df4..7d8a17f 100644 --- a/src/test/java/org/bukkit/metadata/MetadataValueAdapterTest.java +++ b/src/test/java/org/bukkit/metadata/MetadataValueAdapterTest.java @@ -10,22 +10,75 @@ public class MetadataValueAdapterTest { private TestPlugin plugin = new TestPlugin("x"); @Test - public void testIncrementingAdapter() { + public void testAdapterBasics() { IncrementingMetaValue mv = new IncrementingMetaValue(plugin); // check getOwningPlugin assertEquals(mv.getOwningPlugin(), this.plugin); - // check the various value-making methods - assertEquals(mv.asInt(), 1); - assertEquals(mv.asLong(), 2L); - assertEquals(mv.asFloat(), 3.0, 0.001); - assertEquals(mv.asByte(), 4); - assertEquals(mv.asDouble(), 5.0, 0.001); - assertEquals(mv.asShort(), 6); - assertEquals(mv.asString(), "7"); + // Check value-getting and invalidation. + assertEquals(new Integer(1), mv.value()); + assertEquals(new Integer(2), mv.value()); + mv.invalidate(); + assertEquals(new Integer(1), mv.value()); } - /** Silly Metadata implementation that increments every time value() is called */ + @Test + public void testAdapterConversions() { + IncrementingMetaValue mv = new IncrementingMetaValue(plugin); + + assertEquals(1, mv.asInt()); + assertEquals(2L, mv.asLong()); + assertEquals(3.0, mv.asFloat(), 0.001); + assertEquals(4, mv.asByte()); + assertEquals(5.0, mv.asDouble(), 0.001); + assertEquals(6, mv.asShort()); + assertEquals("7", mv.asString()); + } + + /** Boolean conversion is non-trivial, we want to test it thoroughly. */ + @Test + public void testBooleanConversion() { + // null is False. + assertEquals(false, simpleValue(null).asBoolean()); + + // String to boolean. + assertEquals(true, simpleValue("True").asBoolean()); + assertEquals(true, simpleValue("TRUE").asBoolean()); + assertEquals(false, simpleValue("false").asBoolean()); + + // Number to boolean. + assertEquals(true, simpleValue(1).asBoolean()); + assertEquals(true, simpleValue(5.0).asBoolean()); + assertEquals(false, simpleValue(0).asBoolean()); + assertEquals(false, simpleValue(0.1).asBoolean()); + + // Boolean as boolean, of course. + assertEquals(true, simpleValue(Boolean.TRUE).asBoolean()); + assertEquals(false, simpleValue(Boolean.FALSE).asBoolean()); + + // any object that is not null and not a Boolean, String, or Number is true. + assertEquals(true, simpleValue(new Object()).asBoolean()); + } + + /** Test String conversions return an empty string when given null. */ + @Test + public void testStringConversionNull() { + assertEquals("", simpleValue(null).asString()); + } + + /** Get a fixed value MetadataValue. */ + private MetadataValue simpleValue(Object value) { + return new FixedMetadataValue(plugin, value); + } + + /** + * A sample non-trivial MetadataValueAdapter implementation. + * + * The rationale for implementing an incrementing value is to have a value + * which changes with every call to value(). This is important for testing + * because we want to make sure all the tested conversions are calling the + * value() method exactly once and no caching is going on. + */ class IncrementingMetaValue extends MetadataValueAdapter { private int internalValue = 0; -- 1.7.0.4