Upstream
/
WorldGuard
mirror of https://github.com/EngineHub/WorldGuard.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Updated build environment, switched to Jupiter Unit Tests

This commit is contained in:
JOO200 2021-06-12 13:04:36 +02:00 committed by wizjany
parent f17f1fc8c8
commit 04541ed5a6
19 changed files with 408 additions and 412 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
buildSrc/build.gradle.kts
View File

@ -10,10 +10,8 @@ repositories {
dependencies {
implementation(gradleApi())
implementation("gradle.plugin.net.minecrell:licenser:0.4.1")
implementation("gradle.plugin.org.cadixdev.gradle:licenser:0.6.0")
implementation("org.ajoberstar.grgit:grgit-gradle:4.1.0")
implementation("com.github.jengelman.gradle.plugins:shadow:6.1.0")
implementation("net.ltgt.apt-eclipse:net.ltgt.apt-eclipse.gradle.plugin:0.21")
implementation("net.ltgt.apt-idea:net.ltgt.apt-idea.gradle.plugin:0.21")
implementation("org.jfrog.buildinfo:build-info-extractor-gradle:4.21.0")
}

2
buildSrc/src/main/kotlin/ArtifactoryConfig.kt
View File

@ -35,6 +35,6 @@ fun Project.applyRootArtifactoryConfig() {
fun Project.applyCommonArtifactoryConfig() {
tasks.named<ArtifactoryTask>("artifactoryPublish") {
publishConfigs("archives")
publications("maven")
}
}

10
buildSrc/src/main/kotlin/CommonConfig.kt
View File

@ -1,4 +1,7 @@
import org.cadixdev.gradle.licenser.LicenseExtension
import org.gradle.api.Project
import org.gradle.kotlin.dsl.apply
import org.gradle.kotlin.dsl.configure
import org.gradle.kotlin.dsl.repositories
fun Project.applyCommonConfiguration() {
@ -15,4 +18,11 @@ fun Project.applyCommonConfiguration() {
cacheChangingModulesFor(5, "MINUTES")
}
}
apply(plugin = "org.cadixdev.licenser")
configure<LicenseExtension> {
header(rootProject.file("HEADER.txt"))
include("**/*.java")
include("**/*.kt")
}
}

15
buildSrc/src/main/kotlin/LibsConfig.kt
View File

@ -1,26 +1,21 @@
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import org.gradle.api.Project
import org.gradle.api.artifacts.ModuleDependency
import org.gradle.api.internal.HasConvention
import org.gradle.api.plugins.MavenRepositoryHandlerConvention
import org.gradle.api.tasks.Upload
import org.gradle.api.tasks.bundling.Jar
import org.gradle.kotlin.dsl.apply
import org.gradle.kotlin.dsl.get
import org.gradle.kotlin.dsl.getPlugin
import org.gradle.kotlin.dsl.invoke
import org.gradle.kotlin.dsl.register
fun Project.applyLibrariesConfiguration() {
applyCommonConfiguration()
apply(plugin = "java-base")
apply(plugin = "maven")
apply(plugin = "maven-publish")
apply(plugin = "com.github.johnrengelman.shadow")
apply(plugin = "com.jfrog.artifactory")
configurations {
create("shade")
getByName("archives").extendsFrom(getByName("default"))
}
group = "${rootProject.group}.worldguard-libs"
@ -84,13 +79,5 @@ fun Project.applyLibrariesConfiguration() {
}
}
tasks.register<Upload>("install") {
configuration = configurations["archives"]
(repositories as HasConvention).convention.getPlugin<MavenRepositoryHandlerConvention>().mavenInstaller {
pom.version = project.version.toString()
pom.artifactId = project.name
}
}
applyCommonArtifactoryConfig()
}

39
buildSrc/src/main/kotlin/PlatformConfig.kt
View File

