SpigotMC/craftbukkit
0
0
Fork 0
mirror of https://hub.spigotmc.org/stash/scm/spigot/craftbukkit.git synced 2025-04-23 01:05:48 +00:00
Code Issues Activity

Updated tests

Browse Source
This commit is contained in:
DerFrZocker
2023-06-12 10:56:45 +02:00
parent 7374263989
commit 6dac9a12dd
22 changed files with 155 additions and 944 deletions

4
src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java

@ -437,12 +437,12 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
}
@Override
public Entity spawnEntity(Location location, EntityType<?> entityType) {
public <E extends Entity> E spawnEntity(Location location, EntityType<E> entityType) {
return spawn(location, entityType.getEntityClass());
}
@Override
public Entity spawnEntity(Location loc, EntityType<?> type, boolean randomizeData) {
public <E extends Entity> E spawnEntity(Location loc, EntityType<E> type, boolean randomizeData) {
return spawn(loc, type.getEntityClass(), null, CreatureSpawnEvent.SpawnReason.CUSTOM, randomizeData);
}

39
src/test/java/org/bukkit/ArtTest.java

@ -3,60 +3,21 @@ package org.bukkit;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
import com.google.common.collect.Lists;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.minecraft.core.Holder;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.resources.ResourceKey;
import net.minecraft.world.entity.decoration.PaintingVariant;
import org.bukkit.craftbukkit.CraftArt;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class ArtTest extends AbstractTestingBase {
private static final int UNIT_MULTIPLIER = 16;
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Art.class.getFields()) {
if (field.getType() != Art.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No Art for field name " + name, Registry.ART.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (PaintingVariant painting : BuiltInRegistries.PAINTING_VARIANT) {
MinecraftKey minecraftKey = BuiltInRegistries.PAINTING_VARIANT.getKey(painting);
try {
Art art = (Art) Art.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(art.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default art for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type art for" + minecraftKey);
}
}
}
@Test
public void verifyMapping() {
List<Art> arts = Lists.newArrayList(Art.values());

43
src/test/java/org/bukkit/BiomeTest.java

@ -1,57 +1,14 @@
package org.bukkit;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.level.biome.BiomeBase;
import org.bukkit.block.Biome;
import org.bukkit.craftbukkit.block.CraftBiome;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class BiomeTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Biome.class.getFields()) {
if (field.getType() != Biome.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
if (name.equals("CUSTOM")) {
continue;
}
Assert.assertNotNull("No Biome for field name " + name, Registry.BIOME.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (BiomeBase biomeBase : BIOMES) {
MinecraftKey minecraftKey = BIOMES.getKey(biomeBase);
try {
Biome biome = (Biome) Biome.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(biome.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default biome for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type Biome for" + minecraftKey);
}
}
}
@Test
public void testBukkitToMinecraft() {
for (Biome biome : Biome.values()) {

48
src/test/java/org/bukkit/FluidTest.java

@ -1,48 +0,0 @@
package org.bukkit;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.level.material.FluidType;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class FluidTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Fluid.class.getFields()) {
if (field.getType() != Fluid.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No Fluid for field name " + name, Registry.FLUID.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (FluidType fluidType : BuiltInRegistries.FLUID) {
MinecraftKey minecraftKey = BuiltInRegistries.FLUID.getKey(fluidType);
try {
Fluid fluid = (Fluid) Fluid.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(fluid.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default fluid for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type fluid for" + minecraftKey);
}
}
}
}

47
src/test/java/org/bukkit/GameEventTest.java

@ -1,47 +0,0 @@
package org.bukkit;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class GameEventTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : GameEvent.class.getFields()) {
if (field.getType() != GameEvent.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No GameEvent for field name " + name, Registry.GAME_EVENT.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (net.minecraft.world.level.gameevent.GameEvent gameEvent : BuiltInRegistries.GAME_EVENT) {
MinecraftKey minecraftKey = BuiltInRegistries.GAME_EVENT.getKey(gameEvent);
try {
GameEvent game = (GameEvent) GameEvent.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(game.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default game event for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type game event for" + minecraftKey);
}
}
}
}

48
src/test/java/org/bukkit/MusicInstrumentTest.java

@ -1,48 +0,0 @@
package org.bukkit;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.item.Instrument;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class MusicInstrumentTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : MusicInstrument.class.getFields()) {
if (field.getType() != MusicInstrument.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No MusicInstrument for field name " + name, Registry.INSTRUMENT.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (Instrument instrument : BuiltInRegistries.INSTRUMENT) {
MinecraftKey minecraftKey = BuiltInRegistries.INSTRUMENT.getKey(instrument);
try {
MusicInstrument game = (MusicInstrument) MusicInstrument.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(game.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default music instrument for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type music instrument for" + minecraftKey);
}
}
}
}

38
src/test/java/org/bukkit/ParticleTest.java

@ -1,14 +1,10 @@
package org.bukkit;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import org.bukkit.block.BlockType;
import org.bukkit.block.data.BlockData;
import org.bukkit.craftbukkit.CraftParticle;
import org.bukkit.craftbukkit.block.data.CraftBlockData;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.ItemType;
import org.bukkit.material.MaterialData;
@ -18,40 +14,6 @@ import org.junit.Test;
public class ParticleTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Particle.class.getFields()) {
if (field.getType() != Particle.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No particle for field name " + name, Registry.PARTICLE_TYPE.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (net.minecraft.core.particles.Particle particleType : BuiltInRegistries.PARTICLE_TYPE) {
MinecraftKey minecraftKey = BuiltInRegistries.PARTICLE_TYPE.getKey(particleType);
try {
Particle particle = (Particle) Particle.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(particle.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default particle for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type particle for" + minecraftKey);
}
}
}
@Test
public void verifyMapping() {
for (Particle bukkit : Particle.values()) {

156
src/test/java/org/bukkit/RegistryConstantsTest.java

@ -8,15 +8,101 @@ import net.minecraft.core.IRegistry;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.resources.ResourceKey;
import org.bukkit.attribute.Attribute;
import org.bukkit.block.Biome;
import org.bukkit.block.BlockType;
import org.bukkit.block.banner.PatternType;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Cat;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Frog;
import org.bukkit.entity.Villager;
import org.bukkit.generator.structure.Structure;
import org.bukkit.generator.structure.StructureType;
import org.bukkit.inventory.ItemType;
import org.bukkit.inventory.meta.trim.TrimMaterial;
import org.bukkit.inventory.meta.trim.TrimPattern;
import org.bukkit.potion.PotionEffectType;
import org.bukkit.potion.PotionType;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class RegistryConstantsTest extends AbstractTestingBase {
@Test
public void testStructure() {
this.testExcessConstants(Structure.class, Registry.STRUCTURE);
this.testMissingConstants(Structure.class, Registries.STRUCTURE);
}
@Test
public void testStructureType() {
this.testExcessConstants(StructureType.class, Registry.STRUCTURE_TYPE);
this.testMissingConstants(StructureType.class, Registries.STRUCTURE_TYPE);
}
@Test
public void testBiome() {
this.testExcessConstants(Biome.class, Registry.BIOME);
this.testMissingConstants(Biome.class, Registries.BIOME);
}
@Test
public void testArt() {
this.testExcessConstants(Art.class, Registry.ART);
this.testMissingConstants(Art.class, Registries.PAINTING_VARIANT);
}
@Test
public void testFluid() {
this.testExcessConstants(Fluid.class, Registry.FLUID);
this.testMissingConstants(Fluid.class, Registries.FLUID);
}
@Test
public void testEntityType() {
this.testExcessConstants(EntityType.class, Registry.ENTITY_TYPE);
this.testMissingConstants(EntityType.class, Registries.ENTITY_TYPE);
}
@Test
public void testAttribute() {
this.testExcessConstants(Attribute.class, Registry.ATTRIBUTE);
this.testMissingConstants(Attribute.class, Registries.ATTRIBUTE);
}
@Test
public void testVillagerType() {
this.testExcessConstants(Villager.Type.class, Registry.VILLAGER_TYPE);
this.testMissingConstants(Villager.Type.class, Registries.VILLAGER_TYPE);
}
@Test
public void testVillagerProfession() {
this.testExcessConstants(Villager.Profession.class, Registry.VILLAGER_PROFESSION);
this.testMissingConstants(Villager.Profession.class, Registries.VILLAGER_PROFESSION);
}
@Test
public void testPotionEffectType() {
this.testExcessConstants(PotionEffectType.class, Registry.POTION_EFFECT_TYPE);
this.testMissingConstants(PotionEffectType.class, Registries.MOB_EFFECT);
}
@Test
public void testEnchantment() {
this.testExcessConstants(Enchantment.class, Registry.ENCHANTMENT);
this.testMissingConstants(Enchantment.class, Registries.ENCHANTMENT);
}
@Test
public void testSound() {
this.testExcessConstants(Sound.class, Registry.SOUNDS);
this.testMissingConstants(Sound.class, Registries.SOUND_EVENT);
}
@Test
public void testTrimMaterial() {
this.testExcessConstants(TrimMaterial.class, Registry.TRIM_MATERIAL);
@ -29,6 +115,60 @@ public class RegistryConstantsTest extends AbstractTestingBase {
this.testMissingConstants(TrimPattern.class, Registries.TRIM_PATTERN);
}
@Test
public void testBlockType() {
this.testExcessConstants(BlockType.class, Registry.BLOCK);
this.testMissingConstants(BlockType.class, Registries.BLOCK);
}
@Test
public void testItemType() {
this.testExcessConstants(ItemType.class, Registry.ITEM);
this.testMissingConstants(ItemType.class, Registries.ITEM);
}
@Test
public void testFrogVariant() {
this.testExcessConstants(Frog.Variant.class, Registry.FROG_VARIANT);
this.testMissingConstants(Frog.Variant.class, Registries.FROG_VARIANT);
}
@Test
public void testCatType() {
this.testExcessConstants(Cat.Type.class, Registry.CAT_TYPE);
this.testMissingConstants(Cat.Type.class, Registries.CAT_VARIANT);
}
@Test
public void testPatternType() {
this.testExcessConstants(PatternType.class, Registry.BANNER_PATTERN);
this.testMissingConstants(PatternType.class, Registries.BANNER_PATTERN);
}
@Test
public void testParticle() {
this.testExcessConstants(Particle.class, Registry.PARTICLE_TYPE);
this.testMissingConstants(Particle.class, Registries.PARTICLE_TYPE);
}
@Test
public void testPotionType() {
this.testExcessConstants(PotionType.class, Registry.POTION);
this.testMissingConstants(PotionType.class, Registries.POTION);
}
@Test
public void testGameEvent() {
this.testExcessConstants(GameEvent.class, Registry.GAME_EVENT);
this.testMissingConstants(GameEvent.class, Registries.GAME_EVENT);
}
@Test
public void testMusicInstrument() {
this.testExcessConstants(MusicInstrument.class, Registry.INSTRUMENT);
this.testMissingConstants(MusicInstrument.class, Registries.INSTRUMENT);
}
private <T extends Keyed> void testExcessConstants(Class<T> clazz, Registry<T> registry) {
List<NamespacedKey> excessKeys = new ArrayList<>();
@ -37,8 +177,18 @@ public class RegistryConstantsTest extends AbstractTestingBase {
continue;
}
String name = field.getName();
NamespacedKey key = NamespacedKey.fromString(name.toLowerCase());
// Old EntityType#UNKNOWN and Biome#CUSTOM
if (field.getName().equals("UNKNOWN") || field.getName().equals("CUSTOM")) {
continue;
}
NamespacedKey key = null;
try {
key = ((Keyed) field.get(null)).getKey();
} catch (IllegalAccessException e) {
Assert.fail(e.getMessage());
}
if (registry.get(key) == null) {
excessKeys.add(key);
}
@ -57,7 +207,7 @@ public class RegistryConstantsTest extends AbstractTestingBase {
try {
@SuppressWarnings("unchecked")
T bukkitObject = (T) clazz.getField(minecraftKey.getPath().toUpperCase()).get(null);
T bukkitObject = (T) clazz.getField(minecraftKey.getPath().toUpperCase().replace(".", "_")).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(bukkitObject.getKey()));
} catch (NoSuchFieldException e) {

43
src/test/java/org/bukkit/SoundTest.java

@ -2,57 +2,14 @@ package org.bukkit;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.sounds.SoundEffect;
import org.bukkit.craftbukkit.CraftSound;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class SoundTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Sound.class.getFields()) {
if (field.getType() != Sound.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
try {
NamespacedKey key = ((Keyed) field.get(null)).getKey();
Assert.assertNotNull("No Sound for field name " + field.getName(), Registry.SOUNDS.get(key));
} catch (IllegalAccessException e) {
Assert.fail("Can't get object for Bukkit field " + field.getName());
}
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (SoundEffect soundEffect : BuiltInRegistries.SOUND_EVENT) {
MinecraftKey minecraftKey = BuiltInRegistries.SOUND_EVENT.getKey(soundEffect);
try {
Sound sound = (Sound) Sound.class.getField(minecraftKey.getPath().toUpperCase().replace(".", "_")).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(sound.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default sound for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type sound for" + minecraftKey);
}
}
}
@Test
public void testGetSound() {
for (Sound sound : Sound.values()) {

52
src/test/java/org/bukkit/block/BlockTypeTest.java

@ -1,52 +0,0 @@
package org.bukkit.block;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.level.block.Block;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class BlockTypeTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : BlockType.class.getFields()) {
if (field.getType() != BlockType.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No BlockType for field name " + name, Registry.BLOCK.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (Block block : BuiltInRegistries.BLOCK) {
MinecraftKey minecraftKey = BuiltInRegistries.BLOCK.getKey(block);
try {
Field field = BlockType.class.getField(minecraftKey.getPath().toUpperCase());
Assert.assertSame("No Bukkit default blockType for " + minecraftKey, BlockType.class, field.getType());
BlockType<?> blockType = (BlockType<?>) field.get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(blockType.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default blockType for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type blockType for " + minecraftKey);
}
}
}
}

50
src/test/java/org/bukkit/block/banner/PatternTypeTest.java

@ -1,50 +0,0 @@
package org.bukkit.block.banner;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.level.block.entity.EnumBannerPatternType;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class PatternTypeTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : PatternType.class.getFields()) {
if (field.getType() != PatternType.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
org.junit.Assert.assertNotNull("No pattern type for field name " + name, Registry.BANNER_PATTERN.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (EnumBannerPatternType bannerPatternType : BuiltInRegistries.BANNER_PATTERN) {
MinecraftKey minecraftKey = BuiltInRegistries.BANNER_PATTERN.getKey(bannerPatternType);
try {
PatternType patternType = (PatternType) PatternType.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
org.junit.Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(patternType.getKey()));
} catch (NoSuchFieldException e) {
org.junit.Assert.fail("No Bukkit default pattern type for " + minecraftKey);
} catch (IllegalAccessException e) {
org.junit.Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type pattern type for" + minecraftKey);
}
}
}
}

44
src/test/java/org/bukkit/craftbukkit/attribute/AttributeTest.java

@ -1,59 +1,15 @@
package org.bukkit.craftbukkit.attribute;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.entity.ai.attributes.AttributeBase;
import org.bukkit.Keyed;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.attribute.Attribute;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class AttributeTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Attribute.class.getFields()) {
if (field.getType() != Attribute.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
try {
NamespacedKey key = ((Keyed) field.get(null)).getKey();
Assert.assertNotNull("No Attribute for field name " + field.getName(), Registry.ATTRIBUTE.get(key));
} catch (IllegalAccessException e) {
Assert.fail("Can't get object for Bukkit field " + field.getName());
}
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (AttributeBase attributeBase : BuiltInRegistries.ATTRIBUTE) {
MinecraftKey minecraftKey = BuiltInRegistries.ATTRIBUTE.getKey(attributeBase);
try {
Attribute attribute = (Attribute) Attribute.class.getField(minecraftKey.getPath().toUpperCase().replace(".", "_")).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(attribute.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default attribute for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type attribute for" + minecraftKey);
}
}
}
@Test
public void testToBukkit() {
for (MinecraftKey nms : BuiltInRegistries.ATTRIBUTE.keySet()) {

50
src/test/java/org/bukkit/entity/CatTypeTest.java

@ -1,50 +0,0 @@
package org.bukkit.entity;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.entity.animal.CatVariant;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class CatTypeTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Cat.Type.class.getFields()) {
if (field.getType() != Cat.Type.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No cat type for field name " + name, Registry.CAT_TYPE.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (CatVariant catVariant : BuiltInRegistries.CAT_VARIANT) {
MinecraftKey minecraftKey = BuiltInRegistries.CAT_VARIANT.getKey(catVariant);
try {
Cat.Type type = (Cat.Type) Cat.Type.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(type.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default cat type for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type cat type for" + minecraftKey);
}
}
}
}

43
src/test/java/org/bukkit/entity/EntityTypesTest.java

@ -1,61 +1,18 @@
package org.bukkit.entity;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.entity.EntityTypes;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class EntityTypesTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : EntityType.class.getFields()) {
if (field.getType() != EntityType.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
if (name.equals("UNKNOWN")) {
continue;
}
Assert.assertNotNull("No entityType for field name " + name, Registry.ENTITY_TYPE.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (EntityTypes<?> entityTypes : BuiltInRegistries.ENTITY_TYPE) {
MinecraftKey minecraftKey = BuiltInRegistries.ENTITY_TYPE.getKey(entityTypes);
try {
EntityType<?> entityType = (EntityType<?>) EntityType.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(entityType.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default entityType for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type entityType for" + minecraftKey);
}
}
}
@Test
public void testClasses() {
for (EntityType<?> entityType : Registry.ENTITY_TYPE) {

50
src/test/java/org/bukkit/entity/FrogVariantTest.java

@ -1,50 +0,0 @@
package org.bukkit.entity;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.entity.animal.FrogVariant;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class FrogVariantTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Frog.Variant.class.getFields()) {
if (field.getType() != Frog.Variant.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No frog variant for field name " + name, Registry.FROG_VARIANT.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (FrogVariant frogVariant : BuiltInRegistries.FROG_VARIANT) {
MinecraftKey minecraftKey = BuiltInRegistries.FROG_VARIANT.getKey(frogVariant);
try {
Frog.Variant variant = (Frog.Variant) Frog.Variant.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(variant.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default frog variant for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type frog variant for" + minecraftKey);
}
}
}
}

50
src/test/java/org/bukkit/entity/VillagerProfessionTest.java

@ -1,50 +0,0 @@
package org.bukkit.entity;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.entity.npc.VillagerProfession;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class VillagerProfessionTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Villager.Profession.class.getFields()) {
if (field.getType() != Villager.Profession.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No villager profession for field name " + name, Registry.VILLAGER_PROFESSION.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (VillagerProfession villagerProfession : BuiltInRegistries.VILLAGER_PROFESSION) {
MinecraftKey minecraftKey = BuiltInRegistries.VILLAGER_PROFESSION.getKey(villagerProfession);
try {
Villager.Profession profession = (Villager.Profession) Villager.Profession.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(profession.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default villager profession for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type villager profession for" + minecraftKey);
}
}
}
}

50
src/test/java/org/bukkit/entity/VillagerTypeTest.java

@ -1,50 +0,0 @@
package org.bukkit.entity;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.entity.npc.VillagerType;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class VillagerTypeTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Villager.Type.class.getFields()) {
if (field.getType() != Villager.Type.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No villager type for field name " + name, Registry.VILLAGER_TYPE.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (VillagerType villagerType : BuiltInRegistries.VILLAGER_TYPE) {
MinecraftKey minecraftKey = BuiltInRegistries.VILLAGER_TYPE.getKey(villagerType);
try {
Villager.Type type = (Villager.Type) Villager.Type.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(type.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default villager type for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type villager type for" + minecraftKey);
}
}
}
}

51
src/test/java/org/bukkit/generator/structure/StructureTest.java

@ -1,51 +0,0 @@
package org.bukkit.generator.structure;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.IRegistry;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.MinecraftKey;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class StructureTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : Structure.class.getFields()) {
if (field.getType() != Structure.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No structure for field name " + name, Registry.STRUCTURE.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
IRegistry<net.minecraft.world.level.levelgen.structure.Structure> structureBuiltInRegistries = AbstractTestingBase.REGISTRY_CUSTOM.registryOrThrow(Registries.STRUCTURE);
for (net.minecraft.world.level.levelgen.structure.Structure structure : structureBuiltInRegistries) {
MinecraftKey minecraftKey = structureBuiltInRegistries.getKey(structure);
try {
Structure bukkit = (Structure) Structure.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(bukkit.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default structure for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type structure for" + minecraftKey);
}
}
}
}

49
src/test/java/org/bukkit/generator/structure/StructureTypeTest.java

@ -1,49 +0,0 @@
package org.bukkit.generator.structure;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class StructureTypeTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : StructureType.class.getFields()) {
if (field.getType() != StructureType.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No structure type for field name " + name, Registry.STRUCTURE_TYPE.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (net.minecraft.world.level.levelgen.structure.StructureType<?> structureType : BuiltInRegistries.STRUCTURE_TYPE) {
MinecraftKey minecraftKey = BuiltInRegistries.STRUCTURE_TYPE.getKey(structureType);
try {
StructureType bukkit = (StructureType) StructureType.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(bukkit.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default structure type for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type structure type for" + minecraftKey);
}
}
}
}

53
src/test/java/org/bukkit/inventory/ItemTypeTest.java

@ -1,53 +0,0 @@
package org.bukkit.inventory;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.IRegistry;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.item.Item;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class ItemTypeTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : ItemType.class.getFields()) {
if (field.getType() != ItemType.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No ItemType for field name " + name, Registry.ITEM.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (Item item : BuiltInRegistries.ITEM) {
MinecraftKey minecraftKey = BuiltInRegistries.ITEM.getKey(item);
try {
Field field = ItemType.class.getField(minecraftKey.getPath().toUpperCase());
Assert.assertSame("No Bukkit default itemType for " + minecraftKey, ItemType.class, field.getType());
ItemType itemType = (ItemType) field.get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(itemType.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default itemType for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type itemType for " + minecraftKey);
}
}
}
}

41
src/test/java/org/bukkit/potion/PotionTest.java

@ -1,9 +1,6 @@
package org.bukkit.potion;
import static org.junit.Assert.*;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -12,49 +9,11 @@ import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.effect.MobEffect;
import net.minecraft.world.effect.MobEffectList;
import net.minecraft.world.item.alchemy.PotionRegistry;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.support.AbstractTestingBase;
import org.junit.Assert;
import org.junit.Test;
public class PotionTest extends AbstractTestingBase {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : PotionEffectType.class.getFields()) {
if (field.getType() != PotionEffectType.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No potionEffectType for field name " + name, Registry.POTION_EFFECT_TYPE.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (MobEffectList mobEffectList : BuiltInRegistries.MOB_EFFECT) {
MinecraftKey minecraftKey = BuiltInRegistries.MOB_EFFECT.getKey(mobEffectList);
try {
PotionEffectType potionEffectType = (PotionEffectType) PotionEffectType.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(potionEffectType.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default potionEffectType for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type potionEffectType for" + minecraftKey);
}
}
}
@Test
public void testEffectCompleteness() throws Throwable {
Map<PotionType, String> effects = new HashMap<>();

50
src/test/java/org/bukkit/potion/PotionTypeTest.java

@ -1,50 +0,0 @@
package org.bukkit.potion;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.MinecraftKey;
import net.minecraft.world.item.alchemy.PotionRegistry;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.junit.Assert;
import org.junit.Test;
public class PotionTypeTest {
@Test
public void testBukkitToMinecraftFieldName() {
for (Field field : PotionType.class.getFields()) {
if (field.getType() != PotionType.class) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
continue;
}
String name = field.getName();
Assert.assertNotNull("No PotionType for field name " + name, Registry.POTION.get(NamespacedKey.fromString(name.toLowerCase())));
}
}
@Test
public void testMinecraftToBukkitFieldName() {
for (PotionRegistry potionRegistry : BuiltInRegistries.POTION) {
MinecraftKey minecraftKey = BuiltInRegistries.POTION.getKey(potionRegistry);
try {
PotionType potionType = (PotionType) PotionType.class.getField(minecraftKey.getPath().toUpperCase()).get(null);
Assert.assertEquals("Keys are not the same for " + minecraftKey, minecraftKey, CraftNamespacedKey.toMinecraft(potionType.getKey()));
} catch (NoSuchFieldException e) {
Assert.fail("No Bukkit default potion type for " + minecraftKey);
} catch (IllegalAccessException e) {
Assert.fail("Bukkit field is not access able for " + minecraftKey);
} catch (ClassCastException e) {
Assert.fail("Bukkit field is not of type potion for" + minecraftKey);
}
}
}
}