diff --git a/pom.xml b/pom.xml
index 3cdf5b4eb19fad5e75e4567cc8593238a65dcac7..331457fd950b4710fdb14f3b47d49b4ffbafa871 100644
--- a/pom.xml
+++ b/pom.xml
@@ -15,7 +15,8 @@
 		<l2j-server-game.version>2.6.2.0-SNAPSHOT</l2j-server-game.version>
 		<!-- Test -->
 		<testng.version>7.3.0</testng.version>
-		<mockito.version>3.5.2</mockito.version>
+		<easymock.version>4.2</easymock.version>
+		<powermock.version>2.0.7</powermock.version>
 		<!-- Plugins -->
 		<maven-jar-plugin.version>3.2.0</maven-jar-plugin.version>
 		<maven-assembly-plugin.version>3.3.0</maven-assembly-plugin.version>
@@ -39,15 +40,27 @@
 			<scope>test</scope>
 		</dependency>
 		<dependency>
-			<groupId>org.mockito</groupId>
-			<artifactId>mockito-core</artifactId>
-			<version>${mockito.version}</version>
+			<groupId>org.easymock</groupId>
+			<artifactId>easymock</artifactId>
+			<version>${easymock.version}</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
-			<groupId>org.mockito</groupId>
-			<artifactId>mockito-inline</artifactId>
-			<version>${mockito.version}</version>
+			<groupId>org.powermock</groupId>
+			<artifactId>powermock-core</artifactId>
+			<version>${powermock.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.powermock</groupId>
+			<artifactId>powermock-api-easymock</artifactId>
+			<version>${powermock.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.powermock</groupId>
+			<artifactId>powermock-module-testng</artifactId>
+			<version>${powermock.version}</version>
 			<scope>test</scope>
 		</dependency>
 	</dependencies>
diff --git a/src/main/java/com/l2jserver/datapack/handlers/targethandlers/EnemyOnly.java b/src/main/java/com/l2jserver/datapack/handlers/targethandlers/EnemyOnly.java
index 2ffbf2c7c0f7c884f4e2a18e9fc82fe12b7947b2..8ec49db721913e9517b6f027dc612e9ff036250f 100644
--- a/src/main/java/com/l2jserver/datapack/handlers/targethandlers/EnemyOnly.java
+++ b/src/main/java/com/l2jserver/datapack/handlers/targethandlers/EnemyOnly.java
@@ -18,13 +18,15 @@
  */
 package com.l2jserver.datapack.handlers.targethandlers;
 
+import static com.l2jserver.gameserver.model.skills.targets.AffectScope.SINGLE;
 import static com.l2jserver.gameserver.model.skills.targets.L2TargetType.ENEMY_ONLY;
+import static com.l2jserver.gameserver.model.zone.ZoneId.PVP;
 import static com.l2jserver.gameserver.network.SystemMessageId.INCORRECT_TARGET;
 
 import com.l2jserver.gameserver.handler.ITargetTypeHandler;
+import com.l2jserver.gameserver.instancemanager.DuelManager;
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.L2Character;
-import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.model.skills.Skill;
 import com.l2jserver.gameserver.model.skills.targets.L2TargetType;
 
@@ -36,30 +38,100 @@ import com.l2jserver.gameserver.model.skills.targets.L2TargetType;
 public class EnemyOnly implements ITargetTypeHandler {
 	@Override
 	public L2Object[] getTargetList(Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target) {
-		switch (skill.getAffectScope()) {
-			case SINGLE: {
-				if (target == null) {
-					return EMPTY_TARGET_LIST;
-				}
-				
-				final L2PcInstance player = activeChar.getActingPlayer();
-				if (target.isDead() || (!target.isAttackable() && //
-					(player != null) && //
-					!player.isInPartyWith(target) && //
-					!player.isInClanWith(target) && //
-					!player.isInAllyWith(target) && // TODO(Zoey76): Confirm.
-					!player.isInCommandChannelWith(target) && // TODO(Zoey76): Confirm.
-					!player.checkIfPvP(target))) {
-					activeChar.sendPacket(INCORRECT_TARGET);
-					return EMPTY_TARGET_LIST;
-				}
-				
+		if (skill.getAffectScope() != SINGLE) {
+			return EMPTY_TARGET_LIST;
+		}
+		
+		if (target == null) {
+			return EMPTY_TARGET_LIST;
+		}
+		
+		if (target.isDead()) {
+			activeChar.sendPacket(INCORRECT_TARGET);
+			return EMPTY_TARGET_LIST;
+		}
+		
+		if (target.isAttackable()) {
+			return new L2Character[] {
+				target
+			};
+		}
+		
+		final var player = activeChar.getActingPlayer();
+		if (player == null) {
+			return EMPTY_TARGET_LIST;
+		}
+		
+		// In Olympiad, different sides.
+		if (player.isInOlympiadMode()) {
+			final var targetPlayer = target.getActingPlayer();
+			if ((targetPlayer != null) && (player.getOlympiadSide() != targetPlayer.getOlympiadSide())) {
+				return new L2Character[] {
+					target
+				};
+			}
+			player.sendPacket(INCORRECT_TARGET);
+			return EMPTY_TARGET_LIST;
+		}
+		
+		// In Duel, different sides.
+		if (player.isInDuelWith(target)) {
+			final var targetPlayer = target.getActingPlayer();
+			final var duel = DuelManager.getInstance().getDuel(player.getDuelId());
+			final var teamA = duel.getTeamA();
+			final var teamB = duel.getTeamB();
+			if (teamA.contains(player) && teamB.contains(targetPlayer) || //
+				teamB.contains(player) && teamA.contains(targetPlayer)) {
 				return new L2Character[] {
 					target
 				};
 			}
+			player.sendPacket(INCORRECT_TARGET);
+			return EMPTY_TARGET_LIST;
+		}
+		
+		// Not in same party.
+		if (player.isInPartyWith(target)) {
+			player.sendPacket(INCORRECT_TARGET);
+			return EMPTY_TARGET_LIST;
+		}
+		
+		// In PVP Zone.
+		if (player.isInsideZone(PVP)) {
+			return new L2Character[] {
+				target
+			};
+		}
+		
+		// Not in same clan.
+		if (player.isInClanWith(target)) {
+			player.sendPacket(INCORRECT_TARGET);
+			return EMPTY_TARGET_LIST;
+		}
+		
+		// TODO(Zoey76): Validate.
+		// Not in same alliance.
+		if (player.isInAllyWith(target)) {
+			player.sendPacket(INCORRECT_TARGET);
+			return EMPTY_TARGET_LIST;
+		}
+		
+		// TODO(Zoey76): Validate.
+		// Not in same command channel.
+		if (player.isInCommandChannelWith(target)) {
+			player.sendPacket(INCORRECT_TARGET);
+			return EMPTY_TARGET_LIST;
+		}
+		
+		// Cannot PvP.
+		if (!player.checkIfPvP(target)) {
+			player.sendPacket(INCORRECT_TARGET);
+			return EMPTY_TARGET_LIST;
 		}
-		return EMPTY_TARGET_LIST;
+		
+		return new L2Character[] {
+			target
+		};
 	}
 	
 	@Override
diff --git a/src/test/java/com/l2jserver/datapack/handlers/admincommandhandlers/AdminReloadTest.java b/src/test/java/com/l2jserver/datapack/handlers/admincommandhandlers/AdminReloadTest.java
index c4ec78efcc6446b4478362e78bd55729c63aaea4..374b993b9ebbea47af5c6afad3c3aea92767c920 100644
--- a/src/test/java/com/l2jserver/datapack/handlers/admincommandhandlers/AdminReloadTest.java
+++ b/src/test/java/com/l2jserver/datapack/handlers/admincommandhandlers/AdminReloadTest.java
@@ -19,14 +19,16 @@
 package com.l2jserver.datapack.handlers.admincommandhandlers;
 
 import static com.l2jserver.gameserver.config.Configuration.general;
+import static org.easymock.EasyMock.anyString;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.expectLastCall;
+import static org.powermock.api.easymock.PowerMock.replay;
 import static org.testng.Assert.assertFalse;
 
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.testng.annotations.BeforeMethod;
+import org.powermock.api.easymock.annotation.Mock;
 import org.testng.annotations.Test;
 
-import com.l2jserver.gameserver.handler.IAdminCommandHandler;
+import com.l2jserver.datapack.test.AbstractTest;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 /**
@@ -34,22 +36,22 @@ import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  * @author Zoey76
  * @version 2.6.1.0
  */
-public class AdminReloadTest {
-	
-	private final IAdminCommandHandler cmd = new AdminReload();
+public class AdminReloadTest extends AbstractTest {
 	
 	@Mock
-	private L2PcInstance activeChar;
+	private L2PcInstance player;
 	
-	@BeforeMethod
-	public void setup() {
-		MockitoAnnotations.openMocks(this);
-	}
+	private final AdminReload adminReload = new AdminReload();
 	
 	@Test
 	public void useAdminCommandTest() {
 		general().setProperty("EverybodyHasAdminRights", "true");
-		cmd.useAdminCommand("admin_reload config general", activeChar);
+		expect(player.getName()).andReturn("Zoey76");
+		player.sendMessage(anyString());
+		expectLastCall();
+		replay(player);
+		
+		adminReload.useAdminCommand("admin_reload config general", player);
 		assertFalse(general().everybodyHasAdminRights());
 	}
 }
diff --git a/src/test/java/com/l2jserver/datapack/handlers/targethandlers/EnemyOnlyTest.java b/src/test/java/com/l2jserver/datapack/handlers/targethandlers/EnemyOnlyTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bdf4f37ad475df65a9c94c1511651d91194f5f07
--- /dev/null
+++ b/src/test/java/com/l2jserver/datapack/handlers/targethandlers/EnemyOnlyTest.java
@@ -0,0 +1,340 @@
+/*
+ * Copyright © 2004-2020 L2J DataPack
+ * 
+ * This file is part of L2J DataPack.
+ * 
+ * L2J DataPack 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 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * L2J DataPack 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.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.datapack.handlers.targethandlers;
+
+import static com.l2jserver.gameserver.handler.ITargetTypeHandler.EMPTY_TARGET_LIST;
+import static com.l2jserver.gameserver.model.skills.targets.AffectScope.NONE;
+import static com.l2jserver.gameserver.model.skills.targets.AffectScope.SINGLE;
+import static com.l2jserver.gameserver.model.zone.ZoneId.PVP;
+import static com.l2jserver.gameserver.network.SystemMessageId.INCORRECT_TARGET;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.expectLastCall;
+import static org.powermock.api.easymock.PowerMock.mockStatic;
+import static org.powermock.api.easymock.PowerMock.replay;
+import static org.testng.Assert.assertEquals;
+
+import java.util.List;
+
+import org.powermock.api.easymock.annotation.Mock;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.testng.annotations.Test;
+
+import com.l2jserver.datapack.test.AbstractTest;
+import com.l2jserver.gameserver.instancemanager.DuelManager;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.entity.Duel;
+import com.l2jserver.gameserver.model.skills.Skill;
+
+/**
+ * Enemy Only test.
+ * @author Zoey76
+ * @version 2.6.2.0
+ */
+@PrepareForTest(DuelManager.class)
+public class EnemyOnlyTest extends AbstractTest {
+	
+	@Mock
+	private Skill skill;
+	@Mock
+	private L2Character activeChar;
+	@Mock
+	private L2Character target;
+	@Mock
+	private L2PcInstance player;
+	@Mock
+	private L2PcInstance targetPlayer;
+	@Mock
+	private L2PcInstance otherPlayer;
+	@Mock
+	private DuelManager duelManager;
+	@Mock
+	private Duel duel;
+	
+	private final EnemyOnly enemyOnly = new EnemyOnly();
+	
+	@Test
+	public void test_invalid_affect_scope_should_return_empty_target_list() {
+		expect(skill.getAffectScope()).andReturn(NONE);
+		replay(skill);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_null_target_should_return_empty_target_list() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		replay(skill);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, null);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_dead_target_should_return_empty_target_list_with_invalid_target_message() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(true);
+		activeChar.sendPacket(INCORRECT_TARGET);
+		expectLastCall().once();
+		replay(skill, target, activeChar);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_attackable_target_should_return_target() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(true);
+		replay(skill, target);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(target, actual[0]);
+	}
+	
+	@Test
+	public void test_null_player_should_return_empty_target_list() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(null);
+		replay(skill, target, activeChar);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_player_in_olympiad_should_return_target_if_target_is_on_the_other_side() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(true);
+		expect(target.getActingPlayer()).andReturn(targetPlayer);
+		expect(player.getOlympiadSide()).andReturn(0);
+		expect(targetPlayer.getOlympiadSide()).andReturn(1);
+		replay(skill, target, activeChar, player, targetPlayer);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(target, actual[0]);
+	}
+	
+	@Test
+	public void test_player_in_olympiad_should_return_empty_target_list_if_target_is_on_the_same_side() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(true);
+		expect(target.getActingPlayer()).andReturn(targetPlayer);
+		expect(player.getOlympiadSide()).andReturn(0);
+		expect(targetPlayer.getOlympiadSide()).andReturn(0);
+		player.sendPacket(INCORRECT_TARGET);
+		expectLastCall().once();
+		replay(skill, target, activeChar, player, targetPlayer);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_player_in_duel_should_return_target_if_target_is_on_the_other_side() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(true);
+		expect(player.getDuelId()).andReturn(1);
+		expect(target.getActingPlayer()).andReturn(targetPlayer);
+		
+		mockStatic(DuelManager.class);
+		expect(DuelManager.getInstance()).andReturn(duelManager);
+		expect(duelManager.getDuel(1)).andReturn(duel);
+		expect(duel.getTeamA()).andReturn(List.of(player));
+		expect(duel.getTeamB()).andReturn(List.of(targetPlayer));
+		replay(skill, target, activeChar, player, duelManager, duel, DuelManager.class);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(target, actual[0]);
+	}
+	
+	@Test
+	public void test_player_in_duel_should_return_empty_target_list_if_target_is_on_the_same_side() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(true);
+		expect(player.getDuelId()).andReturn(1);
+		expect(target.getActingPlayer()).andReturn(targetPlayer);
+		
+		mockStatic(DuelManager.class);
+		expect(DuelManager.getInstance()).andReturn(duelManager);
+		expect(duelManager.getDuel(1)).andReturn(duel);
+		expect(duel.getTeamA()).andReturn(List.of(player, targetPlayer));
+		expect(duel.getTeamB()).andReturn(List.of(otherPlayer));
+		
+		player.sendPacket(INCORRECT_TARGET);
+		expectLastCall().once();
+		replay(skill, target, activeChar, player, duelManager, duel, DuelManager.class);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_player_in_party_with_target_should_return_empty_target_list() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(false);
+		expect(player.isInPartyWith(target)).andReturn(true);
+		player.sendPacket(INCORRECT_TARGET);
+		expectLastCall().once();
+		replay(skill, target, activeChar, player);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_player_in_pvp_zone_should_return_target() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(false);
+		expect(player.isInPartyWith(target)).andReturn(false);
+		expect(player.isInsideZone(PVP)).andReturn(true);
+		replay(skill, target, activeChar, player);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(target, actual[0]);
+	}
+	
+	@Test
+	public void test_player_in_clan_with_target_should_return_empty_target_list() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(false);
+		expect(player.isInPartyWith(target)).andReturn(false);
+		expect(player.isInsideZone(PVP)).andReturn(false);
+		expect(player.isInClanWith(target)).andReturn(true);
+		player.sendPacket(INCORRECT_TARGET);
+		expectLastCall().once();
+		replay(skill, target, activeChar, player);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_player_in_alliance_with_target_should_return_empty_target_list() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(false);
+		expect(player.isInPartyWith(target)).andReturn(false);
+		expect(player.isInsideZone(PVP)).andReturn(false);
+		expect(player.isInClanWith(target)).andReturn(false);
+		expect(player.isInAllyWith(target)).andReturn(true);
+		player.sendPacket(INCORRECT_TARGET);
+		expectLastCall().once();
+		replay(skill, target, activeChar, player);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_player_in_command_channel_with_target_should_return_empty_target_list() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(false);
+		expect(player.isInPartyWith(target)).andReturn(false);
+		expect(player.isInsideZone(PVP)).andReturn(false);
+		expect(player.isInClanWith(target)).andReturn(false);
+		expect(player.isInAllyWith(target)).andReturn(false);
+		expect(player.isInCommandChannelWith(target)).andReturn(true);
+		player.sendPacket(INCORRECT_TARGET);
+		expectLastCall().once();
+		replay(skill, target, activeChar, player);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_player_cannot_pvp_target_should_return_empty_target_list() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(false);
+		expect(player.isInPartyWith(target)).andReturn(false);
+		expect(player.isInsideZone(PVP)).andReturn(false);
+		expect(player.isInClanWith(target)).andReturn(false);
+		expect(player.isInAllyWith(target)).andReturn(false);
+		expect(player.isInCommandChannelWith(target)).andReturn(false);
+		expect(player.checkIfPvP(target)).andReturn(false);
+		player.sendPacket(INCORRECT_TARGET);
+		expectLastCall().once();
+		replay(skill, target, activeChar, player);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(EMPTY_TARGET_LIST, actual);
+	}
+	
+	@Test
+	public void test_player_can_pvp_target_should_return_target() {
+		expect(skill.getAffectScope()).andReturn(SINGLE);
+		expect(target.isDead()).andReturn(false);
+		expect(target.isAttackable()).andReturn(false);
+		expect(activeChar.getActingPlayer()).andReturn(player);
+		expect(player.isInOlympiadMode()).andReturn(false);
+		expect(player.isInDuelWith(target)).andReturn(false);
+		expect(player.isInPartyWith(target)).andReturn(false);
+		expect(player.isInsideZone(PVP)).andReturn(false);
+		expect(player.isInClanWith(target)).andReturn(false);
+		expect(player.isInAllyWith(target)).andReturn(false);
+		expect(player.isInCommandChannelWith(target)).andReturn(false);
+		expect(player.checkIfPvP(target)).andReturn(true);
+		replay(skill, target, activeChar, player);
+		
+		final var actual = enemyOnly.getTargetList(skill, activeChar, false, target);
+		assertEquals(target, actual[0]);
+	}
+}
diff --git a/src/test/java/com/l2jserver/datapack/test/AbstractTest.java b/src/test/java/com/l2jserver/datapack/test/AbstractTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7a0835756782cc9f333b0446619b0fd770ba502
--- /dev/null
+++ b/src/test/java/com/l2jserver/datapack/test/AbstractTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2004-2020 L2J DataPack
+ * 
+ * This file is part of L2J DataPack.
+ * 
+ * L2J DataPack 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 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * L2J DataPack 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.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.datapack.test;
+
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.testng.PowerMockTestCase;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * AbstractTest.
+ * @author Zoey76
+ * @version 2.6.2.0
+ */
+
+@PrepareForTest(L2PcInstance.class)
+@PowerMockIgnore({
+	"javax.xml.*",
+	"org.w3c.*",
+	"org.apache.*",
+	"org.slf4j.*",
+	"com.sun.*"
+})
+public class AbstractTest extends PowerMockTestCase {
+	
+}