import static junit.framework.Assert.*;
+import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
public class CompositeConfigTest {
- public static class IntClass implements Identifiable<IntClass> {
+ public static interface StringClassInterface extends
+ Identifiable<StringClassInterface> {
- private int value;
+ }
+
+ public static class StringClass implements StringClassInterface {
- public IntClass(int aValue) {
+ private String value;
+
+ public StringClass(String aValue) {
value = aValue;
}
+ public StringClass(int aValue) {
+ this(aValue + "");
+ }
+
@Override
- public Id<IntClass> getId() {
- return new Id<IntClass>(value + "");
+ public Id<StringClassInterface> getId() {
+ return new Id<StringClassInterface>(value + "");
}
@Override
public int hashCode() {
- return ((Integer) value).hashCode();
+ return value.hashCode();
}
@Override
if (aObj == null) {
return false;
}
- if (!(aObj instanceof IntClass)) {
+ if (!(aObj instanceof StringClass)) {
return false;
}
- IntClass obj = (IntClass) aObj;
- return value == obj.value;
+ StringClass obj = (StringClass) aObj;
+ return value.equals(obj.value);
}
}
@Test
public void testEmptyConfig() {
- Config<IntClass> composite = composite();
+ Config<StringClassInterface> composite = composite();
assertTrue(composite.values().isEmpty());
}
@Test(expected = RuntimeException.class)
public void testAddNotAllowed() {
- composite().add(new IntClass(10));
+ composite().add(new StringClass(10));
}
@Test(expected = RuntimeException.class)
public void testRemoveNotAllowed() {
- composite().remove(new Id<IntClass>("xxx"));
+ composite().remove(new Id<StringClassInterface>("xxx"));
}
@Test
public void testAddConfig() {
- CompositeConfig<IntClass> composite = composite();
- Config<IntClass> c1 = new ConfigImpl(id("c1")) {
+ CompositeConfig<StringClassInterface> composite = composite();
+ Config<StringClassInterface> c1 = new ConfigImpl(
+ StringClassInterface.class, id("c1")) {
@Override
public Identifiable wrap(String aPrefix, Identifiable aT) {
return aT;
}
};
- Config<IntClass> c2 = new ConfigImpl(id("c2")) {
+ Config<StringClassInterface> c2 = new ConfigImpl(
+ StringClassInterface.class, id("c2")) {
@Override
public Identifiable wrap(String aPrefix, Identifiable aT) {
return aT;
}
};
- IntClass i1 = new IntClass(10);
- IntClass i2 = new IntClass(20);
- IntClass i3 = new IntClass(30);
- IntClass i4 = new IntClass(40);
+ StringClass i1 = new StringClass(10);
+ StringClass i2 = new StringClass(20);
+ StringClass i3 = new StringClass(30);
+ StringClass i4 = new StringClass(40);
c1.add(i1);
c1.add(i2);
c2.add(i4);
composite.addConfig(c1);
- List<IntClass> values = composite.values();
- assertEquals(2, values.size());
- assertTrue(values.contains(i1));
- assertTrue(values.contains(i2));
+ List<StringClassInterface> values = composite.values();
+ List<String> ids = new ArrayList<String>();
+ for (StringClassInterface intf : values) {
+ ids.add(intf.getId().getId());
+ }
+ assertTrue(ids.contains("c1.10"));
+ assertTrue(ids.contains("c1.20"));
composite.addConfig(c2);
values = composite.values();
assertEquals(4, values.size());
- assertTrue(values.contains(i1));
- assertTrue(values.contains(i2));
- assertTrue(values.contains(i3));
- assertTrue(values.contains(i4));
+
+ ids = new ArrayList<String>();
+ for (StringClassInterface intf : values) {
+ ids.add(intf.getId().getId());
+ }
+ assertTrue(ids.contains("c1.10"));
+ assertTrue(ids.contains("c1.20"));
+ assertTrue(ids.contains("c2.30"));
+ assertTrue(ids.contains("c2.40"));
}
@Test(expected = ConfigException.class)
public void testDuplicatesNotAllowed() {
- CompositeConfig<IntClass> composite = composite();
- Config<IntClass> c1 = new ConfigImpl(id("c1")) {
+ CompositeConfig<StringClassInterface> composite = composite();
+ Config<StringClassInterface> c1 = new ConfigImpl(
+ StringClassInterface.class, id("c1")) {
@Override
public Identifiable wrap(String aPrefix, Identifiable aT) {
return aT;
}
};
- Config<IntClass> c2 = new ConfigImpl(id("c1")) {
+ Config<StringClassInterface> c2 = new ConfigImpl(
+ StringClassInterface.class, id("c1")) {
@Override
public Identifiable wrap(String aPrefix, Identifiable aT) {
return aT;
@Test
public void testDuplicateItem() {
- CompositeConfig<IntClass> composite = composite();
- Config<IntClass> c1 = new ConfigImpl(id("c1")) {
+ CompositeConfig<StringClassInterface> composite = composite();
+ Config<StringClassInterface> c1 = new ConfigImpl(
+ StringClassInterface.class, id("c.x")) {
@Override
public Identifiable wrap(String aPrefix, Identifiable aT) {
return aT;
}
};
- Config<IntClass> c2 = new ConfigImpl(id("c2")) {
+ Config<StringClassInterface> c2 = new ConfigImpl(
+ StringClassInterface.class, id("c")) {
@Override
public Identifiable wrap(String aPrefix, Identifiable aT) {
return aT;
}
};
- IntClass i1 = new IntClass(10);
- IntClass i2 = new IntClass(10);
+ StringClass i1 = new StringClass("y");
+ StringClass i2 = new StringClass("x.y");
c1.add(i1);
c2.add(i2);
composite.addConfig(c1);
// ok.
}
assertEquals(1, composite.values().size());
- assertTrue(composite.values().contains(i1));
+ assertEquals("c.x.y", composite.values().iterator().next().getId()
+ .getId());
}
- private CompositeConfig<IntClass> composite() {
- return new CompositeConfig<IntClass>();
+ private CompositeConfig<StringClassInterface> composite() {
+ return new CompositeConfig<StringClassInterface>(
+ StringClassInterface.class);
}
private Id<Config> id(String aId) {