FlexibleConfig

engine-tests/src/test/java/org/terasology/config/flexible/FlexibleConfigTest.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2016 MovingBlocks
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.terasology.config.flexible;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.terasology.engine.SimpleUri;
+
+import static org.junit.Assert.*;
+
+@RunWith(Enclosed.class)
+public class FlexibleConfigTest {
+    private static final SimpleUri KEY_NON_EXISTENT = new SimpleUri("engine-tests:TestSettingX");
+
+    public static class Get {
+        private FlexibleConfig config;
+
+        @Before
+        public void setUp() throws Exception {
+            config = new FlexibleConfigImpl();
+        }
+
+        @Test
+        public void testGet() throws Exception {
+            SimpleUri id1 = new SimpleUri("engine-tests:TestSetting1");
+            SimpleUri id2 = new SimpleUri("engine-tests:TestSetting2");
+
+            Setting<Integer> expectedSetting1 = new MockSetting<>(id1);
+            config.add(expectedSetting1);
+
+            Setting<Double> expectedSetting2 = new MockSetting<>(id2);
+            config.add(expectedSetting2);
+
+            Setting<Integer> retrievedSetting1 = config.get(id1);
+            Setting<Double> retrievedSetting2 = config.get(id2);
+
+            // We need the references to be equal
+            assertEquals(expectedSetting1, retrievedSetting1);
+            assertEquals(expectedSetting2, retrievedSetting2);
+        }
+    }
+
+    public static class Contains {
+        private FlexibleConfig config;
+
+        @Before
+        public void setUp() throws Exception {
+            config = new FlexibleConfigImpl();
+        }
+
+        @Test
+        public void testContains() throws Exception {
+            SimpleUri id = new SimpleUri("engine-tests:TestSetting");
+            config.add(new MockSetting<Integer>(id));
+
+            assertTrue(config.contains(id));
+        }
+
+        @Test
+        public void testNotContains() throws Exception {
+            SimpleUri id = new SimpleUri("engine-tests:TestSetting");
+            config.add(new MockSetting<Integer>(id));
+
+            assertFalse(config.contains(KEY_NON_EXISTENT));
+        }
+    }
+
+    public static class Add {
+        private FlexibleConfig config;
+
+        @Before
+        public void setUp() throws Exception {
+            config = new FlexibleConfigImpl();
+        }
+
+        @Test
+        public void testAdd() throws Exception {
+            SimpleUri id = new SimpleUri("engine-tests:TestSetting");
+
+            assertTrue(config.add(new MockSetting(id)));
+        }
+
+        @Test
+        public void testAddExisting() throws Exception {
+            SimpleUri id = new SimpleUri("engine-tests:TestSetting");
+
+            assertTrue(config.add(new MockSetting<Integer>(id)));
+            assertFalse(config.add(new MockSetting<Double>(id)));
+        }
+    }
+
+    public static class Remove {
+        private FlexibleConfig config;
+
+        @Before
+        public void setUp() throws Exception {
+            config = new FlexibleConfigImpl();
+        }
+
+        @Test
+        public void testRemove() throws Exception {
+            SimpleUri id1 = new SimpleUri("engine-tests:TestSetting1");
+            SimpleUri id2 = new SimpleUri("engine-tests:TestSetting2");
+
+            config.add(new MockSetting(id1));
+            config.add(new MockSetting(id2));
+
+            assertTrue(config.remove(id1));
+            assertTrue(config.remove(id2));
+        }
+
+        @Test
+        public void testNonexistentRemove() throws Exception {
+            SimpleUri id = new SimpleUri("engine-tests:TestSetting");
+            config.add(new MockSetting(id));
+
+            assertFalse(config.remove(KEY_NON_EXISTENT));
+        }
+
+        @Test
+        public void testSubscribedRemove() throws Exception {
+            SimpleUri id = new SimpleUri("engine-tests:TestSetting");
+            Setting setting = new MockSetting(id);
+            config.add(setting);
+            setting.subscribe(propertyChangeEvent -> {});
+
+            assertFalse(config.remove(id));
+        }
+    }
+}

