diff --git a/build.gradle b/build.gradle index dfe1f3284b7..5ab26a2e631 100644 --- a/build.gradle +++ b/build.gradle @@ -40,7 +40,7 @@ dependencies { implementation fileTree(dir: 'lib', include: '*.jar') testShadow group: 'junit', name: 'junit', version: '4.13.2' - testShadow group: 'org.easymock', name: 'easymock', version: '5.2.0' + testShadow group: 'org.easymock', name: 'easymock', version: '5.0.1' } task checkAliases { diff --git a/src/main/java/ch/njol/skript/Skript.java b/src/main/java/ch/njol/skript/Skript.java index 7b1ac6c0eab..291ebff5ae4 100644 --- a/src/main/java/ch/njol/skript/Skript.java +++ b/src/main/java/ch/njol/skript/Skript.java @@ -691,6 +691,9 @@ protected void afterErrors() { long milliseconds = 0, tests = 0, fails = 0, ignored = 0, size = 0; try { List> classes = Lists.newArrayList(Utils.getClasses(Skript.getInstance(), "org.skriptlang.skript.test", "tests")); + // Don't attempt to run inner/anonymous classes as tests + classes.removeIf(Class::isAnonymousClass); + classes.removeIf(Class::isLocalClass); // Test that requires package access. This is only present when compiling with src/test. classes.add(Class.forName("ch.njol.skript.variables.FlatFileStorageTest")); size = classes.size(); diff --git a/src/main/java/ch/njol/skript/effects/EffApplyBoneMeal.java b/src/main/java/ch/njol/skript/effects/EffApplyBoneMeal.java index 484654a14f6..080f1cd3982 100644 --- a/src/main/java/ch/njol/skript/effects/EffApplyBoneMeal.java +++ b/src/main/java/ch/njol/skript/effects/EffApplyBoneMeal.java @@ -71,7 +71,7 @@ protected void execute(Event event) { @Override public String toString(@Nullable Event event, boolean debug) { - return "apply " + amount != null ? amount.toString(event, debug) + " " : "" + "bone meal to " + blocks.toString(event, debug); + return "apply " + (amount != null ? amount.toString(event, debug) + " " : "" + "bone meal to " + blocks.toString(event, debug)); } } diff --git a/src/main/java/ch/njol/skript/effects/EffSwingHand.java b/src/main/java/ch/njol/skript/effects/EffSwingHand.java index a129254de9f..826cce82978 100644 --- a/src/main/java/ch/njol/skript/effects/EffSwingHand.java +++ b/src/main/java/ch/njol/skript/effects/EffSwingHand.java @@ -46,7 +46,7 @@ public class EffSwingHand extends Effect { "make %livingentities% swing [their] off[ ]hand"); } - private static final boolean SWINGING_IS_SUPPORTED = Skript.methodExists(LivingEntity.class, "swingMainHand"); + public static final boolean SWINGING_IS_SUPPORTED = Skript.methodExists(LivingEntity.class, "swingMainHand"); @SuppressWarnings("null") private Expression entities; diff --git a/src/main/java/ch/njol/skript/test/runner/SkriptJUnitTest.java b/src/main/java/ch/njol/skript/test/runner/SkriptJUnitTest.java index 38ec51d116c..65a52f0ac1a 100644 --- a/src/main/java/ch/njol/skript/test/runner/SkriptJUnitTest.java +++ b/src/main/java/ch/njol/skript/test/runner/SkriptJUnitTest.java @@ -38,7 +38,7 @@ public abstract class SkriptJUnitTest { static { - World world = Bukkit.getWorlds().get(0); + World world = getTestWorld(); world.setGameRule(GameRule.MAX_ENTITY_CRAMMING, 1000); world.setGameRule(GameRule.DO_WEATHER_CYCLE, false); // Natural entity spawning diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffActionBarTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffActionBarTest.java new file mode 100644 index 00000000000..125f22e86e8 --- /dev/null +++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffActionBarTest.java @@ -0,0 +1,97 @@ +/** + * This file is part of Skript. + * + * Skript 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. + * + * Skript 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 Skript. If not, see . + * + * Copyright Peter Güttinger, SkriptLang team and contributors + */ +package org.skriptlang.skript.test.tests.syntaxes.effects; + + +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.util.ContextlessEvent; +import ch.njol.skript.test.runner.SkriptJUnitTest; +import ch.njol.skript.variables.Variables; +import net.md_5.bungee.api.ChatMessageType; +import net.md_5.bungee.api.chat.BaseComponent; +import net.md_5.bungee.api.chat.TextComponent; +import org.bukkit.entity.Player; +import org.easymock.EasyMock; +import org.easymock.IArgumentMatcher; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + + +@SuppressWarnings("deprecation") +public class EffActionBarTest extends SkriptJUnitTest { + + private Player testPlayer; + private Player.Spigot testSpigotPlayer; + private Effect actionBarEffect; + + @Before + public void setup() { + testPlayer = EasyMock.niceMock(Player.class); + testSpigotPlayer = EasyMock.niceMock(Player.Spigot.class); + actionBarEffect = Effect.parse("send actionbar {_content} to {_player}", null); + } + + @Test + public void test() { + if (actionBarEffect == null) + Assert.fail("Effect is null"); + + String expectedActionBarContent = "hello world"; + + EasyMock.expect(testPlayer.spigot()).andAnswer(() -> testSpigotPlayer); + + testSpigotPlayer.sendMessage( + EasyMock.eq(ChatMessageType.ACTION_BAR), + (BaseComponent[]) componentMatcher(expectedActionBarContent) + ); + + EasyMock.expectLastCall(); + + EasyMock.replay(testPlayer, testSpigotPlayer); + + ContextlessEvent event = ContextlessEvent.get(); + Variables.setVariable("content", expectedActionBarContent, event, true); + Variables.setVariable("player", testPlayer, event, true); + TriggerItem.walk(actionBarEffect, event); + + EasyMock.verify(testPlayer, testSpigotPlayer); + } + + private T componentMatcher(String expectedContent) { + EasyMock.reportMatcher(new IArgumentMatcher() { + @Override + public boolean matches(Object argument) { + if (argument instanceof TextComponent) { + return ((TextComponent) argument).getText().equals(expectedContent); + } + return false; + } + + @Override + public void appendTo(StringBuffer buffer) { + buffer.append("[component matcher]"); + } + }); + + return null; + } + +} diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffApplyBoneMealTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffApplyBoneMealTest.java new file mode 100644 index 00000000000..5b7a5b8aa1f --- /dev/null +++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffApplyBoneMealTest.java @@ -0,0 +1,96 @@ +/** + * This file is part of Skript. + * + * Skript 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. + * + * Skript 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 Skript. If not, see . + * + * Copyright Peter Güttinger, SkriptLang team and contributors + */ +package org.skriptlang.skript.test.tests.syntaxes.effects; + + +import ch.njol.skript.Skript; +import ch.njol.skript.effects.EffApplyBoneMeal; +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.SyntaxElementInfo; +import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.util.ContextlessEvent; +import ch.njol.skript.test.runner.SkriptJUnitTest; +import ch.njol.skript.variables.Variables; +import org.bukkit.block.Block; +import org.easymock.EasyMock; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Proxy; + +public class EffApplyBoneMealTest { + + private Block stubTestBlock; + private Effect applyBonemealEffect; + private Effect applyMultipleBonemealEffect; + + @Before + public void setup() { + stubTestBlock = EasyMock.niceMock(Block.class); + applyBonemealEffect = Effect.parse("apply bonemeal to {_block}", null); + applyMultipleBonemealEffect = Effect.parse("apply {_times} bonemeal to {_block}", null); + } + + @Test + public void test() { + boolean bonemealEffectRegistered = Skript.getEffects().stream() + .map(SyntaxElementInfo::getElementClass) + .anyMatch(EffApplyBoneMeal.class::equals); + if (!bonemealEffectRegistered) + return; + if (applyBonemealEffect == null) + Assert.fail("Effect is null"); + if (applyMultipleBonemealEffect == null) + Assert.fail("Multiple effect is null"); + + int countOfBonemealToApply = 5; + ContextlessEvent event = ContextlessEvent.get(); + Variables.setVariable("block", getMockBlock(), event, true); + Variables.setVariable("times", countOfBonemealToApply, event, true); + + EasyMock.expect(stubTestBlock.applyBoneMeal(EasyMock.notNull())).andReturn(true).times(1); + EasyMock.replay(stubTestBlock); + TriggerItem.walk(applyBonemealEffect, event); + EasyMock.verify(stubTestBlock); + + EasyMock.resetToNice(stubTestBlock); + EasyMock.expect(stubTestBlock.applyBoneMeal(EasyMock.notNull())).andReturn(true).times(2); + EasyMock.replay(stubTestBlock); + TriggerItem.walk(applyMultipleBonemealEffect, event); + EasyMock.verify(stubTestBlock); + } + + private Block getMockBlock() { + Block realBlock = SkriptJUnitTest.getBlock(); + + // we need to intercept applyBoneMeal calls so that easymock can detect them + // but we need to pass the other calls to a real block so that a real blockdata, + // material, location, etc are available + InvocationHandler handler = (proxy, method, args) -> { + if (method.getName().equals("applyBoneMeal")) { + return method.invoke(stubTestBlock, args); + } + return method.invoke(realBlock, args); + }; + + return (Block) Proxy.newProxyInstance(getClass().getClassLoader(), new Class[] { Block.class }, handler); + } +} diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffFeedTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffFeedTest.java new file mode 100644 index 00000000000..1235eea38ab --- /dev/null +++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffFeedTest.java @@ -0,0 +1,84 @@ +/** + * This file is part of Skript. + * + * Skript 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. + * + * Skript 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 Skript. If not, see . + * + * Copyright Peter Güttinger, SkriptLang team and contributors + */ +package org.skriptlang.skript.test.tests.syntaxes.effects; + +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.util.ContextlessEvent; +import ch.njol.skript.test.runner.SkriptJUnitTest; +import ch.njol.skript.variables.Variables; +import org.bukkit.entity.Player; +import org.easymock.EasyMock; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Proxy; + +public class EffFeedTest extends SkriptJUnitTest { + + private Player easyMockPlayer; + private Effect feedFullyEffect; + private Effect feedPartiallyEffect; + + @Before + public void setup() { + easyMockPlayer = EasyMock.niceMock(Player.class); + feedFullyEffect = Effect.parse("feed {_player}", null); + feedPartiallyEffect = Effect.parse("feed {_player} by {_amount} beef", null); + } + + @Test + public void test() { + if (feedFullyEffect == null) + Assert.fail("Fully effect is null"); + if (feedPartiallyEffect == null) + Assert.fail("Partially effect is null"); + + int amountToFeed = 1; + int maxFoodLevel = 20; + ContextlessEvent event = ContextlessEvent.get(); + Variables.setVariable("player", getMockPlayer(), event, true); + Variables.setVariable("amount", amountToFeed, event, true); + + easyMockPlayer.setFoodLevel(EasyMock.eq(maxFoodLevel)); + EasyMock.expectLastCall(); + EasyMock.replay(easyMockPlayer); + TriggerItem.walk(feedFullyEffect, event); + EasyMock.verify(easyMockPlayer); + + EasyMock.resetToNice(easyMockPlayer); + easyMockPlayer.setFoodLevel(EasyMock.eq(amountToFeed)); + EasyMock.expectLastCall(); + EasyMock.replay(easyMockPlayer); + TriggerItem.walk(feedPartiallyEffect, event); + EasyMock.verify(easyMockPlayer); + } + + private Player getMockPlayer() { + InvocationHandler handler = (proxy, method, args) -> { + if (method.getName().equals("getFoodLevel")) + return 0; + return method.invoke(easyMockPlayer, args); + }; + return (Player) Proxy.newProxyInstance(getClass().getClassLoader(), new Class[] { Player.class }, handler); + } + +} diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffMakeFlyTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffMakeFlyTest.java new file mode 100644 index 00000000000..28497059e53 --- /dev/null +++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffMakeFlyTest.java @@ -0,0 +1,73 @@ +/** + * This file is part of Skript. + * + * Skript 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. + * + * Skript 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 Skript. If not, see . + * + * Copyright Peter Güttinger, SkriptLang team and contributors + */ +package org.skriptlang.skript.test.tests.syntaxes.effects; + +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.util.ContextlessEvent; +import ch.njol.skript.test.runner.SkriptJUnitTest; +import ch.njol.skript.variables.Variables; +import org.bukkit.entity.Player; +import org.easymock.EasyMock; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +public class EffMakeFlyTest extends SkriptJUnitTest { + + private Player testPlayer; + private Effect startFlyingEffect; + private Effect stopFlyingEffect; + + @Before + public void setup() { + testPlayer = EasyMock.niceMock(Player.class); + startFlyingEffect = Effect.parse("make {_player} start flying", null); + stopFlyingEffect = Effect.parse("make {_player} stop flying", null); + } + + @Test + public void test() { + if (startFlyingEffect == null) + Assert.fail("Start flying effect is null"); + if (stopFlyingEffect == null) + Assert.fail("Stop flying effect is null"); + + ContextlessEvent event = ContextlessEvent.get(); + Variables.setVariable("player", testPlayer, event, true); + + testPlayer.setAllowFlight(true); + EasyMock.expectLastCall(); + testPlayer.setFlying(true); + EasyMock.expectLastCall(); + EasyMock.replay(testPlayer); + TriggerItem.walk(startFlyingEffect, event); + EasyMock.verify(testPlayer); + + EasyMock.resetToNice(testPlayer); + testPlayer.setAllowFlight(false); + EasyMock.expectLastCall(); + testPlayer.setFlying(false); + EasyMock.expectLastCall(); + EasyMock.replay(testPlayer); + TriggerItem.walk(stopFlyingEffect, event); + EasyMock.verify(testPlayer); + } + +} diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffOpTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffOpTest.java new file mode 100644 index 00000000000..69b237292d9 --- /dev/null +++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffOpTest.java @@ -0,0 +1,69 @@ +/** + * This file is part of Skript. + * + * Skript 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. + * + * Skript 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 Skript. If not, see . + * + * Copyright Peter Güttinger, SkriptLang team and contributors + */ +package org.skriptlang.skript.test.tests.syntaxes.effects; + +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.util.ContextlessEvent; +import ch.njol.skript.test.runner.SkriptJUnitTest; +import ch.njol.skript.variables.Variables; +import org.bukkit.entity.Player; +import org.easymock.EasyMock; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +public class EffOpTest extends SkriptJUnitTest { + + private Player testPlayer; + private Effect opPlayerEffect; + private Effect deopPlayerEffect; + + @Before + public void setup() { + testPlayer = EasyMock.niceMock(Player.class); + opPlayerEffect = Effect.parse("op {_player}", null); + deopPlayerEffect = Effect.parse("deop {_player}", null); + } + + @Test + public void test() { + if (opPlayerEffect == null) + Assert.fail("Op player effect is null"); + if (deopPlayerEffect == null) + Assert.fail("Deop player effect is null"); + + ContextlessEvent event = ContextlessEvent.get(); + Variables.setVariable("player", testPlayer, event, true); + + testPlayer.setOp(true); + EasyMock.expectLastCall(); + EasyMock.replay(testPlayer); + TriggerItem.walk(opPlayerEffect, event); + EasyMock.verify(testPlayer); + + EasyMock.resetToNice(testPlayer); + testPlayer.setOp(false); + EasyMock.expectLastCall(); + EasyMock.replay(testPlayer); + TriggerItem.walk(deopPlayerEffect, event); + EasyMock.verify(testPlayer); + } + +} diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffSwingHandTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffSwingHandTest.java new file mode 100644 index 00000000000..1b5da4d1a46 --- /dev/null +++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/effects/EffSwingHandTest.java @@ -0,0 +1,75 @@ +/** + * This file is part of Skript. + * + * Skript 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. + * + * Skript 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 Skript. If not, see . + * + * Copyright Peter Güttinger, SkriptLang team and contributors + */ +package org.skriptlang.skript.test.tests.syntaxes.effects; + +import ch.njol.skript.Skript; +import ch.njol.skript.effects.EffSwingHand; +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.SyntaxElementInfo; +import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.util.ContextlessEvent; +import ch.njol.skript.test.runner.SkriptJUnitTest; +import ch.njol.skript.variables.Variables; +import org.bukkit.entity.LivingEntity; +import org.easymock.EasyMock; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + + +public class EffSwingHandTest extends SkriptJUnitTest { + + private LivingEntity testEntity; + private Effect swingMainHandEffect; + private Effect swingOffhandEffect; + + @Before + public void setup() { + testEntity = EasyMock.niceMock(LivingEntity.class); + swingMainHandEffect = Effect.parse("make {_entity} swing their main hand", null); + swingOffhandEffect = Effect.parse("make {_entity} swing their offhand", null); + } + + @Test + public void test() { + if (!EffSwingHand.SWINGING_IS_SUPPORTED) + return; + if (swingMainHandEffect == null) + Assert.fail("Main hand is null"); + if (swingOffhandEffect == null) + Assert.fail("Offhand effect is null"); + + ContextlessEvent event = ContextlessEvent.get(); + Variables.setVariable("entity", testEntity, event, true); + + testEntity.swingMainHand(); + EasyMock.expectLastCall(); + EasyMock.replay(testEntity); + TriggerItem.walk(swingMainHandEffect, event); + EasyMock.verify(testEntity); + + EasyMock.resetToNice(testEntity); + testEntity.swingOffHand(); + EasyMock.expectLastCall(); + EasyMock.replay(testEntity); + TriggerItem.walk(swingOffhandEffect, event); + EasyMock.verify(testEntity); + } + +} diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/EvtGrowTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/events/EvtGrowTest.java similarity index 97% rename from src/test/java/org/skriptlang/skript/test/tests/syntaxes/EvtGrowTest.java rename to src/test/java/org/skriptlang/skript/test/tests/syntaxes/events/EvtGrowTest.java index 96baf1b5c32..44cb566c33f 100644 --- a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/EvtGrowTest.java +++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/events/EvtGrowTest.java @@ -16,7 +16,7 @@ * * Copyright Peter Güttinger, SkriptLang team and contributors */ -package org.skriptlang.skript.test.tests.syntaxes; +package org.skriptlang.skript.test.tests.syntaxes.events; import ch.njol.skript.Skript; import ch.njol.skript.test.runner.SkriptJUnitTest; diff --git a/src/test/skript/junit/EvtGrow.sk b/src/test/skript/junit/EvtGrow.sk index e932519af9b..080dfd819b9 100644 --- a/src/test/skript/junit/EvtGrow.sk +++ b/src/test/skript/junit/EvtGrow.sk @@ -2,69 +2,69 @@ on script load: # prior to 1.18, applyBoneMeal either did not exist or did not fire events # so we need to complete the objectives manually to avoid the tests failing if running below minecraft "1.18": - complete objective "grow of wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow from wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow to wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow of wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow from wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow to wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow of birch tree" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow of birch sapling" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow from birch sapling" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow to birch tree" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + complete objective "grow of wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow from wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow to wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow of wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow from wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow to wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow of birch tree" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow of birch sapling" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow from birch sapling" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow to birch tree" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" # itemtype - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow of wheat" - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow from wheat" - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow to wheat" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow of wheat" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow from wheat" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow to wheat" # blockdata - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow of wheat (blockdata)" - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow from wheat (blockdata)" - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow to wheat (blockdata)" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow of wheat (blockdata)" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow from wheat (blockdata)" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow to wheat (blockdata)" # structures - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow of birch tree" - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow of birch sapling" - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow from birch sapling" - ensure junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" completes "grow to birch tree" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow of birch tree" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow of birch sapling" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow from birch sapling" + ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" completes "grow to birch tree" on grow of wheat: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow of wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow of wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow of wheat[age=0]: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow of wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow of wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow from wheat: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow from wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow from wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow from wheat[age=0]: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow from wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow from wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow to wheat: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow to wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow to wheat" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow to wheat[age=7]: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow to wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow to wheat (blockdata)" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow of birch tree: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow of birch tree" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow of birch tree" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow of birch sapling: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow of birch sapling" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow of birch sapling" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow from birch sapling: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow from birch sapling" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow from birch sapling" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" on grow to birch tree: - junit test is "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" - complete objective "grow to birch tree" for junit test "org.skriptlang.skript.test.tests.syntaxes.EvtGrowTest" + junit test is "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" + complete objective "grow to birch tree" for junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtGrowTest" diff --git a/src/test/skript/tests/syntaxes/effects/EffDoIf.sk b/src/test/skript/tests/syntaxes/effects/EffDoIf.sk new file mode 100644 index 00000000000..da17471d8d5 --- /dev/null +++ b/src/test/skript/tests/syntaxes/effects/EffDoIf.sk @@ -0,0 +1,6 @@ +test "do if": + set {_false} to false if 1 is 1 + assert {_false} is false with "Do if didn't run when it should have" + + set {_unset} to true if 1 is 2 + assert {_unset} is not set with "Do if ran when it shouldn't have" diff --git a/src/test/skript/tests/syntaxes/effects/EffPvP.sk b/src/test/skript/tests/syntaxes/effects/EffPvP.sk new file mode 100644 index 00000000000..bb41b776670 --- /dev/null +++ b/src/test/skript/tests/syntaxes/effects/EffPvP.sk @@ -0,0 +1,6 @@ +test "pvp effect": + set {_world} to first element out of all worlds + disable pvp in {_world} + assert pvp is disabled in {_world} with "PvP was not disabled" + enable pvp in {_world} + assert pvp is enabled in {_world} with "PvP was not enabled"