@Test public void testAbsents() { DataContainer container = DataContainer.createNew(); DataQuery testQuery = of("foo", "bar", "baz"); assertTrue(!container.get(testQuery).isPresent()); assertTrue(!container.getBoolean(testQuery).isPresent()); assertTrue(!container.getBooleanList(testQuery).isPresent()); assertTrue(!container.getByteList(testQuery).isPresent()); assertTrue(!container.getCharacterList(testQuery).isPresent()); assertTrue(!container.getDouble(testQuery).isPresent()); assertTrue(!container.getDoubleList(testQuery).isPresent()); assertTrue(!container.getFloatList(testQuery).isPresent()); assertTrue(!container.getInt(testQuery).isPresent()); assertTrue(!container.getIntegerList(testQuery).isPresent()); assertTrue(!container.getList(testQuery).isPresent()); assertTrue(!container.getLong(testQuery).isPresent()); assertTrue(!container.getLongList(testQuery).isPresent()); assertTrue(!container.getMapList(testQuery).isPresent()); assertTrue(!container.getShortList(testQuery).isPresent()); assertTrue(!container.getString(testQuery).isPresent()); assertTrue(!container.getStringList(testQuery).isPresent()); assertTrue(!container.getView(testQuery).isPresent()); }
@Test public void testLists() { DataContainer container = DataContainer.createNew(); DataQuery query = of("foo"); List<DataView> list = Lists.newArrayList(); for (int i = 0; i < 1; i++) { DataContainer internal = DataContainer.createNew(); internal.set(of("foo", "bar"), "foo.bar" + i); int[] ints = new int[] {0, 1, 2, 3, i}; internal.set(of("ints"), Arrays.asList(ints)); list.add(internal); } container.set(query, list); assertTrue(container.contains(query)); List<DataView> queriedList = container.getViewList(query).get(); assertTrue(queriedList.equals(list)); }
@Test public void testCreateView() { DataContainer container = DataContainer.createNew(); DataQuery tempQuery = of("foo", "bar", "baz"); container.createView(tempQuery); assertTrue(container.getView(tempQuery).isPresent()); }
@Override protected DataContainer fillContainer(DataContainer dataContainer) { return dataContainer.set(this.usedKey.getQuery(), this.value.name()); }
@Test public void testNumbers() { DataContainer container = DataContainer.createNew(); DataQuery testQuery = of("foo", "bar"); container.set(testQuery, 1.0D); Optional<Integer> integerOptional = container.getInt(testQuery); assertTrue(integerOptional.isPresent()); assertTrue(integerOptional.get() == 1); Optional<Long> longOptional = container.getLong(testQuery); assertTrue(longOptional.isPresent()); assertTrue(longOptional.get() == 1L); Optional<Double> doubleOptional = container.getDouble(testQuery); assertTrue(doubleOptional.isPresent()); assertTrue(doubleOptional.get() == 1.0D); }
@Test public void testNumberedLists() { DataContainer container = DataContainer.createNew(); DataQuery testQuery = of("foo", "bar", "baz"); List<Integer> intList = ImmutableList.of(1, 2, 3, 4); container.set(testQuery, intList); assertTrue(container.getIntegerList(testQuery).isPresent()); assertTrue(container.getIntegerList(testQuery).get().equals(intList)); List<Double> doubleList = ImmutableList.of(1.0D, 2.0D, 3.0D, 4.0D); container.set(testQuery, doubleList); assertTrue(container.getDoubleList(testQuery).isPresent()); assertTrue(container.getDoubleList(testQuery).get().equals(doubleList)); List<Short> shortList = ImmutableList.of((short) 1, (short) 2, (short) 3, (short) 4); container.set(testQuery, shortList); assertTrue(container.getShortList(testQuery).isPresent()); assertTrue(container.getShortList(testQuery).get().equals(shortList)); List<Byte> byteList = ImmutableList.of((byte) 1, (byte) 2, (byte) 3, (byte) 4); container.set(testQuery, byteList); assertTrue(container.getByteList(testQuery).isPresent()); assertTrue(container.getByteList(testQuery).get().equals(byteList)); }
@Test public void testCopy() { final DataContainer container = DataContainer.createNew(); container.set(of("Foo"), "foo"); final DataContainer newContainer = container.copy(); assertTrue(container.equals(newContainer)); container.set(of("Foo", "bar"), "foo.bar"); final DataView internal = container.getView(of("Foo")).get().copy(); final DataContainer internalCopy = DataContainer.createNew().set(of("bar"), "foo.bar"); assertTrue(internal.equals(internalCopy)); }
@Test public void testContainsEmpty() { DataContainer container = DataContainer.createNew(); DataQuery query = of(""); assertTrue(!container.contains(query)); container.set(query, "foo"); assertTrue(container.contains(query)); query = of('.', "foo.bar"); assertTrue(!container.contains(query)); container.set(query, "baz"); assertTrue(container.contains(query)); }
@Test public void testString() { DataContainer container = DataContainer.createNew(); DataQuery testQuery = of("foo", "bar"); container.set(testQuery, "foo"); Optional<String> stringOptional = container.getString(testQuery); assertTrue(stringOptional.isPresent()); assertTrue(stringOptional.get().equals("foo")); }
@Test public void testGetSerializableList() throws Exception { initGame(); List<SimpleData> list = Lists.newArrayList(); for (int i = 0; i < 1000; i++) { String number = Integer.toString(i); list.add(new SimpleData(i, 0.1 * i, "i", Lists.asList(number, new String[] {" foo", "bar"}))); } DataContainer container = DataContainer.createNew(); container.set(of("foo", "bar"), list); assertTrue(container.contains(of("foo", "bar"))); Optional<List<SimpleData>> fromContainer = container.getSerializableList(of("foo", "bar"), SimpleData.class); assertTrue(fromContainer.isPresent()); List<SimpleData> memoryList = fromContainer.get(); assertTrue(Objects.equal(memoryList, list)); }
@Test public void testBoolean() { DataContainer container = DataContainer.createNew(); DataQuery testQuery = of("foo", "bar"); container.set(testQuery, false); Optional<Boolean> booleanOptional = container.getBoolean(testQuery); assertTrue(booleanOptional.isPresent()); assertTrue(!booleanOptional.get()); }
@Test public void testDeepSerialization() { List<List<?>> values = Lists.newArrayList(); List<List<?>> sub = Lists.newArrayList(); values.add(sub); SimpleData data1 = new SimpleData(1, 2.0, "3", Arrays.asList("foo", "bar", "baz")); SimpleData data2 = new SimpleData(2, 3.0, "4", Arrays.asList("bar", "baz", "foo")); SimpleData data3 = new SimpleData(3, 4.0, "5", Arrays.asList("baz", "foo", "bar")); sub.add(ImmutableList.of(data1)); sub.add(ImmutableList.of(data2)); DataContainer main = DataContainer.createNew(); main.set(DataQuery.of("ROOT"), data3); main.set(DataQuery.of("SINGLE"), ImmutableList.of(data2)); main.set(DataQuery.of("SUB"), values); main.getMap(of()).get(); }
/** * Helper method to translate Player UUIDs to names. * * @param results List of results * @param uuidsPendingLookup Lists of UUIDs pending lookup * @return CompletableFuture */ public static CompletableFuture<List<Result>> translateUuidsToNames(List<Result> results, List<UUID> uuidsPendingLookup) { CompletableFuture<List<Result>> future = new CompletableFuture<>(); CompletableFuture<Collection<GameProfile>> futures = Sponge.getServer().getGameProfileManager().getAllById(uuidsPendingLookup, true); futures.thenAccept((profiles) -> { for (GameProfile profile : profiles) { for (Result r : results) { Optional<Object> cause = r.data.get(DataQueries.Cause); if (cause.isPresent() && cause.get().equals(profile.getUniqueId().toString())) { r.data.set(DataQueries.Cause, profile.getName().orElse("unknown")); } } } future.complete(results); }); return future; } }
/** * Helper method for formatting entity container data. * @param entity */ private void writeEntity(Entity entity) { checkNotNull(entity); DataContainer entityData = entity.toContainer(); Optional<DataView> position = entityData.getView(DataQueries.Position); if (position.isPresent()) { position.get().set(DataQueries.WorldUuid, entityData.get(DataQueries.WorldUuid).get()); data.set(DataQueries.Location, position.get()); entityData.remove(DataQueries.Position); entityData.remove(DataQueries.WorldUuid); } Optional<DataView> optionalUnsafeData = entityData.getView(DataQueries.UnsafeData); if (optionalUnsafeData.isPresent()) { DataView unsafeData = optionalUnsafeData.get(); unsafeData.remove(DataQueries.Rotation); unsafeData.remove(DataQueries.Pos); entityData.set(DataQueries.UnsafeData, unsafeData); } data.set(DataQueries.Target, entity.getType().getId().replace("_", " ")); data.set(DataQueries.Entity, entityData); }
DataContainer schematic = DataContainer.createNew(SafetyMode.NO_DATA_CLONED); schematic.set(DataQuery.of("Width"), w); schematic.set(DataQuery.of("Height"), h); schematic.set(DataQuery.of("Length"), l); schematic.set(DataQuery.of("Version"), 1); DataView metadata = schematic.createView(DataQuery.of("Metadata")); metadata.set(DataQuery.of("Name"), name); schematic.set(DataQuery.of("Offset"), offset); schematic.set(DataQuery.of("BlockData"), buffer.toByteArray());
@Test public void testCreateDataView() { DataContainer.createNew(); }
/** * Removes unnecessary/duplicate data from a BlockSnapshot's DataContainer. * * @param blockSnapshot Block Snapshot. * @return DataContainer Formatted Data Container. */ private DataContainer formatBlockDataContainer(BlockSnapshot blockSnapshot) { DataContainer block = blockSnapshot.toContainer(); block.remove(DataQueries.WorldUuid); block.remove(DataQueries.Position); Optional<Object> optionalUnsafeData = block.get(DataQueries.UnsafeData); if (optionalUnsafeData.isPresent()) { DataView unsafeData = (DataView) optionalUnsafeData.get(); unsafeData.remove(DataQueries.X); unsafeData.remove(DataQueries.Y); unsafeData.remove(DataQueries.Z); block.set(DataQueries.UnsafeData, unsafeData); } return block; } }