engine-tests/src/test/java/org/terasology/config/flexible/MockSetting.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2016 MovingBlocks
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.terasology.config.flexible;
+
+import org.terasology.config.flexible.validators.SettingValueValidator;
+import org.terasology.engine.SimpleUri;
+
+import java.beans.PropertyChangeListener;
+
+class MockSetting<T> implements Setting<T> {
+    private final SimpleUri id;
+    private boolean isSubscribedTo = false;
+
+    MockSetting(SimpleUri id) {
+        this.id = id;
+    }
+
+    @Override
+    public boolean subscribe(PropertyChangeListener changeListener) {
+        isSubscribedTo = true;
+        return true;
+    }
+
+    @Override
+    public boolean unsubscribe(PropertyChangeListener changeListener) {
+        isSubscribedTo = false;
+        return false;
+    }
+
+    @Override
+    public SimpleUri getId() {
+        return id;
+    }
+
+    @Override
+    public SettingValueValidator<T> getValidator() {
+        return null;
+    }
+
+    @Override
+    public T getDefaultValue() {
+        return null;
+    }
+
+    @Override
+    public T getValue() {
+        return null;
+    }
+
+    @Override
+    public boolean setValue(T newValue) {
+        return false;
+    }
+
+    @Override
+    public String getHumanReadableName() {
+        return null;
+    }
+
+    @Override
+    public String getDescription() {
+        return null;
+    }
+
+    @Override
+    public boolean hasSubscribers() {
+        return isSubscribedTo;
+    }
+}

engine-tests/src/test/java/org/terasology/config/flexible/SettingTest.java

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2016 MovingBlocks
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.terasology.config.flexible;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.terasology.config.flexible.validators.RangedNumberValidator;
+import org.terasology.engine.SimpleUri;
+import org.terasology.utilities.random.FastRandom;
+import org.terasology.utilities.random.Random;
+
+import java.beans.PropertyChangeListener;
+
+import static org.junit.Assert.*;
+
+@RunWith(Enclosed.class)
+public class SettingTest {
+    private static final SimpleUri SETTING_ID = new SimpleUri("engine-tests:TestSetting");
+
+    public static class SetValue {
+        private Setting<Integer> setting;
+
+        private int eventResult;
+
+        @Before
+        public void setUp() {
+            setting = new SettingImpl<>(SETTING_ID,
+                    50, new RangedNumberValidator<>(0, 100, false, false));
+
+            eventResult = -1;
+
+            setting.subscribe(propertyChangeEvent -> eventResult = (int) propertyChangeEvent.getNewValue());
+        }
+
+        @Test
+        public void testSetsValue() {
+            assertTrue(setting.setValue(25));
+
+            assertEquals(25, eventResult);
+        }
+
+        @Test
+        public void testDoesNotSetValue() {
+            assertFalse(setting.setValue(101));
+
+            assertEquals(-1, eventResult);
+        }
+    }
+
+    public static class Subscribers {
+        private Setting<Integer> setting;
+
+        private PropertyChangeListener listener;
+
+        private int eventCallCount;
+
+        @Before
+        public void setUp() {
+            setting = new SettingImpl<>(SETTING_ID,
+                    50, new RangedNumberValidator<>(0, 100, false, false));
+
+            eventCallCount = 0;
+
+            listener = propertyChangeEvent -> eventCallCount++;
+        }
+
+        @Test
+        public void testHasSubscribers() {
+            setting.subscribe(listener);
+
+            assertTrue(setting.hasSubscribers());
+
+            setting.unsubscribe(listener);
+
+            assertFalse(setting.hasSubscribers());
+        }
+
+        @Test
+        public void testSetEventCall() {
+            setting.subscribe(listener);
+
+            Random random = new FastRandom();
+
+            final int MAX_SET_VALUE_COUNT = 50;
+            int expectedEventCallCount = 0;
+
+            for (int i = 0; i < MAX_SET_VALUE_COUNT; i++) {
+                int randomInt = random.nextInt(-50, 150);
+                expectedEventCallCount += setting.setValue(randomInt) ? 1 : 0;
+            }
+
+            assertEquals(expectedEventCallCount, eventCallCount);
+        }
+
+        @Test
+        public void testSubscribe() {
+            final int SUBSCRIBER_COUNT = 10;
+
+            for (int i = 0; i < SUBSCRIBER_COUNT; i++) {
+                setting.subscribe(propertyChangeEvent -> eventCallCount++);
+            }
+
+            setting.setValue(30);
+
+            assertEquals(SUBSCRIBER_COUNT, eventCallCount);
+        }
+
+        @Test
+        public void testUnsubscribe() {
+            int subscriberCount = 10;
+
+            PropertyChangeListener[] listeners = new PropertyChangeListener[subscriberCount];
+
+            for (int i = 0; i < subscriberCount; i++) {
+                listeners[i] = propertyChangeEvent -> eventCallCount++;
+                setting.subscribe(listeners[i]);
+            }
+
+            for (int i = 0; i < new FastRandom().nextInt(subscriberCount / 2); i++) {
+                setting.unsubscribe(listeners[i]);
+                subscriberCount--;
+            }
+
+            setting.setValue(30);
+
+            assertEquals(subscriberCount, eventCallCount);
+        }
+    }
+}