1012 lines
37 KiB
Java
1012 lines
37 KiB
Java
/**
|
|
* ProtocolLib - Bukkit server library that allows access to the Minecraft protocol. Copyright (C) 2012 Kristian S.
|
|
* Stangeland
|
|
* <p>
|
|
* This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
|
|
* License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later
|
|
* version.
|
|
* <p>
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
* <p>
|
|
* You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
|
|
* Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
package com.comphenix.protocol.events;
|
|
|
|
import java.lang.reflect.Array;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.Modifier;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.EnumSet;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import java.util.Optional;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.ThreadLocalRandom;
|
|
|
|
import com.comphenix.protocol.BukkitInitialization;
|
|
import com.comphenix.protocol.PacketType;
|
|
import com.comphenix.protocol.injector.PacketConstructor;
|
|
import com.comphenix.protocol.reflect.EquivalentConverter;
|
|
import com.comphenix.protocol.reflect.FuzzyReflection;
|
|
import com.comphenix.protocol.reflect.StructureModifier;
|
|
import com.comphenix.protocol.reflect.accessors.Accessors;
|
|
import com.comphenix.protocol.reflect.accessors.FieldAccessor;
|
|
import com.comphenix.protocol.reflect.cloning.SerializableCloner;
|
|
import com.comphenix.protocol.utility.MinecraftMethods;
|
|
import com.comphenix.protocol.utility.MinecraftReflection;
|
|
import com.comphenix.protocol.wrappers.*;
|
|
import com.comphenix.protocol.wrappers.EnumWrappers.Direction;
|
|
import com.comphenix.protocol.wrappers.EnumWrappers.EntityUseAction;
|
|
import com.comphenix.protocol.wrappers.EnumWrappers.Hand;
|
|
import com.comphenix.protocol.wrappers.EnumWrappers.NativeGameMode;
|
|
import com.comphenix.protocol.wrappers.EnumWrappers.SoundCategory;
|
|
import com.comphenix.protocol.wrappers.WrappedDataWatcher.Registry;
|
|
import com.comphenix.protocol.wrappers.nbt.NbtCompound;
|
|
import com.comphenix.protocol.wrappers.nbt.NbtFactory;
|
|
import com.google.common.collect.Lists;
|
|
import io.netty.buffer.ByteBuf;
|
|
import net.md_5.bungee.api.chat.BaseComponent;
|
|
import net.md_5.bungee.api.chat.ClickEvent;
|
|
import net.md_5.bungee.api.chat.ComponentBuilder;
|
|
import net.md_5.bungee.api.chat.HoverEvent;
|
|
import net.md_5.bungee.api.chat.hover.content.Text;
|
|
import net.minecraft.core.registries.BuiltInRegistries;
|
|
import net.minecraft.network.protocol.game.PacketPlayOutGameStateChange;
|
|
import net.minecraft.network.protocol.game.PacketPlayOutUpdateAttributes;
|
|
import net.minecraft.network.protocol.game.PacketPlayOutUpdateAttributes.AttributeSnapshot;
|
|
import net.minecraft.resources.MinecraftKey;
|
|
import net.minecraft.world.effect.MobEffect;
|
|
import net.minecraft.world.effect.MobEffectList;
|
|
import net.minecraft.world.entity.ai.attributes.AttributeBase;
|
|
import net.minecraft.world.entity.ai.attributes.AttributeModifier;
|
|
import net.minecraft.world.entity.animal.CatVariant;
|
|
import net.minecraft.world.entity.animal.FrogVariant;
|
|
import org.apache.commons.lang.SerializationUtils;
|
|
import org.bukkit.ChatColor;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.Sound;
|
|
import org.bukkit.entity.EntityType;
|
|
import org.bukkit.inventory.ItemStack;
|
|
import org.bukkit.inventory.meta.ItemMeta;
|
|
import org.bukkit.potion.PotionEffect;
|
|
import org.bukkit.potion.PotionEffectType;
|
|
import org.bukkit.util.Vector;
|
|
import org.junit.jupiter.api.Assertions;
|
|
import org.junit.jupiter.api.BeforeAll;
|
|
import org.junit.jupiter.api.Disabled;
|
|
import org.junit.jupiter.api.Test;
|
|
|
|
import static com.comphenix.protocol.utility.TestUtils.assertItemCollectionsEqual;
|
|
import static com.comphenix.protocol.utility.TestUtils.assertItemsEqual;
|
|
import static com.comphenix.protocol.utility.TestUtils.equivalentItem;
|
|
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
|
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
|
|
import static org.junit.jupiter.api.Assertions.assertNotSame;
|
|
import static org.junit.jupiter.api.Assertions.assertSame;
|
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
|
|
|
public class PacketContainerTest {
|
|
|
|
private static BaseComponent[] TEST_COMPONENT;
|
|
// Helper converters
|
|
private final EquivalentConverter<WrappedDataWatcher> watchConvert = BukkitConverters.getDataWatcherConverter();
|
|
private final EquivalentConverter<ItemStack> itemConvert = BukkitConverters.getItemStackConverter();
|
|
|
|
@BeforeAll
|
|
public static void initializeBukkit() {
|
|
BukkitInitialization.initializeAll();
|
|
|
|
TEST_COMPONENT = new ComponentBuilder("Hit or miss?")
|
|
.event(new ClickEvent(ClickEvent.Action.OPEN_URL, "https://reddit.com"))
|
|
.event(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text("The \"front page\" of the internet")))
|
|
.append("I guess they never miss, huh?")
|
|
.create();
|
|
}
|
|
|
|
private <T> void testPrimitive(StructureModifier<T> modifier, int index, T initialValue, T testValue) {
|
|
// Check initial value
|
|
assertEquals(initialValue, modifier.read(index));
|
|
|
|
// Test assignment
|
|
modifier.write(index, testValue);
|
|
assertEquals(testValue, modifier.read(0));
|
|
}
|
|
|
|
private <T> void testObjectArray(StructureModifier<T[]> modifier, int index, T[] initialValue, T[] testValue) {
|
|
// Check initial value
|
|
assertEquals(modifier.read(index).length, initialValue.length);
|
|
modifier.writeDefaults();
|
|
|
|
// Test initial
|
|
assertArrayEquals(initialValue, modifier.read(index));
|
|
|
|
// Test assignment
|
|
modifier.write(index, testValue);
|
|
assertArrayEquals(testValue, modifier.read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testGetByteArrays() {
|
|
// Contains a byte array we will test
|
|
PacketContainer customPayload = new PacketContainer(PacketType.Login.Client.ENCRYPTION_BEGIN);
|
|
StructureModifier<byte[]> bytes = customPayload.getByteArrays();
|
|
byte[] testArray = new byte[]{1, 2, 3};
|
|
|
|
// It's NULL at first
|
|
// assertEquals(null, bytes.read(0));
|
|
customPayload.getModifier().writeDefaults();
|
|
|
|
// Then it should create an empty array
|
|
assertArrayEquals(new byte[0], bytes.read(0));
|
|
|
|
// Check and see if we can write to it
|
|
bytes.write(0, testArray);
|
|
assertArrayEquals(testArray, bytes.read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testGetBytes() {
|
|
PacketContainer spawnMob = new PacketContainer(PacketType.Play.Server.NAMED_ENTITY_SPAWN);
|
|
this.testPrimitive(spawnMob.getBytes(), 0, (byte) 0, (byte) 1);
|
|
}
|
|
|
|
@Test
|
|
public void testGetShorts() {
|
|
PacketContainer itemData = new PacketContainer(PacketType.Play.Server.REL_ENTITY_MOVE);
|
|
this.testPrimitive(itemData.getShorts(), 0, (short) 0, (short) 1);
|
|
}
|
|
|
|
@Test
|
|
public void testGetIntegers() {
|
|
PacketContainer updateSign = new PacketContainer(PacketType.Play.Client.CLOSE_WINDOW);
|
|
this.testPrimitive(updateSign.getIntegers(), 0, 0, 1);
|
|
}
|
|
|
|
@Test
|
|
public void testGetLongs() {
|
|
PacketContainer updateTime = new PacketContainer(PacketType.Play.Server.UPDATE_TIME);
|
|
this.testPrimitive(updateTime.getLongs(), 0, (long) 0, (long) 1);
|
|
}
|
|
|
|
@Test
|
|
public void testGetFloat() {
|
|
PacketContainer explosion = new PacketContainer(PacketType.Play.Server.EXPLOSION);
|
|
this.testPrimitive(explosion.getFloat(), 0, (float) 0, (float) 0.8);
|
|
}
|
|
|
|
@Test
|
|
public void testGetDoubles() {
|
|
PacketContainer explosion = new PacketContainer(PacketType.Play.Server.EXPLOSION);
|
|
this.testPrimitive(explosion.getDoubles(), 0, (double) 0, 0.8);
|
|
}
|
|
|
|
@Test
|
|
public void testGetStrings() {
|
|
PacketContainer explosion = new PacketContainer(PacketType.Play.Client.CHAT);
|
|
this.testPrimitive(explosion.getStrings(), 0, "", "hello");
|
|
}
|
|
|
|
@Test
|
|
public void testGetStringArrays() {
|
|
PacketContainer packet = new PacketContainer(PacketType.Play.Client.UPDATE_SIGN);
|
|
this.testObjectArray(packet.getStringArrays(), 0,
|
|
new String[]{"", "", "", ""},
|
|
new String[]{"hello", "world"}
|
|
);
|
|
}
|
|
|
|
@Test
|
|
public void testGetIntegerArrays() {
|
|
// Contains a byte array we will test
|
|
PacketContainer packet = new PacketContainer(PacketType.Play.Server.MOUNT);
|
|
StructureModifier<int[]> integers = packet.getIntegerArrays();
|
|
int[] testArray = new int[]{1, 2, 3};
|
|
|
|
assertArrayEquals(new int[0], integers.read(0));
|
|
|
|
integers.write(0, testArray);
|
|
assertArrayEquals(testArray, integers.read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testGetItemModifier() {
|
|
PacketContainer windowClick = new PacketContainer(PacketType.Play.Client.WINDOW_CLICK);
|
|
|
|
ItemStack item = this.itemWithData();
|
|
|
|
StructureModifier<ItemStack> items = windowClick.getItemModifier();
|
|
// assertNull(items.read(0));
|
|
|
|
// Insert the item and check if it's there
|
|
items.write(0, item);
|
|
assertTrue(equivalentItem(item, items.read(0)), "Item " + item + " != " + items.read(0));
|
|
}
|
|
|
|
private ItemStack itemWithData() {
|
|
ItemStack item = new ItemStack(Material.GREEN_WOOL, 1);
|
|
ItemMeta meta = item.getItemMeta();
|
|
meta.setDisplayName(ChatColor.GREEN + "Green Wool");
|
|
meta.setLore(Lists.newArrayList(ChatColor.WHITE + "This is lore."));
|
|
item.setItemMeta(meta);
|
|
return item;
|
|
}
|
|
|
|
@Test
|
|
public void testGetItemListModifier() {
|
|
PacketContainer windowItems = new PacketContainer(PacketType.Play.Server.WINDOW_ITEMS);
|
|
StructureModifier<List<ItemStack>> itemAccess = windowItems.getItemListModifier();
|
|
|
|
List<ItemStack> items = new ArrayList<>();
|
|
items.add(this.itemWithData());
|
|
items.add(new ItemStack(Material.DIAMOND_AXE));
|
|
|
|
assertEquals(itemAccess.read(0).size(), 0);
|
|
|
|
// Insert and check that it was succesful
|
|
itemAccess.write(0, items);
|
|
|
|
// Read back array
|
|
List<ItemStack> comparison = itemAccess.read(0);
|
|
assertItemCollectionsEqual(items, comparison);
|
|
}
|
|
|
|
@Test
|
|
public void testGetNbtModifier() {
|
|
PacketContainer updateTileEntity = new PacketContainer(PacketType.Play.Server.TILE_ENTITY_DATA);
|
|
|
|
NbtCompound compound = NbtFactory.ofCompound("test");
|
|
compound.put("test", "name");
|
|
compound.put(NbtFactory.ofList("ages", 1, 2, 3));
|
|
|
|
updateTileEntity.getNbtModifier().write(0, compound);
|
|
|
|
NbtCompound result = (NbtCompound) updateTileEntity.getNbtModifier().read(0);
|
|
|
|
assertEquals(compound.getString("test"), result.getString("test"));
|
|
assertEquals(compound.getList("ages"), result.getList("ages"));
|
|
}
|
|
|
|
// TODO They removed DataWatchers from packets, it's all entity metadata packets now
|
|
/* @Test
|
|
public void testGetDataWatcherModifier() {
|
|
PacketContainer mobSpawnPacket = new PacketContainer(PacketType.Play.Server.ENTITY_METADATA);
|
|
StructureModifier<WrappedDataWatcher> watcherAccessor = mobSpawnPacket.getDataWatcherModifier();
|
|
|
|
WrappedDataWatcher dataWatcher = new WrappedDataWatcher();
|
|
dataWatcher.setObject(new WrappedDataWatcherObject(1, Registry.get(Byte.class)), (byte) 1);
|
|
dataWatcher.setObject(new WrappedDataWatcherObject(2, Registry.get(String.class)), "Lorem");
|
|
dataWatcher.setObject(new WrappedDataWatcherObject(3, Registry.get(Boolean.class)), true);
|
|
dataWatcher.setObject(new WrappedDataWatcherObject(4, Registry.getUUIDSerializer(true)), Optional.of(UUID.randomUUID()));
|
|
|
|
assertNull(watcherAccessor.read(0));
|
|
|
|
// Insert and read back
|
|
watcherAccessor.write(0, dataWatcher);
|
|
assertEquals(dataWatcher, watcherAccessor.read(0));
|
|
} */
|
|
|
|
// Unfortunately, it might be too difficult to mock this one
|
|
//
|
|
// @Test
|
|
// public void testGetEntityModifier() { }
|
|
|
|
// No packet expose this type directly.
|
|
//
|
|
// @Test
|
|
// public void testGetPositionModifier() { }
|
|
|
|
@Test
|
|
public void testEntityTypeModifier() {
|
|
PacketContainer packet = new PacketContainer(PacketType.Play.Server.SPAWN_ENTITY);
|
|
|
|
packet.getEntityTypeModifier().write(0, EntityType.ARROW);
|
|
assertEquals(packet.getEntityTypeModifier().read(0), EntityType.ARROW);
|
|
}
|
|
|
|
@Test
|
|
public void testGetPositionCollectionModifier() {
|
|
PacketContainer explosionPacket = new PacketContainer(PacketType.Play.Server.EXPLOSION);
|
|
StructureModifier<List<BlockPosition>> positionAccessor = explosionPacket.getBlockPositionCollectionModifier();
|
|
|
|
assertEquals(positionAccessor.read(0).size(), 0);
|
|
|
|
List<BlockPosition> positions = new ArrayList<>();
|
|
positions.add(new BlockPosition(1, 2, 3));
|
|
positions.add(new BlockPosition(3, 4, 5));
|
|
|
|
// Insert and read back
|
|
positionAccessor.write(0, positions);
|
|
List<BlockPosition> cloned = positionAccessor.read(0);
|
|
|
|
assertEquals(positions, cloned);
|
|
}
|
|
|
|
@Test
|
|
public void testGetDataValueCollectionModifier() {
|
|
PacketContainer entityMetadata = new PacketContainer(PacketType.Play.Server.ENTITY_METADATA);
|
|
StructureModifier<List<WrappedDataValue>> watchableAccessor = entityMetadata.getDataValueCollectionModifier();
|
|
|
|
assertEquals(0, watchableAccessor.read(0).size());
|
|
|
|
List<WrappedDataValue> values = Lists.newArrayList(
|
|
new WrappedDataValue(0, Registry.get(Byte.class), (byte) 21),
|
|
new WrappedDataValue(1, Registry.get(String.class), "World"));
|
|
|
|
// Insert and read back
|
|
watchableAccessor.write(0, values);
|
|
assertEquals(values, watchableAccessor.read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testGameProfiles() {
|
|
PacketContainer spawnEntity = new PacketContainer(PacketType.Login.Server.SUCCESS);
|
|
WrappedGameProfile profile = new WrappedGameProfile(UUID.fromString("d7047a08-3150-4aa8-a2f2-7c1e2b17e298"),
|
|
"name");
|
|
spawnEntity.getGameProfiles().write(0, profile);
|
|
|
|
assertEquals(profile, spawnEntity.getGameProfiles().read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testChatComponents() {
|
|
PacketContainer chatPacket = new PacketContainer(PacketType.Login.Server.DISCONNECT);
|
|
chatPacket.getChatComponents().write(0,
|
|
WrappedChatComponent.fromChatMessage("You shall not " + ChatColor.ITALIC + "pass!")[0]);
|
|
|
|
assertEquals("{\"extra\":[{\"text\":\"You shall not \"},{\"italic\":true,\"text\":\"pass!\"}],\"text\":\"\"}",
|
|
chatPacket.getChatComponents().read(0).getJson());
|
|
}
|
|
|
|
@Test
|
|
public void testSerialization() {
|
|
PacketContainer useItem = new PacketContainer(PacketType.Play.Client.USE_ITEM);
|
|
useItem.getMovingBlockPositions().write(0, new MovingObjectPositionBlock(
|
|
new BlockPosition(0, 1, 0),
|
|
new Vector(0, 1, 0),
|
|
Direction.DOWN,
|
|
false));
|
|
useItem.getHands().write(0, Hand.MAIN_HAND);
|
|
useItem.getIntegers().write(0, 5);
|
|
useItem.getLongs().write(0, System.currentTimeMillis());
|
|
|
|
PacketContainer copy = (PacketContainer) SerializationUtils.clone(useItem);
|
|
|
|
assertEquals(PacketType.Play.Client.USE_ITEM, copy.getType());
|
|
assertEquals(Hand.MAIN_HAND, copy.getHands().read(0));
|
|
assertEquals(5, copy.getIntegers().read(0));
|
|
|
|
MovingObjectPositionBlock pos = copy.getMovingBlockPositions().read(0);
|
|
assertEquals(1, pos.getBlockPosition().getY());
|
|
assertEquals(Direction.DOWN, pos.getDirection());
|
|
assertFalse(pos.isInsideBlock());
|
|
}
|
|
|
|
@Test
|
|
public void testBigPacketSerialization() {
|
|
PacketContainer payload = new PacketContainer(PacketType.Play.Server.CUSTOM_PAYLOAD);
|
|
payload.getMinecraftKeys().write(0, new com.comphenix.protocol.wrappers.MinecraftKey("test"));
|
|
|
|
byte[] randomData = new byte[8192];
|
|
ThreadLocalRandom.current().nextBytes(randomData);
|
|
|
|
ByteBuf serializer = (ByteBuf) MinecraftReflection.createPacketDataSerializer(randomData.length);
|
|
serializer.writeBytes(randomData);
|
|
|
|
payload.getModifier().withType(MinecraftReflection.getPacketDataSerializerClass()).write(0, serializer);
|
|
|
|
PacketContainer cloned = SerializableCloner.clone(payload);
|
|
com.comphenix.protocol.wrappers.MinecraftKey clonedKey = cloned.getMinecraftKeys().read(0);
|
|
|
|
byte[] clonedData = new byte[randomData.length];
|
|
ByteBuf clonedBuffer = (ByteBuf) cloned.getModifier()
|
|
.withType(MinecraftReflection.getPacketDataSerializerClass())
|
|
.read(0);
|
|
clonedBuffer.readBytes(clonedData);
|
|
|
|
assertEquals("minecraft:test", clonedKey.getFullKey());
|
|
assertArrayEquals(randomData, clonedData);
|
|
}
|
|
|
|
@Test
|
|
public void testIntList() {
|
|
PacketContainer destroy = new PacketContainer(PacketType.Play.Server.ENTITY_DESTROY);
|
|
destroy.getIntLists().write(0, new ArrayList<Integer>() {{
|
|
this.add(420);
|
|
this.add(69);
|
|
}});
|
|
List<Integer> back = destroy.getIntLists().read(0);
|
|
assertEquals(back.size(), 2);
|
|
assertEquals((int) back.get(0), 420);
|
|
assertEquals((int) back.get(1), 69);
|
|
}
|
|
|
|
@Test
|
|
public void testAttributeList() {
|
|
PacketContainer attribute = new PacketContainer(PacketType.Play.Server.UPDATE_ATTRIBUTES);
|
|
attribute.getIntegers().write(0, 123); // Entity ID
|
|
|
|
// Initialize some test data
|
|
List<AttributeModifier> modifiers = Lists.newArrayList(
|
|
new AttributeModifier(UUID.randomUUID(), "Unknown synced attribute modifier", 10,
|
|
AttributeModifier.Operation.a));
|
|
|
|
// Obtain an AttributeSnapshot instance. This is complicated by the fact that AttributeSnapshots
|
|
// are inner classes (which is ultimately pointless because AttributeSnapshots don't access any
|
|
// members of the packet itself)
|
|
PacketPlayOutUpdateAttributes packet = (PacketPlayOutUpdateAttributes) attribute.getHandle();
|
|
AttributeBase base = BuiltInRegistries.u.a(MinecraftKey.a("generic.max_health"));
|
|
AttributeSnapshot snapshot = new AttributeSnapshot(base, 20.0D, modifiers);
|
|
attribute.getSpecificModifier(List.class).write(0, Lists.newArrayList(snapshot));
|
|
|
|
PacketContainer cloned = attribute.deepClone();
|
|
AttributeSnapshot
|
|
clonedSnapshot = (AttributeSnapshot) cloned.getSpecificModifier(List.class).read(0).get(0);
|
|
|
|
// Compare the fields, because apparently the packet is a field in AttributeSnapshot
|
|
for (Field field : AttributeSnapshot.class.getDeclaredFields()) {
|
|
try {
|
|
// Skip the packet
|
|
if (field.getType().equals(packet.getClass())) {
|
|
continue;
|
|
}
|
|
|
|
field.setAccessible(true);
|
|
this.testEquality(field.get(snapshot), field.get(clonedSnapshot));
|
|
} catch (AssertionError e) {
|
|
throw e;
|
|
} catch (Throwable ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testBlocks() {
|
|
PacketContainer blockAction = new PacketContainer(PacketType.Play.Server.BLOCK_ACTION);
|
|
blockAction.getBlocks().write(0, Material.STONE);
|
|
|
|
assertEquals(Material.STONE, blockAction.getBlocks().read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testBlockData() {
|
|
PacketContainer blockChange = new PacketContainer(PacketType.Play.Server.BLOCK_CHANGE);
|
|
|
|
Material material = Material.GLOWSTONE;
|
|
WrappedBlockData data = WrappedBlockData.createData(material);
|
|
blockChange.getBlockData().write(0, data);
|
|
|
|
WrappedBlockData read = blockChange.getBlockData().read(0);
|
|
assertEquals(material, read.getType());
|
|
}
|
|
|
|
@Test
|
|
@SuppressWarnings("deprecation")
|
|
public void testPotionEffect() {
|
|
PotionEffect effect = new PotionEffect(PotionEffectType.FIRE_RESISTANCE, 20 * 60, 1);
|
|
MobEffect mobEffect = new MobEffect(MobEffectList.a(effect.getType().getId()), effect.getDuration(),
|
|
effect.getAmplifier(), effect.isAmbient(),
|
|
effect.hasParticles());
|
|
int entityId = 42;
|
|
|
|
// The constructor we want to call
|
|
PacketConstructor creator = PacketConstructor.DEFAULT.withPacket(
|
|
PacketType.Play.Server.ENTITY_EFFECT, new Class<?>[]{int.class, MobEffect.class});
|
|
PacketContainer packet = creator.createPacket(entityId, mobEffect);
|
|
|
|
assertEquals(entityId, packet.getIntegers().read(0));
|
|
assertEquals(effect.getAmplifier(), (byte) packet.getBytes().read(0));
|
|
assertEquals(effect.getDuration(), packet.getIntegers().read(1));
|
|
|
|
WrappedRegistry registry = WrappedRegistry.getRegistry(MinecraftReflection.getMobEffectListClass());
|
|
Object effectList = assertInstanceOf(MobEffectList.class, packet.getStructures().read(0).getHandle());
|
|
assertEquals(effect.getType().getId(), registry.getId(effectList));
|
|
|
|
int e = 0;
|
|
if (effect.isAmbient()) {
|
|
e |= 1;
|
|
}
|
|
if (effect.hasParticles()) {
|
|
e |= 2;
|
|
}
|
|
if (effect.hasIcon()) {
|
|
e |= 4;
|
|
}
|
|
|
|
assertEquals(e, (byte) packet.getBytes().read(1));
|
|
}
|
|
|
|
@Test
|
|
public void testPlayerAction() {
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Client.ENTITY_ACTION);
|
|
|
|
// no change across nms versions
|
|
container.getPlayerActions().write(0, EnumWrappers.PlayerAction.OPEN_INVENTORY);
|
|
assertEquals(container.getPlayerActions().read(0), EnumWrappers.PlayerAction.OPEN_INVENTORY);
|
|
|
|
// changed in 1.15
|
|
container.getPlayerActions().write(0, EnumWrappers.PlayerAction.START_SNEAKING);
|
|
assertEquals(container.getPlayerActions().read(0), EnumWrappers.PlayerAction.START_SNEAKING);
|
|
}
|
|
|
|
@Test
|
|
public void testMobEffectList() {
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.REMOVE_ENTITY_EFFECT);
|
|
container.getEffectTypes().write(0, PotionEffectType.GLOWING);
|
|
|
|
assertEquals(container.getEffectTypes().read(0), PotionEffectType.GLOWING);
|
|
}
|
|
|
|
@Test
|
|
public void testSoundCategory() {
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.NAMED_SOUND_EFFECT);
|
|
container.getSoundCategories().write(0, SoundCategory.PLAYERS);
|
|
|
|
assertEquals(SoundCategory.PLAYERS, container.getSoundCategories().read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testSoundEffects() {
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.NAMED_SOUND_EFFECT);
|
|
container.getSoundEffects().optionRead(0);
|
|
|
|
container.getSoundEffects().write(0, Sound.ENTITY_CAT_HISS);
|
|
|
|
assertEquals(container.getSoundEffects().read(0), Sound.ENTITY_CAT_HISS);
|
|
}
|
|
|
|
// @Test
|
|
public void testGenericEnums() {
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.BOSS);
|
|
container.getEnumModifier(Action.class, 1).write(0, Action.UPDATE_PCT);
|
|
|
|
// assertEquals(container.getEnumModifier(Action.class, PacketPlayOutBoss.d.class).read(0), Action.UPDATE_PCT);
|
|
}
|
|
|
|
@Test
|
|
public void testInternalStructures() {
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.SCOREBOARD_TEAM);
|
|
Optional<InternalStructure> optStruct = container.getOptionalStructures().read(0);
|
|
assertTrue(optStruct.isPresent());
|
|
InternalStructure struct = optStruct.get();
|
|
struct.getChatComponents().write(0, WrappedChatComponent.fromText("hi there"));
|
|
container.getOptionalStructures().write(0, Optional.of(struct));
|
|
|
|
optStruct = container.getOptionalStructures().read(0);
|
|
assertTrue(optStruct.isPresent());
|
|
struct = optStruct.get();
|
|
this.testEquality(
|
|
struct.getChatComponents().read(0),
|
|
WrappedChatComponent.fromText("hi there")
|
|
);
|
|
}
|
|
|
|
// @Test
|
|
public void testDimensions() {
|
|
// TODO this won't work in testing, but hopefully will in live
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.RESPAWN);
|
|
container.getDimensions().write(0, 1);
|
|
assertEquals((Object) 1, container.getDimensions().read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testEntityEquipment() {
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.ENTITY_EQUIPMENT);
|
|
|
|
List<Pair<EnumWrappers.ItemSlot, ItemStack>> data = new ArrayList<>();
|
|
data.add(new Pair<>(EnumWrappers.ItemSlot.CHEST, new ItemStack(Material.NETHERITE_CHESTPLATE)));
|
|
data.add(new Pair<>(EnumWrappers.ItemSlot.LEGS, new ItemStack(Material.GOLDEN_LEGGINGS)));
|
|
|
|
container.getSlotStackPairLists().write(0, data);
|
|
|
|
List<Pair<EnumWrappers.ItemSlot, ItemStack>> written = container.getSlotStackPairLists().read(0);
|
|
assertEquals(data, written);
|
|
}
|
|
|
|
@Test
|
|
public void testMovingBlockPos() {
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Client.USE_ITEM);
|
|
|
|
Vector vector = new Vector(0, 1, 2);
|
|
BlockPosition position = new BlockPosition(3, 4, 5);
|
|
EnumWrappers.Direction direction = EnumWrappers.Direction.DOWN;
|
|
|
|
MovingObjectPositionBlock movingPos = new MovingObjectPositionBlock(position, vector, direction, true);
|
|
container.getMovingBlockPositions().write(0, movingPos);
|
|
|
|
MovingObjectPositionBlock back = container.getMovingBlockPositions().read(0);
|
|
|
|
assertEquals(back.getPosVector(), vector);
|
|
assertEquals(back.getBlockPosition(), position);
|
|
assertEquals(back.getDirection(), direction);
|
|
assertTrue(back.isInsideBlock());
|
|
}
|
|
|
|
@Test
|
|
public void testMultiBlockChange() {
|
|
PacketContainer packet = new PacketContainer(PacketType.Play.Server.MULTI_BLOCK_CHANGE);
|
|
|
|
packet.getShortArrays().writeSafely(0, new short[]{420, 69});
|
|
assertArrayEquals(new short[]{420, 69}, packet.getShortArrays().readSafely(0));
|
|
|
|
packet.getBlockDataArrays().writeSafely(0, new WrappedBlockData[]{
|
|
WrappedBlockData.createData(Material.IRON_BARS),
|
|
WrappedBlockData.createData(Material.IRON_BLOCK)
|
|
});
|
|
assertArrayEquals(new WrappedBlockData[]{
|
|
WrappedBlockData.createData(Material.IRON_BARS),
|
|
WrappedBlockData.createData(Material.IRON_BLOCK)
|
|
}, packet.getBlockDataArrays().readSafely(0));
|
|
|
|
packet.getSectionPositions().writeSafely(0, new BlockPosition(42, 43, 44));
|
|
assertEquals(new BlockPosition(42, 43, 44), packet.getSectionPositions().readSafely(0));
|
|
|
|
PacketContainer clone = packet.deepClone();
|
|
assertNotSame(clone, packet);
|
|
}
|
|
|
|
@Test
|
|
public void testGameStateChange() {
|
|
PacketContainer packet = new PacketContainer(PacketType.Play.Server.GAME_STATE_CHANGE);
|
|
assertEquals(0, (int) packet.getGameStateIDs().read(0));
|
|
|
|
packet.getGameStateIDs().write(0, 2);
|
|
assertEquals(2, (int) packet.getGameStateIDs().read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testUseEntity() {
|
|
PacketContainer packet = new PacketContainer(PacketType.Play.Client.USE_ENTITY);
|
|
|
|
WrappedEnumEntityUseAction action;
|
|
WrappedEnumEntityUseAction clone;
|
|
// test attack
|
|
packet.getEnumEntityUseActions().write(0, WrappedEnumEntityUseAction.attack());
|
|
action = packet.getEnumEntityUseActions().read(0);
|
|
// attack's handle should always be the same
|
|
assertEquals(WrappedEnumEntityUseAction.attack(), action);
|
|
assertEquals(EntityUseAction.ATTACK, action.getAction());
|
|
// hand & position should not be available
|
|
assertThrows(IllegalArgumentException.class, action::getHand);
|
|
assertThrows(IllegalArgumentException.class, action::getPosition);
|
|
// test cloning
|
|
clone = action.deepClone();
|
|
assertSame(WrappedEnumEntityUseAction.attack(), clone);
|
|
|
|
// test interact
|
|
packet.getEnumEntityUseActions().write(0, WrappedEnumEntityUseAction.interact(Hand.OFF_HAND));
|
|
action = packet.getEnumEntityUseActions().read(0);
|
|
assertEquals(EntityUseAction.INTERACT, action.getAction());
|
|
assertEquals(Hand.OFF_HAND, action.getHand());
|
|
// position should not be available
|
|
assertThrows(IllegalArgumentException.class, action::getPosition);
|
|
// test cloning
|
|
clone = action.deepClone();
|
|
assertEquals(EntityUseAction.INTERACT, clone.getAction());
|
|
assertEquals(Hand.OFF_HAND, clone.getHand());
|
|
|
|
// test interact_at
|
|
Vector position = new Vector(1, 199, 4);
|
|
packet.getEnumEntityUseActions().write(0, WrappedEnumEntityUseAction.interactAt(Hand.MAIN_HAND, position));
|
|
action = packet.getEnumEntityUseActions().read(0);
|
|
assertEquals(EntityUseAction.INTERACT_AT, action.getAction());
|
|
assertEquals(Hand.MAIN_HAND, action.getHand());
|
|
assertEquals(position, action.getPosition());
|
|
// test cloning
|
|
clone = action.deepClone();
|
|
assertEquals(EntityUseAction.INTERACT_AT, clone.getAction());
|
|
assertEquals(Hand.MAIN_HAND, clone.getHand());
|
|
assertEquals(position, clone.getPosition());
|
|
}
|
|
|
|
@Test
|
|
public void testSetSimulationDistance() {
|
|
// first packet which is a record - set will fail if we missed something during patching
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.UPDATE_SIMULATION_DISTANCE);
|
|
container.getIntegers().write(0, 1234);
|
|
assertEquals(1234, (int) container.getIntegers().read(0));
|
|
}
|
|
|
|
@Test
|
|
public void testMapChunk() {
|
|
// this is a special case as we are generating a data serializer class (we only need to construct the packet)
|
|
PacketContainer container = new PacketContainer(PacketType.Play.Server.MAP_CHUNK);
|
|
// check if we can read an nbt compound from the class
|
|
assertTrue(container.getStructures().read(0).getNbtModifier().optionRead(0).isPresent());
|
|
}
|
|
|
|
@Test
|
|
public void testComponentArrays() {
|
|
PacketContainer signChange = new PacketContainer(PacketType.Play.Server.TILE_ENTITY_DATA);
|
|
WrappedChatComponent[] components = new WrappedChatComponent[]{
|
|
WrappedChatComponent.fromText("hello world"), WrappedChatComponent.fromText(""),
|
|
WrappedChatComponent.fromText(""), WrappedChatComponent.fromText("")
|
|
};
|
|
signChange.getChatComponentArrays().write(0, components);
|
|
|
|
WrappedChatComponent[] back = signChange.getChatComponentArrays().read(0);
|
|
assertArrayEquals(components, back);
|
|
}
|
|
|
|
@Test
|
|
public void testPlayerInfoActions() {
|
|
PacketContainer updatePlayerInfoActions = new PacketContainer(PacketType.Play.Server.PLAYER_INFO);
|
|
|
|
EnumSet<EnumWrappers.PlayerInfoAction> actions = EnumSet.of(
|
|
EnumWrappers.PlayerInfoAction.ADD_PLAYER,
|
|
EnumWrappers.PlayerInfoAction.UPDATE_LATENCY,
|
|
EnumWrappers.PlayerInfoAction.UPDATE_LISTED);
|
|
updatePlayerInfoActions.getPlayerInfoActions().write(0, actions);
|
|
|
|
UUID id = UUID.randomUUID();
|
|
PlayerInfoData data = new PlayerInfoData(
|
|
id,
|
|
20,
|
|
false,
|
|
NativeGameMode.CREATIVE,
|
|
new WrappedGameProfile(new UUID(0, 0), "system"),
|
|
null,
|
|
(WrappedRemoteChatSessionData) null);
|
|
updatePlayerInfoActions.getPlayerInfoDataLists().write(1, Collections.singletonList(data));
|
|
|
|
Set<EnumWrappers.PlayerInfoAction> readActions = updatePlayerInfoActions.getPlayerInfoActions().read(0);
|
|
Assertions.assertTrue(readActions.contains(EnumWrappers.PlayerInfoAction.ADD_PLAYER));
|
|
Assertions.assertTrue(readActions.contains(EnumWrappers.PlayerInfoAction.UPDATE_LATENCY));
|
|
Assertions.assertTrue(readActions.contains(EnumWrappers.PlayerInfoAction.UPDATE_LISTED));
|
|
|
|
Collection<PlayerInfoData> readData = updatePlayerInfoActions.getPlayerInfoDataLists().read(1);
|
|
Assertions.assertEquals(1, readData.size());
|
|
|
|
PlayerInfoData firstData = readData.iterator().next();
|
|
Assertions.assertFalse(data.isListed());
|
|
Assertions.assertEquals(id, data.getProfileId());
|
|
Assertions.assertEquals("system", firstData.getProfile().getName());
|
|
Assertions.assertEquals(20, firstData.getLatency());
|
|
Assertions.assertEquals(NativeGameMode.CREATIVE, firstData.getGameMode());
|
|
}
|
|
|
|
// TODO: fix this this at some point
|
|
/*
|
|
@Test
|
|
public void testSignedChatMessage() {
|
|
PacketContainer chatPacket = new PacketContainer(PacketType.Play.Client.CHAT);
|
|
|
|
byte[] signature = new byte[512];
|
|
long salt = 124L;
|
|
WrappedSaltedSignature wrappedSignature = new WrappedSaltedSignature(salt, signature);
|
|
chatPacket.getSignatures().write(0, wrappedSignature);
|
|
|
|
WrappedSaltedSignature read = chatPacket.getSignatures().read(0);
|
|
assertEquals(salt, read.getSalt());
|
|
assertArrayEquals(signature, read.getSignature());
|
|
}*/
|
|
|
|
private void assertPacketsEqualAndSerializable(PacketContainer constructed, PacketContainer cloned) {
|
|
StructureModifier<Object> firstMod = constructed.getModifier(), secondMod = cloned.getModifier();
|
|
assertEquals(firstMod.size(), secondMod.size());
|
|
|
|
if (PacketType.Status.Server.SERVER_INFO.equals(constructed.getType())) {
|
|
assertArrayEquals(SerializationUtils.serialize(constructed), SerializationUtils.serialize(cloned));
|
|
} else {
|
|
// Make sure all the fields are equivalent
|
|
for (int i = 0; i < firstMod.size(); i++) {
|
|
if (firstMod.getField(i).getType().isArray()) {
|
|
assertArrayEquals(this.getArray(firstMod.read(i)), this.getArray(secondMod.read(i)));
|
|
} else {
|
|
this.testEquality(firstMod.read(i), secondMod.read(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
Object buffer = MinecraftReflection.createPacketDataSerializer(0);
|
|
MinecraftMethods.getPacketWriteByteBufMethod().invoke(cloned.getHandle(), buffer);
|
|
}
|
|
|
|
@Test
|
|
public void testCloning() {
|
|
// Try constructing all the packets
|
|
for (PacketType type : PacketType.values()) {
|
|
// TODO: try to support chat - for now chat contains to many sub classes to properly clone it
|
|
if (type.isDeprecated() || !type.isSupported() || type.name().contains("CUSTOM_PAYLOAD") || type.name().contains("CHAT")
|
|
|| type.name().contains("BUNDLE")) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
PacketContainer constructed = new PacketContainer(type);
|
|
|
|
// Initialize default values
|
|
constructed.getModifier().writeDefaults();
|
|
|
|
// Make sure watchable collections can be cloned
|
|
if (type == PacketType.Play.Server.ENTITY_METADATA) {
|
|
constructed.getDataValueCollectionModifier().write(0, Lists.newArrayList(
|
|
new WrappedDataValue(0, Registry.get(Byte.class), (byte) 1),
|
|
new WrappedDataValue(0, Registry.get(Float.class), 5F),
|
|
new WrappedDataValue(0, Registry.get(String.class), "String"),
|
|
new WrappedDataValue(0, Registry.get(Boolean.class), true),
|
|
new WrappedDataValue(
|
|
0,
|
|
Registry.getChatComponentSerializer(true),
|
|
Optional.of(ComponentConverter.fromBaseComponent(TEST_COMPONENT).getHandle())),
|
|
new WrappedDataValue(
|
|
0,
|
|
Registry.getItemStackSerializer(false),
|
|
BukkitConverters.getItemStackConverter().getGeneric(new ItemStack(Material.WOODEN_AXE))),
|
|
new WrappedDataValue(0, Registry.get(CatVariant.class), BuiltInRegistries.ai.e(CatVariant.e)),
|
|
new WrappedDataValue(0, Registry.get(FrogVariant.class), FrogVariant.a)
|
|
));
|
|
} else if (type == PacketType.Play.Server.CHAT) {
|
|
constructed.getChatComponents().write(0, ComponentConverter.fromBaseComponent(TEST_COMPONENT));
|
|
} else if (type == PacketType.Play.Server.REMOVE_ENTITY_EFFECT || type == PacketType.Play.Server.ENTITY_EFFECT) {
|
|
constructed.getEffectTypes().write(0, PotionEffectType.GLOWING);
|
|
} else if (type == PacketType.Play.Server.GAME_STATE_CHANGE) {
|
|
constructed.getStructures().write(
|
|
0,
|
|
InternalStructure.getConverter().getSpecific(PacketPlayOutGameStateChange.a));
|
|
} else if (type == PacketType.Play.Client.USE_ITEM || type == PacketType.Play.Client.BLOCK_PLACE) {
|
|
constructed.getLongs().write(0, 0L); // timestamp of the packet, not sent over the network
|
|
}
|
|
|
|
// gives some indication which cloning process fails as the checks itself are happening outside this method
|
|
|
|
// Clone the packet all three ways
|
|
PacketContainer shallowCloned = constructed.shallowClone();
|
|
this.assertPacketsEqualAndSerializable(constructed, shallowCloned);
|
|
|
|
PacketContainer deepCloned = constructed.deepClone();
|
|
this.assertPacketsEqualAndSerializable(constructed, deepCloned);
|
|
|
|
PacketContainer serializedCloned = SerializableCloner.clone(constructed);
|
|
if (type == PacketType.Play.Client.USE_ITEM || type == PacketType.Play.Client.BLOCK_PLACE) {
|
|
// shit fix - but what are we supposed to do :/
|
|
serializedCloned.getLongs().write(0, 0L);
|
|
}
|
|
this.assertPacketsEqualAndSerializable(constructed, serializedCloned);
|
|
} catch (Throwable t) {
|
|
Assertions.fail("Unable to clone " + type, t);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convert to objects that support equals()
|
|
private void testEquality(Object a, Object b) {
|
|
if (a == null) {
|
|
if (b == null) {
|
|
return;
|
|
} else {
|
|
throw new AssertionError("a was null, but b was not");
|
|
}
|
|
} else if (b == null) {
|
|
throw new AssertionError("a was not null, but b was null");
|
|
}
|
|
|
|
if (a instanceof Optional) {
|
|
if (b instanceof Optional) {
|
|
this.testEquality(((Optional<?>) a).orElse(null), ((Optional<?>) b).orElse(null));
|
|
return;
|
|
} else {
|
|
throw new AssertionError("a was optional, but b was not");
|
|
}
|
|
}
|
|
|
|
if (a.equals(b) || Objects.equals(a, b) || this.stringEquality(a, b)) {
|
|
return;
|
|
}
|
|
|
|
if (MinecraftReflection.isDataWatcher(a)) {
|
|
a = this.watchConvert.getSpecific(a);
|
|
b = this.watchConvert.getSpecific(b);
|
|
} else if (MinecraftReflection.isItemStack(a)) {
|
|
a = this.itemConvert.getSpecific(a);
|
|
b = this.itemConvert.getSpecific(b);
|
|
}
|
|
|
|
if (a instanceof ItemStack && b instanceof ItemStack) {
|
|
assertItemsEqual((ItemStack) a, (ItemStack) b);
|
|
return;
|
|
}
|
|
|
|
if (a instanceof List<?>) {
|
|
if (b instanceof List<?>) {
|
|
List<?> listA = (List<?>) a;
|
|
List<?> listB = (List<?>) b;
|
|
|
|
assertEquals(listA.size(), listB.size());
|
|
for (int i = 0; i < listA.size(); i++) {
|
|
this.testEquality(listA.get(i), listB.get(i));
|
|
}
|
|
return;
|
|
} else {
|
|
throw new AssertionError("a was a list, but b was not");
|
|
}
|
|
}
|
|
|
|
if (a.getClass().isArray()) {
|
|
if (b.getClass().isArray()) {
|
|
int arrayLengthA = Array.getLength(a);
|
|
int arrayLengthB = Array.getLength(b);
|
|
|
|
assertEquals(arrayLengthA, arrayLengthB);
|
|
for (int i = 0; i < arrayLengthA; i++) {
|
|
Object elementA = Array.get(a, i);
|
|
Object elementB = Array.get(b, i);
|
|
|
|
testEquality(elementA, elementB);
|
|
}
|
|
return;
|
|
} else {
|
|
throw new AssertionError("a was an array, but b was not");
|
|
}
|
|
}
|
|
|
|
if (!a.getClass().isAssignableFrom(b.getClass())) {
|
|
assertEquals(a, b);
|
|
return;
|
|
}
|
|
|
|
Set<Field> fields = FuzzyReflection.fromObject(a, true).getFields();
|
|
for (Field field : fields) {
|
|
if (!Modifier.isStatic(field.getModifiers())) {
|
|
FieldAccessor accessor = Accessors.getFieldAccessor(field);
|
|
testEquality(accessor.get(a), accessor.get(b));
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean stringEquality(Object a, Object b) {
|
|
try {
|
|
return a.toString().equals(b.toString());
|
|
} catch (Exception ex) {
|
|
// internal null pointers, usually
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the underlying array as an object array.
|
|
*
|
|
* @param val - array wrapped as an Object.
|
|
* @return An object array.
|
|
*/
|
|
private Object[] getArray(Object val) {
|
|
if (val instanceof Object[]) {
|
|
return (Object[]) val;
|
|
}
|
|
if (val == null) {
|
|
return null;
|
|
}
|
|
|
|
int arrlength = Array.getLength(val);
|
|
Object[] outputArray = new Object[arrlength];
|
|
|
|
for (int i = 0; i < arrlength; ++i) {
|
|
outputArray[i] = Array.get(val, i);
|
|
}
|
|
return outputArray;
|
|
}
|
|
|
|
/**
|
|
* Actions from the outbound Boss packet. Used for testing generic enums.
|
|
*
|
|
* @author dmulloy2
|
|
*/
|
|
public enum Action {
|
|
ADD,
|
|
REMOVE,
|
|
UPDATE_PCT,
|
|
UPDATE_NAME,
|
|
UPDATE_STYLE,
|
|
UPDATE_PROPERTIES
|
|
}
|
|
}
|