@ -1,9 +1,10 @@
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import net.minecrell.gradle.licenser.LicenseExtension
import org.gradle.api.JavaVersion
import org.gradle.api.Project
import org.gradle.api.plugins.JavaPluginConvention
import org.gradle.api.plugins.quality.CheckstyleExtension
import org.gradle.api.publish.PublishingExtension
import org.gradle.api.publish.maven.MavenPublication
import org.gradle.api.tasks.bundling.Jar
import org.gradle.api.tasks.javadoc.Javadoc
import org.gradle.api.tasks.testing.Test
@ -22,11 +23,10 @@ fun Project.applyPlatformAndCoreConfiguration() {
apply(plugin = "java")
apply(plugin = "eclipse")
apply(plugin = "idea")
apply(plugin = "maven")
apply(plugin = "maven-publish")
apply(plugin = "checkstyle")
apply(plugin = "com.github.johnrengelman.shadow")
apply(plugin = "com.jfrog.artifactory")
apply(plugin = "net.minecrell.licenser")
ext["internalVersion"] = "$version+${rootProject.ext["gitCommitHash"]}"
@ -37,18 +37,19 @@ fun Project.applyPlatformAndCoreConfiguration() {
configure<CheckstyleExtension> {
configFile = rootProject.file("config/checkstyle/checkstyle.xml")
toolVersion = "7.6.1"
toolVersion = "8.34"
}
tasks.withType<Test>().configureEach {
useJUnit()
useJUnitPlatform()
}
dependencies {
"testCompile"("junit:junit:${Versions.JUNIT}")
// TODO switch to jupiter - doesn't support abstract test classes so tests need rewriting
//"testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.JUNIT}")
//"testRuntime"("org.junit.jupiter:junit-jupiter-engine:${Versions.JUNIT}")
"testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.JUNIT}")
"testImplementation"("org.junit.jupiter:junit-jupiter-params:${Versions.JUNIT}")
"testImplementation"("org.mockito:mockito-core:${Versions.MOCKITO}")
"testImplementation"("org.mockito:mockito-junit-jupiter:${Versions.MOCKITO}")
"testRuntimeOnly"("org.junit.jupiter:junit-jupiter-engine:${Versions.JUNIT}")
}
// Java 8 turns on doclint which we fail
@ -90,13 +91,23 @@ fun Project.applyPlatformAndCoreConfiguration() {
dependsOn("checkstyleMain", "checkstyleTest")
}
applyCommonArtifactoryConfig()
configure<LicenseExtension> {
header = rootProject.file("HEADER.txt")
include("**/*.java")
configure<PublishingExtension> {
publications {
register<MavenPublication>("maven") {
from(components["java"])
versionMapping {
usage("java-api") {
fromResolutionOf("runtimeClasspath")
}
usage("java-runtime") {
fromResolutionResult()
}
}
}
}
}
applyCommonArtifactoryConfig()
}
fun Project.applyShadowConfiguration() {

3
buildSrc/src/main/kotlin/Versions.kt
View File

@ -2,7 +2,8 @@ object Versions {
// const val PISTON = "0.4.3"
// const val AUTO_VALUE = "1.6.5"
const val WORLDEDIT = "7.2.6-SNAPSHOT"
const val JUNIT = "4.11"
const val JUNIT = "5.7.0"
const val SQUIRRELID = "0.2.0"
const val GUAVA = "21.0"
const val MOCKITO = "3.7.7"
}

17
worldguard-bukkit/build.gradle.kts
View File

@ -3,8 +3,6 @@ import org.gradle.api.internal.HasConvention
plugins {
id("java-library")
id("net.ltgt.apt-eclipse")
id("net.ltgt.apt-idea")
}
applyPlatformAndCoreConfiguration()
@ -46,21 +44,6 @@ dependencies {
"shade"("co.aikar:minecraft-timings:1.0.4")
}
tasks.named<Upload>("install") {
(repositories as HasConvention).convention.getPlugin<MavenRepositoryHandlerConvention>().mavenInstaller {
pom.whenConfigured {
dependencies.firstOrNull { dep ->
dep!!.withGroovyBuilder {
getProperty("groupId") == "com.destroystokyo.paper" && getProperty("artifactId") == "paper-api"
}
}?.withGroovyBuilder {
setProperty("groupId", "org.spigotmc")
setProperty("artifactId", "spigot-api")
}
}
}
}
tasks.named<Copy>("processResources") {
val internalVersion = project.ext["internalVersion"]
inputs.property("internalVersion", internalVersion)

2
worldguard-core/build.gradle.kts
View File

@ -1,7 +1,5 @@
plugins {
id("java-library")
id("net.ltgt.apt-eclipse")
id("net.ltgt.apt-idea")
}
applyPlatformAndCoreConfiguration()

4
worldguard-core/src/test/java/com/sk89q/worldguard/TestPlayer.java
View File

@ -30,7 +30,6 @@ import com.sk89q.worldedit.util.Location;
import com.sk89q.worldedit.util.formatting.text.Component;
import com.sk89q.worldedit.world.World;
import com.sk89q.worldedit.world.weather.WeatherType;
import org.junit.Ignore;
import java.util.HashSet;
import java.util.Locale;
@ -39,7 +38,7 @@ import java.util.UUID;
import javax.annotation.Nullable;
@Ignore
public class TestPlayer extends AbstractPlayerActor implements LocalPlayer {
private final UUID uuid = UUID.randomUUID();
@ -250,6 +249,7 @@ public class TestPlayer extends AbstractPlayerActor implements LocalPlayer {
}
@Override
@Deprecated
public void setPosition(Vector3 pos, float pitch, float yaw) {
}

80
worldguard-core/src/test/java/com/sk89q/worldguard/domains/DefaultDomainTest.java
View File

@ -20,13 +20,14 @@
package com.sk89q.worldguard.domains;
import com.sk89q.worldguard.TestPlayer;
import junit.framework.TestCase;
import org.junit.jupiter.api.Test;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class DefaultDomainTest extends TestCase {
public class DefaultDomainTest {
@Test
public void testContains() throws Exception {
TestPlayer player1 = new TestPlayer("test1");
TestPlayer player2 = new TestPlayer("test2");
@ -40,81 +41,76 @@ public class DefaultDomainTest extends TestCase {
domain = new DefaultDomain();
domain.addGroup("group1");
assertThat(domain.contains(player1), is(false));
assertThat(domain.contains(player2), is(true));
assertThat(domain.contains(player3), is(true));
assertFalse(domain.contains(player1));
assertTrue(domain.contains(player2));
assertTrue(domain.contains(player3));
domain = new DefaultDomain();
domain.addGroup("group1");
domain.addGroup("group2");
assertThat(domain.contains(player1), is(false));
assertThat(domain.contains(player2), is(true));
assertThat(domain.contains(player3), is(true));
assertFalse(domain.contains(player1));
assertTrue(domain.contains(player2));
assertTrue(domain.contains(player3));
domain = new DefaultDomain();
domain.addGroup("group1");
domain.addGroup("group3");
assertThat(domain.contains(player1), is(false));
assertThat(domain.contains(player2), is(true));
assertThat(domain.contains(player3), is(true));
assertFalse(domain.contains(player1));
assertTrue(domain.contains(player2));
assertTrue(domain.contains(player3));
domain = new DefaultDomain();
domain.addGroup("group3");
assertThat(domain.contains(player1), is(false));
assertThat(domain.contains(player2), is(false));
assertThat(domain.contains(player3), is(true));
assertFalse(domain.contains(player1));
assertFalse(domain.contains(player2));
assertTrue(domain.contains(player3));
domain = new DefaultDomain();
domain.addPlayer(player1.getName());
assertThat(domain.contains(player1), is(true));
assertThat(domain.contains(player2), is(false));
assertThat(domain.contains(player3), is(false));
assertTrue(domain.contains(player1));
assertFalse(domain.contains(player2));
assertFalse(domain.contains(player3));
domain = new DefaultDomain();
domain.addGroup("group3");
domain.addPlayer(player1.getName());
assertThat(domain.contains(player1), is(true));
assertThat(domain.contains(player2), is(false));
assertThat(domain.contains(player3), is(true));
assertTrue(domain.contains(player1));
assertFalse(domain.contains(player2));
assertTrue(domain.contains(player3));
domain = new DefaultDomain();
domain.addGroup("group3");
domain.addPlayer(player1.getUniqueId());
assertThat(domain.contains(player1), is(true));
assertThat(domain.contains(player2), is(false));
assertThat(domain.contains(player3), is(true));
assertTrue(domain.contains(player1));
assertFalse(domain.contains(player2));
assertTrue(domain.contains(player3));
domain = new DefaultDomain();
domain.addGroup("group3");
domain.addPlayer(player1.getName());
domain.addPlayer(player1.getUniqueId());
assertThat(domain.contains(player1), is(true));
assertThat(domain.contains(player2), is(false));
assertThat(domain.contains(player3), is(true));
assertTrue(domain.contains(player1));
assertFalse(domain.contains(player2));
assertTrue(domain.contains(player3));
domain = new DefaultDomain();
domain.addGroup("group3");
domain.addPlayer(player1);
assertThat(domain.contains(player1), is(true));
assertThat(domain.contains(player2), is(false));
assertThat(domain.contains(player3), is(true));
assertTrue(domain.contains(player1));
assertFalse(domain.contains(player2));
assertTrue(domain.contains(player3));
domain = new DefaultDomain();
domain.addPlayer(player1);
assertThat(domain.contains(player1), is(true));
assertThat(domain.contains(player2), is(false));
assertThat(domain.contains(player3), is(false));
assertTrue(domain.contains(player1));
assertFalse(domain.contains(player2));
assertFalse(domain.contains(player3));
domain = new DefaultDomain();
domain.addPlayer(player2);
domain.addPlayer(player3);
assertThat(domain.contains(player1), is(false));
assertThat(domain.contains(player2), is(true));
assertThat(domain.contains(player3), is(true));
assertFalse(domain.contains(player1));
assertTrue(domain.contains(player2));
assertTrue(domain.contains(player3));
}
public void testSize() throws Exception {
}
}

96
worldguard-core/src/test/java/com/sk89q/worldguard/protection/ApplicableRegionSetTest.java
View File

@ -25,13 +25,15 @@ import com.sk89q.worldguard.protection.flags.StateFlag;
import com.sk89q.worldguard.protection.flags.StringFlag;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import com.sk89q.worldguard.util.command.CommandFilter;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.HashSet;
import java.util.Set;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class ApplicableRegionSetTest {
@ -42,7 +44,7 @@ public class ApplicableRegionSetTest {
LocalPlayer player = mock.createPlayer();
ApplicableRegionSet set = mock.getApplicableSet();
assertThat(set.testState(player, Flags.BUILD), is(true));
assertTrue(set.testState(player, Flags.BUILD));
}
@Test
@ -54,7 +56,7 @@ public class ApplicableRegionSetTest {
ProtectedRegion global = mock.global();
ApplicableRegionSet set = mock.getApplicableSet();
assertThat(set.testState(player, Flags.BUILD), is(true));
assertTrue(set.testState(player, Flags.BUILD));
}
@Test
@ -68,8 +70,8 @@ public class ApplicableRegionSetTest {
region.getMembers().addPlayer(member);
ApplicableRegionSet set = mock.getApplicableSet();
assertThat(set.testState(member, Flags.BUILD), is(true));
assertThat(set.testState(nonMember, Flags.BUILD), is(false));
assertTrue(set.testState(member, Flags.BUILD));
assertFalse(set.testState(nonMember, Flags.BUILD));
}
@Test
@ -80,15 +82,15 @@ public class ApplicableRegionSetTest {
ApplicableRegionSet set = mock.getApplicableSet();
assertThat(set.testState(player, Flags.MOB_DAMAGE), is(true));
assertThat(set.testState(player, Flags.ENTRY), is(true));
assertThat(set.testState(player, Flags.EXIT), is(true));
assertThat(set.testState(player, Flags.LEAF_DECAY), is(true));
assertThat(set.testState(player, Flags.RECEIVE_CHAT), is(true));
assertThat(set.testState(player, Flags.SEND_CHAT), is(true));
assertThat(set.testState(player, Flags.INVINCIBILITY), is(false));
assertTrue(set.testState(player, Flags.MOB_DAMAGE));
assertTrue(set.testState(player, Flags.ENTRY));
assertTrue(set.testState(player, Flags.EXIT));
assertTrue(set.testState(player, Flags.LEAF_DECAY));
assertTrue(set.testState(player, Flags.RECEIVE_CHAT));
assertTrue(set.testState(player, Flags.SEND_CHAT));
assertFalse(set.testState(player, Flags.INVINCIBILITY));
assertThat(set.testState(player, Flags.BUILD), is(true));
assertTrue(set.testState(player, Flags.BUILD));
}
@Test
@ -101,15 +103,15 @@ public class ApplicableRegionSetTest {
ApplicableRegionSet set = mock.getApplicableSet();
assertThat(set.testState(player, Flags.MOB_DAMAGE), is(true));
assertThat(set.testState(player, Flags.ENTRY), is(true));
assertThat(set.testState(player, Flags.EXIT), is(true));
assertThat(set.testState(player, Flags.LEAF_DECAY), is(true));
assertThat(set.testState(player, Flags.RECEIVE_CHAT), is(true));
assertThat(set.testState(player, Flags.SEND_CHAT), is(true));
assertThat(set.testState(player, Flags.INVINCIBILITY), is(false));
assertTrue(set.testState(player, Flags.MOB_DAMAGE));
assertTrue(set.testState(player, Flags.ENTRY));
assertTrue(set.testState(player, Flags.EXIT));
assertTrue(set.testState(player, Flags.LEAF_DECAY));
assertTrue(set.testState(player, Flags.RECEIVE_CHAT));
assertTrue(set.testState(player, Flags.SEND_CHAT));
assertFalse(set.testState(player, Flags.INVINCIBILITY));
assertThat(set.testState(player, Flags.BUILD), is(true));
assertTrue(set.testState(player, Flags.BUILD));
}
@Test
@ -124,25 +126,25 @@ public class ApplicableRegionSetTest {
ApplicableRegionSet set = mock.getApplicableSet();
assertThat(set.testState(member, Flags.MOB_DAMAGE), is(true));
assertThat(set.testState(member, Flags.ENTRY), is(true));
assertThat(set.testState(member, Flags.EXIT), is(true));
assertThat(set.testState(member, Flags.LEAF_DECAY), is(true));
assertThat(set.testState(member, Flags.RECEIVE_CHAT), is(true));
assertThat(set.testState(member, Flags.SEND_CHAT), is(true));
assertThat(set.testState(member, Flags.INVINCIBILITY), is(false));
assertTrue(set.testState(member, Flags.MOB_DAMAGE));
assertTrue(set.testState(member, Flags.ENTRY));
assertTrue(set.testState(member, Flags.EXIT));
assertTrue(set.testState(member, Flags.LEAF_DECAY));
assertTrue(set.testState(member, Flags.RECEIVE_CHAT));
assertTrue(set.testState(member, Flags.SEND_CHAT));
assertFalse(set.testState(member, Flags.INVINCIBILITY));
assertThat(set.testState(member, Flags.BUILD), is(true));
assertTrue(set.testState(member, Flags.BUILD));
assertThat(set.testState(nonMember, Flags.MOB_DAMAGE), is(true));
assertThat(set.testState(nonMember, Flags.ENTRY), is(true));
assertThat(set.testState(nonMember, Flags.EXIT), is(true));
assertThat(set.testState(nonMember, Flags.LEAF_DECAY), is(true));
assertThat(set.testState(nonMember, Flags.RECEIVE_CHAT), is(true));
assertThat(set.testState(nonMember, Flags.SEND_CHAT), is(true));
assertThat(set.testState(nonMember, Flags.INVINCIBILITY), is(false));
assertTrue(set.testState(nonMember, Flags.MOB_DAMAGE));
assertTrue(set.testState(nonMember, Flags.ENTRY));
assertTrue(set.testState(nonMember, Flags.EXIT));
assertTrue(set.testState(nonMember, Flags.LEAF_DECAY));
assertTrue(set.testState(nonMember, Flags.RECEIVE_CHAT));
assertTrue(set.testState(nonMember, Flags.SEND_CHAT));
assertFalse(set.testState(nonMember, Flags.INVINCIBILITY));
assertThat(set.testState(nonMember, Flags.BUILD), is(false));
assertFalse(set.testState(nonMember, Flags.BUILD));
}
@Test
@ -623,19 +625,19 @@ public class ApplicableRegionSetTest {
test = new CommandFilter(
set.queryValue(nonMember, Flags.ALLOWED_CMDS),
set.queryValue(nonMember, Flags.BLOCKED_CMDS));
assertThat(test.apply("/permit"), is(true));
assertThat(test.apply("/strange"), is(true));
assertThat(test.apply("/other"), is(false));
assertThat(test.apply("/deny"), is(false));
assertTrue(test.apply("/permit"));
assertTrue(test.apply("/strange"));
assertFalse(test.apply("/other"));
assertFalse(test.apply("/deny"));
set = mock.getApplicableSetInWilderness();
test = new CommandFilter(
set.queryValue(nonMember, Flags.ALLOWED_CMDS),
set.queryValue(nonMember, Flags.BLOCKED_CMDS));
assertThat(test.apply("/permit"), is(true));
assertThat(test.apply("/strange"), is(false));
assertThat(test.apply("/other"), is(true));
assertThat(test.apply("/deny"), is(false));
assertTrue(test.apply("/permit"));
assertFalse(test.apply("/strange"));
assertTrue(test.apply("/other"));
assertFalse(test.apply("/deny"));
}
@Test

49
worldguard-core/src/test/java/com/sk89q/worldguard/protection/FlagValueCalculatorMapFlagTest.java
View File

@ -24,13 +24,12 @@ import com.sk89q.worldguard.protection.flags.MapFlag;
import com.sk89q.worldguard.protection.flags.StateFlag;
import com.sk89q.worldguard.protection.flags.StringFlag;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.HashMap;
import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
@SuppressWarnings({"UnusedDeclaration"})
public class FlagValueCalculatorMapFlagTest {
@ -48,18 +47,18 @@ public class FlagValueCalculatorMapFlagTest {
global.setFlag(mapFlag, map);
ApplicableRegionSet applicableSet = mock.getApplicableSet();
assertThat(applicableSet.queryMapValue(null, mapFlag, "allow", Flags.BUILD),
equalTo(StateFlag.State.ALLOW));
assertThat(applicableSet.queryMapValue(null, mapFlag, "deny", Flags.BUILD),
equalTo(StateFlag.State.DENY));
assertThat(applicableSet.queryMapValue(null, mapFlag, "undefined", Flags.BUILD),
equalTo(StateFlag.State.DENY));
assertThat(applicableSet.queryMapValue(null, mapFlag, "allow", null),
equalTo(StateFlag.State.ALLOW));
assertThat(applicableSet.queryMapValue(null, mapFlag, "deny", null),
equalTo(StateFlag.State.DENY));
assertThat(applicableSet.queryMapValue(null, mapFlag, "undefined", null),
equalTo(StateFlag.State.ALLOW));
assertEquals(applicableSet.queryMapValue(null, mapFlag, "allow", Flags.BUILD),
StateFlag.State.ALLOW);
assertEquals(applicableSet.queryMapValue(null, mapFlag, "deny", Flags.BUILD),
StateFlag.State.DENY);
assertEquals(applicableSet.queryMapValue(null, mapFlag, "undefined", Flags.BUILD),
StateFlag.State.DENY);
assertEquals(applicableSet.queryMapValue(null, mapFlag, "allow", null),
StateFlag.State.ALLOW);
assertEquals(applicableSet.queryMapValue(null, mapFlag, "deny", null),
StateFlag.State.DENY);
assertEquals(applicableSet.queryMapValue(null, mapFlag, "undefined", null),
StateFlag.State.ALLOW);
}
@Test
@ -86,12 +85,12 @@ public class FlagValueCalculatorMapFlagTest {
region2.setFlag(mapFlag, map2);
ApplicableRegionSet applicableSet = mock.getApplicableSet();
assertThat(applicableSet.queryMapValue(null, mapFlag, "should-deny", null),
equalTo(StateFlag.State.DENY));
assertThat(applicableSet.queryMapValue(null, mapFlag, "should-allow", null),
equalTo(StateFlag.State.ALLOW));
assertThat(applicableSet.queryMapValue(null, mapFlag, "should-allow2", null),
equalTo(StateFlag.State.ALLOW));
assertEquals(applicableSet.queryMapValue(null, mapFlag, "should-deny", null),
StateFlag.State.DENY);
assertEquals(applicableSet.queryMapValue(null, mapFlag, "should-allow", null),
StateFlag.State.ALLOW);
assertEquals(applicableSet.queryMapValue(null, mapFlag, "should-allow2", null),
StateFlag.State.ALLOW);
}
@ -116,9 +115,9 @@ public class FlagValueCalculatorMapFlagTest {
child.setFlag(mapFlag, childMap);
ApplicableRegionSet applicableSet = mock.getApplicableSet();
assertThat(applicableSet.queryMapValue(null, mapFlag, "useChildValue", null),
equalTo(StateFlag.State.DENY));
assertThat(applicableSet.queryMapValue(null, mapFlag, "useParentValue", null),
equalTo(StateFlag.State.ALLOW));
assertEquals(applicableSet.queryMapValue(null, mapFlag, "useChildValue", null),
StateFlag.State.DENY);
assertEquals(applicableSet.queryMapValue(null, mapFlag, "useParentValue", null),
StateFlag.State.ALLOW);
}
}

382
worldguard-core/src/test/java/com/sk89q/worldguard/protection/FlagValueCalculatorTest.java
View File

@ -28,12 +28,14 @@ import com.sk89q.worldguard.protection.flags.StateFlag.State;
import com.sk89q.worldguard.protection.flags.StringFlag;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Set;
import static com.google.common.collect.ImmutableSet.copyOf;
import static com.google.common.collect.ImmutableSet.of;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.jupiter.api.Assertions.*;
@SuppressWarnings({"UnusedAssignment", "UnusedDeclaration"})
public class FlagValueCalculatorTest {
@ -45,7 +47,7 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.NO_REGIONS));
assertEquals(result.getMembership(player), Result.NO_REGIONS);
}
@Test
@ -57,7 +59,7 @@ public class FlagValueCalculatorTest {
ProtectedRegion global = mock.global();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.NO_REGIONS));
assertEquals(result.getMembership(player), Result.NO_REGIONS);
}
@Test
@ -69,7 +71,7 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.NO_REGIONS));
assertEquals(result.getMembership(player), Result.NO_REGIONS);
}
@Test
@ -83,7 +85,7 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.FAIL));
assertEquals(result.getMembership(player), Result.FAIL);
}
@Test
@ -99,7 +101,7 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.NO_REGIONS));
assertEquals(result.getMembership(player), Result.NO_REGIONS);
}
@Test
@ -114,7 +116,7 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.FAIL));
assertEquals(result.getMembership(player), Result.FAIL);
}
@Test
@ -130,7 +132,7 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.SUCCESS));
assertEquals(result.getMembership(player), Result.SUCCESS);
}
@Test
@ -148,13 +150,13 @@ public class FlagValueCalculatorTest {
region = mock.add(0);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.FAIL));
assertEquals(result.getMembership(player), Result.FAIL);
// Add another player (should still fail)
region.getMembers().addPlayer(mock.createPlayer());
result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.FAIL));
assertEquals(result.getMembership(player), Result.FAIL);
}
@Test
@ -172,7 +174,7 @@ public class FlagValueCalculatorTest {
region = mock.add(10);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.FAIL));
assertEquals(result.getMembership(player), Result.FAIL);
}
@Test
@ -190,7 +192,7 @@ public class FlagValueCalculatorTest {
region = mock.add(0);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.SUCCESS));
assertEquals(result.getMembership(player), Result.SUCCESS);
}
@Test
@ -209,7 +211,7 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.SUCCESS));
assertEquals(result.getMembership(player), Result.SUCCESS);
}
@Test
@ -228,7 +230,7 @@ public class FlagValueCalculatorTest {
parent.getMembers().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.SUCCESS));
assertEquals(result.getMembership(player), Result.SUCCESS);
}
@Test
@ -249,7 +251,7 @@ public class FlagValueCalculatorTest {
parent.getMembers().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.FAIL));
assertEquals(result.getMembership(player), Result.FAIL);
}
@Test
@ -271,7 +273,7 @@ public class FlagValueCalculatorTest {
parent.getMembers().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getMembership(player), is(Result.SUCCESS));
assertEquals(result.getMembership(player), Result.SUCCESS);
}
// ========================================================================
@ -285,8 +287,8 @@ public class FlagValueCalculatorTest {
StateFlag flag2 = new StateFlag("test2", true);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryState(null, flag1), is((State) null));
assertThat(result.queryState(null, flag2), is(State.ALLOW));
assertNull(result.queryState(null, flag1));
assertEquals(result.queryState(null, flag2), State.ALLOW);
}
// ========================================================================
@ -303,8 +305,8 @@ public class FlagValueCalculatorTest {
region.setFlag(flag2, State.DENY);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag1), is((State) null));
assertThat(result.queryValue(null, flag2), is(State.DENY));
assertNull(result.queryValue(null, flag1));
assertEquals(result.queryValue(null, flag2), State.DENY);
}
@Test
@ -321,8 +323,8 @@ public class FlagValueCalculatorTest {
region.setFlag(flag2, State.ALLOW);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag1), is((State) null));
assertThat(result.queryValue(null, flag2), is(State.DENY));
assertNull(result.queryValue(null, flag1));
assertEquals(result.queryValue(null, flag2), State.DENY);
}
@Test
@ -338,8 +340,8 @@ public class FlagValueCalculatorTest {
region.setFlag(flag2, State.ALLOW);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag1), is((State) null));
assertThat(result.queryValue(null, flag2), is(State.ALLOW));
assertNull(result.queryValue(null, flag1));
assertEquals(result.queryValue(null, flag2), State.ALLOW);
}
@Test
@ -358,9 +360,9 @@ public class FlagValueCalculatorTest {
region.setFlag(flag2, State.DENY);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag1), is(State.DENY));
assertThat(result.queryValue(null, flag2), is(State.DENY));
assertThat(result.queryValue(null, flag3), is((State) null));
assertEquals(result.queryValue(null, flag1), State.DENY);
assertEquals(result.queryValue(null, flag2), State.DENY);
assertNull(result.queryValue(null, flag3));
}
@Test
@ -381,8 +383,8 @@ public class FlagValueCalculatorTest {
region.setParent(parent);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, flag1), is(State.DENY));
assertThat(result.queryValue(member, flag1), is((State) null));
assertEquals(result.queryValue(nonMember, flag1), State.DENY);
assertNull(result.queryValue(member, flag1));
}
@Test
@ -405,9 +407,9 @@ public class FlagValueCalculatorTest {
region.setParent(parent);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, flag1), is(State.DENY));
assertThat(result.queryValue(memberOne, flag1), is((State) null));
assertThat(result.queryValue(memberTwo, flag1), is(State.DENY));
assertEquals(result.queryValue(nonMember, flag1), State.DENY);
assertNull(result.queryValue(memberOne, flag1));
assertEquals(result.queryValue(memberTwo, flag1), State.DENY);
}
@Test
@ -427,8 +429,8 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(member);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, flag1), is(State.DENY));
assertThat(result.queryValue(member, flag1), is(State.DENY));
assertEquals(result.queryValue(nonMember, flag1), State.DENY);
assertEquals(result.queryValue(member, flag1), State.DENY);
}
@Test
@ -450,8 +452,8 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(member);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, flag1), is(State.DENY));
assertThat(result.queryValue(member, flag1), is(State.ALLOW));
assertEquals(result.queryValue(nonMember, flag1), State.DENY);
assertEquals(result.queryValue(member, flag1), State.ALLOW);
}
@Test
@ -469,9 +471,9 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test2");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, stringFlag1), isOneOf("test1", "test2"));
assertThat(result.queryValue(null, stringFlag2), is((String) null));
assertThat(result.queryValue(null, flag1), is((State) null));
assertTrue(List.of("test1", "test2").contains(result.queryValue(null, stringFlag1)));
assertNull(result.queryValue(null, stringFlag2));
assertNull(result.queryValue(null, flag1));
}
@Test
@ -483,7 +485,7 @@ public class FlagValueCalculatorTest {
ProtectedRegion global = mock.global();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag), is(State.ALLOW));
assertEquals(result.queryValue(null, flag), State.ALLOW);
}
@Test
@ -496,7 +498,7 @@ public class FlagValueCalculatorTest {
global.setFlag(flag, State.ALLOW);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag), is(State.ALLOW));
assertEquals(result.queryValue(null, flag), State.ALLOW);
}
@Test
@ -509,7 +511,7 @@ public class FlagValueCalculatorTest {
global.setFlag(flag, State.DENY);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag), is(State.DENY));
assertEquals(result.queryValue(null, flag), State.DENY);
}
@Test
@ -521,7 +523,7 @@ public class FlagValueCalculatorTest {
ProtectedRegion global = mock.global();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag), is((String) null));
assertNull(result.queryValue(null, flag));
}
@Test
@ -534,7 +536,7 @@ public class FlagValueCalculatorTest {
global.setFlag(flag, "hello");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag), is("hello"));
assertEquals(result.queryValue(null, flag), "hello");
}
@Test
@ -549,7 +551,7 @@ public class FlagValueCalculatorTest {
ProtectedRegion region = mock.add(0);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag), is("hello"));
assertEquals(result.queryValue(null, flag), "hello");
}
@Test
@ -565,7 +567,7 @@ public class FlagValueCalculatorTest {
region.setFlag(flag, "beep");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag), is("beep"));
assertEquals(result.queryValue(null, flag), "beep");
}
@Test
@ -591,9 +593,9 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(member);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(null, flag), is("ello there"));
assertThat(result.queryValue(nonMember, flag), is("ello there"));
assertThat(result.queryValue(member, flag), is("beep beep"));
assertEquals(result.queryValue(null, flag), "ello there");
assertEquals(result.queryValue(nonMember, flag), "ello there");
assertEquals(result.queryValue(member, flag), "beep beep");
}
@Test
@ -603,7 +605,7 @@ public class FlagValueCalculatorTest {
LocalPlayer nonMember = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.ALLOW));
assertEquals(result.queryValue(nonMember, Flags.BUILD), State.ALLOW);
}
@Test
@ -615,7 +617,7 @@ public class FlagValueCalculatorTest {
ProtectedRegion global = mock.global();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.ALLOW));
assertEquals(result.queryValue(nonMember, Flags.BUILD), State.ALLOW);
}
@Test
@ -628,7 +630,7 @@ public class FlagValueCalculatorTest {
global.setFlag(Flags.BUILD, State.DENY);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.DENY));
assertEquals(result.queryValue(nonMember, Flags.BUILD), State.DENY);
}
@Test
@ -641,7 +643,7 @@ public class FlagValueCalculatorTest {
global.setFlag(Flags.BUILD, State.ALLOW);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.ALLOW));
assertEquals(result.queryValue(nonMember, Flags.BUILD), State.ALLOW);
}
@Test
@ -655,8 +657,8 @@ public class FlagValueCalculatorTest {
global.getMembers().addPlayer(member);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(member, Flags.BUILD), is(State.ALLOW));
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertEquals(result.queryValue(member, Flags.BUILD), State.ALLOW);
assertNull(result.queryValue(nonMember, Flags.BUILD));
}
@Test
@ -671,8 +673,8 @@ public class FlagValueCalculatorTest {
global.setFlag(Flags.BUILD, State.DENY);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(member, Flags.BUILD), is(State.DENY));
assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.DENY));
assertEquals(result.queryValue(member, Flags.BUILD), State.DENY);
assertEquals(result.queryValue(nonMember, Flags.BUILD), State.DENY);
}
@Test
@ -689,8 +691,8 @@ public class FlagValueCalculatorTest {
// Cannot set ALLOW on BUILD
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(member, Flags.BUILD), is(State.ALLOW));
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertEquals(result.queryValue(member, Flags.BUILD), State.ALLOW);
assertNull(result.queryValue(nonMember, Flags.BUILD));
}
@Test
@ -704,8 +706,8 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(member);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(member, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertEquals(result.queryValue(member, Flags.BUILD), State.ALLOW);
}
@Test
@ -724,9 +726,9 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(memberBoth);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertNull(result.queryValue(memberOne, Flags.BUILD));
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -746,9 +748,9 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(memberBoth);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -768,9 +770,9 @@ public class FlagValueCalculatorTest {
region.setParent(parent);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -790,9 +792,9 @@ public class FlagValueCalculatorTest {
region.setParent(parent);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -814,9 +816,9 @@ public class FlagValueCalculatorTest {
ProtectedRegion priority = mock.add(10);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is((State) null));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertNull(result.queryValue(memberOne, Flags.BUILD));
assertNull(result.queryValue(memberBoth, Flags.BUILD));
}
@Test
@ -839,9 +841,9 @@ public class FlagValueCalculatorTest {
priority.setFlag(Flags.PASSTHROUGH, State.ALLOW);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -862,9 +864,9 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(memberBoth);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertNull(result.queryValue(memberOne, Flags.BUILD));
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -887,9 +889,9 @@ public class FlagValueCalculatorTest {
region.setFlag(Flags.BUILD, State.ALLOW);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.ALLOW));
assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertEquals(result.queryValue(nonMember, Flags.BUILD), State.ALLOW);
assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -913,9 +915,9 @@ public class FlagValueCalculatorTest {
region.setFlag(Flags.BUILD, State.ALLOW);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.DENY));
assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.DENY));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.DENY));
assertEquals(result.queryValue(nonMember, Flags.BUILD), State.DENY);
assertEquals(result.queryValue(memberOne, Flags.BUILD), State.DENY);
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.DENY);
}
@Test
@ -939,9 +941,9 @@ public class FlagValueCalculatorTest {
// Disable setting ALLOW for safety reasons
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertNull(result.queryValue(memberOne, Flags.BUILD));
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -964,10 +966,10 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(memberBoth);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(globalMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(globalMember, Flags.BUILD));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertNull(result.queryValue(memberOne, Flags.BUILD));
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -992,10 +994,10 @@ public class FlagValueCalculatorTest {
FlagValueCalculator result = mock.getFlagCalculator();
// Inconsistent due to legacy reasons
assertThat(result.queryValue(globalMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(globalMember, Flags.BUILD));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertNull(result.queryValue(memberOne, Flags.BUILD));
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
@Test
@ -1019,10 +1021,10 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(memberBoth);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.queryValue(globalMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
assertNull(result.queryValue(globalMember, Flags.BUILD));
assertNull(result.queryValue(nonMember, Flags.BUILD));
assertNull(result.queryValue(memberOne, Flags.BUILD));
assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
}
// ========================================================================
@ -1046,8 +1048,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test2");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1", "test2")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1", "test2"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1068,8 +1070,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test", "test")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1090,8 +1092,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test2");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1115,8 +1117,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test2");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1", "test3")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1", "test3"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1141,8 +1143,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test2");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1167,8 +1169,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test2");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test3")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test3"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1193,8 +1195,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test2");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1219,8 +1221,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1, "test2");
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test2")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test2"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1248,8 +1250,8 @@ public class FlagValueCalculatorTest {
region.setParent(parent2);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test2", "test3")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test2", "test3"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1277,8 +1279,8 @@ public class FlagValueCalculatorTest {
region = mock.add(30);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test2")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test2"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
@Test
@ -1306,8 +1308,8 @@ public class FlagValueCalculatorTest {
region = mock.add(30);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1")));
assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1"));
assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
}
// ========================================================================
@ -1320,7 +1322,7 @@ public class FlagValueCalculatorTest {
ProtectedRegion region = mock.add(30);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getPriority(region), is(30));
assertEquals(result.getPriority(region), 30);
}
@Test
@ -1330,7 +1332,7 @@ public class FlagValueCalculatorTest {
ProtectedRegion region = mock.global();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getPriority(region), is(Integer.MIN_VALUE));
assertEquals(result.getPriority(region), Integer.MIN_VALUE);
}
// ========================================================================
@ -1352,8 +1354,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.ALL);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1374,8 +1376,8 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1394,8 +1396,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.ALL);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1416,8 +1418,8 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1436,8 +1438,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.NON_MEMBERS);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1458,8 +1460,8 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1480,8 +1482,8 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo(null));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertNull(result.getEffectiveFlag(region, stringFlag1, player));
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1500,8 +1502,8 @@ public class FlagValueCalculatorTest {
region.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.MEMBERS);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo(null));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertNull(result.getEffectiveFlag(region, stringFlag1, null));
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1523,8 +1525,8 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1546,8 +1548,8 @@ public class FlagValueCalculatorTest {
region.getOwners().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1569,8 +1571,8 @@ public class FlagValueCalculatorTest {
region.getOwners().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1592,8 +1594,8 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo(null));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertNull(result.getEffectiveFlag(region, stringFlag1, player));
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1615,8 +1617,8 @@ public class FlagValueCalculatorTest {
region.getOwners().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo(null));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertNull(result.getEffectiveFlag(region, stringFlag1, player));
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1638,8 +1640,8 @@ public class FlagValueCalculatorTest {
region.getOwners().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo(null));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertNull(result.getEffectiveFlag(region, stringFlag1, player));
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1661,8 +1663,8 @@ public class FlagValueCalculatorTest {
region.getMembers().addPlayer(player);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1683,8 +1685,8 @@ public class FlagValueCalculatorTest {
LocalPlayer player = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1709,8 +1711,8 @@ public class FlagValueCalculatorTest {
region.setParent(parent2);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test1"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test1");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1737,8 +1739,8 @@ public class FlagValueCalculatorTest {
region.setParent(parent2);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test2"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test2");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1765,8 +1767,8 @@ public class FlagValueCalculatorTest {
parent1.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.ALL);
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test3"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test3");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1798,10 +1800,10 @@ public class FlagValueCalculatorTest {
LocalPlayer player2 = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1833,10 +1835,10 @@ public class FlagValueCalculatorTest {
LocalPlayer player2 = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1864,10 +1866,10 @@ public class FlagValueCalculatorTest {
LocalPlayer player2 = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1895,10 +1897,10 @@ public class FlagValueCalculatorTest {
LocalPlayer player2 = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1926,10 +1928,10 @@ public class FlagValueCalculatorTest {
LocalPlayer player2 = mock.createPlayer();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
assertNull(result.getEffectiveFlag(region, stringFlag2, null));
}
@Test
@ -1939,7 +1941,7 @@ public class FlagValueCalculatorTest {
ProtectedRegion global = mock.global();
FlagValueCalculator result = mock.getFlagCalculator();
assertThat(result.getEffectiveFlag(global, Flags.BUILD, null), equalTo(null));
assertNull(result.getEffectiveFlag(global, Flags.BUILD, null));
}
@Test
@ -1951,7 +1953,7 @@ public class FlagValueCalculatorTest {
FlagValueCalculator result = mock.getFlagCalculator();
// Cannot let users override BUILD on GLOBAL
assertThat(result.getEffectiveFlag(global, Flags.BUILD, null), equalTo(State.DENY));
assertEquals(result.getEffectiveFlag(global, Flags.BUILD, null), State.DENY);
}
@Test
@ -1963,6 +1965,6 @@ public class FlagValueCalculatorTest {
FlagValueCalculator result = mock.getFlagCalculator();
// Cannot let users override BUILD on GLOBAL
assertThat(result.getEffectiveFlag(global, Flags.BUILD, null), equalTo(null));
assertNull(result.getEffectiveFlag(global, Flags.BUILD, null));
}
}

16
worldguard-core/src/test/java/com/sk89q/worldguard/protection/HashMapIndexRemovalTest.java
View File

@ -29,14 +29,14 @@ import com.sk89q.worldguard.protection.managers.storage.MemoryRegionDatabase;
import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import com.sk89q.worldguard.protection.regions.ProtectedRegion.CircularInheritanceException;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class HashMapIndexRemovalTest {
private static final String ORPHAN_ID = "orphan";
@ -52,7 +52,7 @@ public class HashMapIndexRemovalTest {
return new RegionManager(new MemoryRegionDatabase(), new HashMapIndex.Factory(), getFlagRegistry());
}
@Before
@BeforeEach
public void setUp() {
manager = createRegionManager();

19
worldguard-core/src/test/java/com/sk89q/worldguard/protection/RegionEntryExitTest.java
View File

@ -19,8 +19,6 @@
package com.sk89q.worldguard.protection;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import com.sk89q.worldedit.math.BlockVector3;
import com.sk89q.worldguard.TestPlayer;
@ -34,8 +32,11 @@ import com.sk89q.worldguard.protection.managers.RegionManager;
import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
public abstract class RegionEntryExitTest {
@ -60,7 +61,7 @@ public abstract class RegionEntryExitTest {
protected abstract RegionManager createRegionManager() throws Exception;
@Before
@BeforeEach
public void setUp() throws Exception {
setUpGlobalRegion();
@ -129,8 +130,8 @@ public abstract class RegionEntryExitTest {
// System.out.println("flag " + appl.getFlag(Flags.ENTRY));
// System.out.println("grp " + appl.getFlag(Flags.ENTRY.getRegionGroupFlag()));
// System.out.println("===");
assertTrue("Allowed Entry", appl.testState(vipPlayer, Flags.ENTRY));
assertFalse("Forbidden Entry", appl.testState(builderPlayer, Flags.ENTRY));
assertTrue(appl.testState(vipPlayer, Flags.ENTRY), "Allowed Entry");
assertFalse(appl.testState(builderPlayer, Flags.ENTRY), "Forbidden Entry");
}
@Test
@ -144,8 +145,8 @@ public abstract class RegionEntryExitTest {
// System.out.println("flag " + appl.getFlag(Flags.EXIT));
// System.out.println("grp " + appl.getFlag(Flags.EXIT.getRegionGroupFlag()));
// System.out.println("===");
assertTrue("Allowed Exit", appl.testState(builderPlayer, Flags.EXIT));
assertFalse("Forbidden Exit", appl.testState(vipPlayer, Flags.EXIT));
assertTrue(appl.testState(builderPlayer, Flags.EXIT), "Allowed Exit");
assertFalse(appl.testState(vipPlayer, Flags.EXIT), "Forbidden Exit");
}
}

42
worldguard-core/src/test/java/com/sk89q/worldguard/protection/RegionOverlapTest.java
View File

@ -19,9 +19,6 @@
package com.sk89q.worldguard.protection;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import com.sk89q.worldedit.math.BlockVector2;
import com.sk89q.worldedit.math.BlockVector3;
import com.sk89q.worldguard.TestPlayer;
@ -36,16 +33,20 @@ import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
@RunWith(Parameterized.class)
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public abstract class RegionOverlapTest {
static String COURTYARD_ID = "courtyard";
static String FOUNTAIN_ID = "fountain";
@ -64,13 +65,13 @@ public abstract class RegionOverlapTest {
TestPlayer player1;
TestPlayer player2;
@Parameterized.Parameters(name = "{index}: useMaxPrio = {0}")
/* @Parameterized.Parameters(name = "{index}: useMaxPrio = {0}")
public static Iterable<Object[]> params() {
return Arrays.asList(new Object[][]{{true}, {false}});
}
}*/
@Parameterized.Parameter
public boolean useMaxPriorityAssociation;
// public boolean useMaxPriorityAssociation;
protected FlagRegistry getFlagRegistry() {
return WorldGuard.getInstance().getFlagRegistry();
@ -78,7 +79,7 @@ public abstract class RegionOverlapTest {
protected abstract RegionManager createRegionManager() throws Exception;
@Before
@BeforeAll
public void setUp() throws Exception {
setUpGlobalRegion();
@ -194,8 +195,9 @@ public abstract class RegionOverlapTest {
assertTrue(appl.testState(player2, Flags.BUILD));
}
@Test
public void testNonPlayerBuildAccessInOneRegion() {
@ParameterizedTest(name = "useMaxPriorityAssociation={0}")
@ValueSource(booleans = { false, true })
public void testNonPlayerBuildAccessInOneRegion(boolean useMaxPriorityAssociation) {
ApplicableRegionSet appl;
HashSet<ProtectedRegion> source = new HashSet<>();
@ -213,8 +215,9 @@ public abstract class RegionOverlapTest {
assertFalse(appl.testState(assoc, Flags.BUILD));
}
@Test
public void testNonPlayerBuildAccessInBothRegions() {
@ParameterizedTest(name = "useMaxPriorityAssociation={0}")
@ValueSource(booleans = { false, true })
public void testNonPlayerBuildAccessInBothRegions(boolean useMaxPriorityAssociation) {
ApplicableRegionSet appl;
HashSet<ProtectedRegion> source = new HashSet<>();
@ -233,8 +236,9 @@ public abstract class RegionOverlapTest {
assertTrue(appl.testState(assoc, Flags.BUILD));
}
@Test
public void testNonPlayerBuildAccessInNoRegions() {
@ParameterizedTest(name = "useMaxPriorityAssociation={0}")
@ValueSource(booleans = { false, true })
public void testNonPlayerBuildAccessInNoRegions(boolean useMaxPriorityAssociation) {
ApplicableRegionSet appl;
HashSet<ProtectedRegion> source = new HashSet<>();

13
worldguard-core/src/test/java/com/sk89q/worldguard/protection/RegionPriorityTest.java
View File

@ -19,8 +19,6 @@
package com.sk89q.worldguard.protection;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import com.sk89q.worldedit.math.BlockVector2;
import com.sk89q.worldedit.math.BlockVector3;
@ -35,11 +33,16 @@ import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public abstract class RegionPriorityTest {
static String COURTYARD_ID = "courtyard";
static String FOUNTAIN_ID = "fountain";
@ -63,7 +66,7 @@ public abstract class RegionPriorityTest {
protected abstract RegionManager createRegionManager() throws Exception;
@Before
@BeforeAll
public void setUp() throws Exception {
setUpGlobalRegion();

13
worldguard-core/src/test/java/com/sk89q/worldguard/protection/regions/RegionIntersectTest.java
View File

@ -19,17 +19,18 @@
package com.sk89q.worldguard.protection.regions;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import com.sk89q.worldedit.math.BlockVector2;
import com.sk89q.worldedit.math.BlockVector3;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class RegionIntersectTest {
@Test
@ -96,7 +97,7 @@ public class RegionIntersectTest {
e.printStackTrace();
}
assertEquals("Check for '" + region2.getId() + "' region failed.", expected, actual);
assertEquals(expected, actual, "Check for '" + region2.getId() + "' region failed.");
}
private static final BlockVector2[] polygon = {
@ -117,8 +118,8 @@ public class RegionIntersectTest {
final ProtectedPolygonalRegion polygonalRegion = new ProtectedPolygonalRegion("polygonalRegion", Arrays.asList(rotatedPolygon), -3, 3);
assertTrue(String.format("%s does not intersect (cuboid.intersectsEdges(polygonal)", Arrays.asList(rotatedPolygon)), cuboidRegion.intersectsEdges(polygonalRegion));
assertTrue(String.format("%s does not intersect (polygonal.intersectsEdges(cuboid)", Arrays.asList(rotatedPolygon)), polygonalRegion.intersectsEdges(cuboidRegion));
assertTrue(cuboidRegion.intersectsEdges(polygonalRegion), String.format("%s does not intersect (cuboid.intersectsEdges(polygonal)", Arrays.asList(rotatedPolygon)));
assertTrue(polygonalRegion.intersectsEdges(cuboidRegion), String.format("%s does not intersect (polygonal.intersectsEdges(cuboid)", Arrays.asList(rotatedPolygon)));
}
}
}

14
worldguard-core/src/test/java/com/sk89q/worldguard/util/CommandFilterTest.java
View File

@ -21,15 +21,15 @@ package com.sk89q.worldguard.util;
import com.sk89q.worldguard.util.command.CommandFilter;
import com.sk89q.worldguard.util.command.CommandFilter.Builder;
import junit.framework.TestCase;
import org.junit.jupiter.api.Test;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class CommandFilterTest extends TestCase {
public class CommandFilterTest {
private static final String[] COMMAND_SEPARATORS = new String[] {" ", " ", "\t", " \t", "\n", "\r\n"};
@Test
public void testApply() throws Exception {
CommandFilter filter;
@ -187,9 +187,9 @@ public class CommandFilterTest extends TestCase {
private void assertSubcommands(CommandFilter filter, final String root, boolean expected) {
for (String separator : COMMAND_SEPARATORS) {
assertThat(filter.apply(root.replaceAll(" ", separator)), is(expected));
assertThat(filter.apply((root + " _subcmd").replaceAll(" ", separator)), is(expected));
assertThat(filter.apply((root + " _subcmd _another").replaceAll(" ", separator)), is(expected));
assertEquals(filter.apply(root.replaceAll(" ", separator)), expected);
assertEquals(filter.apply((root + " _subcmd").replaceAll(" ", separator)), expected);
assertEquals(filter.apply((root + " _subcmd _another").replaceAll(" ", separator)), expected);
}
}