optimize test performance

src/integration-test/kotlin/de/bixilon/minosoft/data/physics/PhysicsTestUtil.kt

@@ -36,19 +36,23 @@ import de.bixilon.minosoft.util.KUtil.matches
 import de.bixilon.minosoft.util.KUtil.startInit
 import org.testng.Assert
 import java.util.*
+import kotlin.reflect.jvm.javaField
 
 object PhysicsTestUtil {
     const val MATCH_EXACTLY = true
     val VALUE_MARGIN = if (MATCH_EXACTLY) 0.0 else DoubleUtil.DEFAULT_MARGIN
 
+    private val PLAYER_ATTRIBUTES = LocalPlayerEntity::attributes.javaField!!
+    private val CONNECTION_PLAYER = PlayConnection::player.javaField!!
+    private val CONNECTION_CAMERA = PlayConnection::camera.javaField!!
 
-    fun createPlayer(connection: PlayConnection = createConnection()): LocalPlayerEntity {
+
-        connection.world.dimension::skyLight.forceSet(false)
+    fun createPlayer(connection: PlayConnection = createConnection(light = false)): LocalPlayerEntity {
         val player = LocalPlayerEntity(connection.account, connection, SignatureKeyManagement(connection, connection.account))
-        player::attributes.forceSet(EntityAttributes(player.type.attributes))
+        PLAYER_ATTRIBUTES.forceSet(player, EntityAttributes(player.type.attributes))
         player.startInit()
-        connection::player.forceSet(player)
+        CONNECTION_PLAYER.forceSet(connection, player)
-        connection::camera.forceSet(ConnectionCamera(connection))
+        CONNECTION_CAMERA.forceSet(connection, ConnectionCamera(connection))
         connection.camera.init()
         connection.world.entities.remove(0)
         connection.world.entities.add(0, null, player)

src/integration-test/kotlin/de/bixilon/minosoft/gui/rendering/models/baked/BakedModelTestUtil.kt

@@ -25,23 +25,27 @@ import de.bixilon.minosoft.gui.rendering.models.block.state.baked.BakedModel
 import de.bixilon.minosoft.gui.rendering.system.base.texture.TextureManager
 import de.bixilon.minosoft.gui.rendering.system.base.texture.texture.memory.MemoryTexture
 import de.bixilon.minosoft.gui.rendering.textures.TextureUtil.texture
-import de.bixilon.minosoft.protocol.network.connection.play.ConnectionTestUtil
+import de.bixilon.minosoft.protocol.network.connection.play.ConnectionTestUtil.createConnection
 import de.bixilon.minosoft.util.KUtil.toResourceLocation
 import org.testng.Assert
 import kotlin.math.abs
 
 object BakedModelTestUtil {
     private val texture = Minosoft::class.java.getResourceAsStream("/assets/minosoft/textures/debug.png")!!.readAllBytes()
+    private val connection by lazy { createConnection() }
+    private val rendering by lazy {
+        val rendering = Rendering(connection)
+        rendering.context.textures::debugTexture.forceSet(MemoryTexture(Vec2i(0, 0)))
+        return@lazy rendering
+    }
+
 
     fun createTextureManager(vararg names: String): TextureManager {
-        val connection = ConnectionTestUtil.createConnection()
         val assets = MemoryAssetsManager()
         for (name in names) {
             assets.push(name.toResourceLocation().texture(), texture)
         }
         connection::assetsManager.forceSet(assets.box())
-        val rendering = Rendering(connection)
-        rendering.context.textures::debugTexture.forceSet(MemoryTexture(Vec2i(0, 0)))
 
         return rendering.context.textures
     }

src/integration-test/kotlin/de/bixilon/minosoft/protocol/network/connection/play/ConnectionTestUtil.kt

@@ -35,10 +35,12 @@ import de.bixilon.minosoft.protocol.versions.Versions
 import de.bixilon.minosoft.tags.TagManager
 import de.bixilon.minosoft.test.IT
 import de.bixilon.minosoft.test.IT.FALLBACK_TAGS
+import de.bixilon.minosoft.test.IT.OBJENESIS
 import de.bixilon.minosoft.test.IT.reference
 import de.bixilon.minosoft.test.ITUtil
 import de.bixilon.minosoft.util.KUtil.startInit
 import java.util.concurrent.atomic.AtomicInteger
+import kotlin.reflect.jvm.javaField
 
 
 object ConnectionTestUtil {
@@ -48,28 +50,47 @@ object ConnectionTestUtil {
         reference()
     }
 
+    private val LANGUAGE = PlayConnection::language.javaField!!
+    private val SEQUENCE = PlayConnection::sequence.javaField!!
+    private val ACCOUNT = PlayConnection::account.javaField!!
+    private val VERSION = PlayConnection::version.javaField!!
+    private val REGISTRIES = PlayConnection::registries.javaField!!
+    private val WORLD = PlayConnection::world.javaField!!
+    private val PLAYER = PlayConnection::player.javaField!!
+    private val NETWORK = PlayConnection::network.javaField!!
+    private val EVENTS = PlayConnection::events.javaField!!
+    private val PROFILES = PlayConnection::profiles.javaField!!
+    private val ASSETS_MANAGER = PlayConnection::assetsManager.javaField!!
+    private val STATE = PlayConnection::state.javaField!!
+    private val TAGS = PlayConnection::tags.javaField!!
+    private val LEGACY_TAGS = PlayConnection::legacyTags.javaField!!
+    private val CAMERA = PlayConnection::camera.javaField!!
+
+    private val language = LanguageList(mutableListOf())
+    private val signature = OBJENESIS.newInstance(SignatureKeyManagement::class.java)
+
 
     fun createConnection(worldSize: Int = 0, light: Boolean = false, version: String? = null): PlayConnection {
-        val connection = IT.OBJENESIS.newInstance(PlayConnection::class.java)
+        val connection = OBJENESIS.newInstance(PlayConnection::class.java)
-        connection::language.forceSet(LanguageList(mutableListOf()))
+        LANGUAGE.forceSet(connection, language)
         val version = if (version == null) IT.VERSION else Versions[version] ?: throw IllegalArgumentException("Can not find version: $version")
-        connection::sequence.forceSet(AtomicInteger(1))
+        SEQUENCE.forceSet(connection, AtomicInteger(1))
-        connection::account.forceSet(TestAccount)
+        ACCOUNT.forceSet(connection, TestAccount)
-        connection::version.forceSet(version)
+        VERSION.forceSet(connection, version)
-        connection::registries.forceSet(Registries())
+        REGISTRIES.forceSet(connection, Registries())
         connection.registries.updateFlattened(version.flattened)
         connection.registries.parent = if (version == IT.VERSION) IT.REGISTRIES else ITUtil.loadRegistries(version)
-        connection::world.forceSet(createWorld(connection, light, (worldSize * 2 + 1).pow(2)))
+        WORLD.forceSet(connection, createWorld(connection, light, (worldSize * 2 + 1).pow(2)))
-        connection::player.forceSet(LocalPlayerEntity(connection.account, connection, SignatureKeyManagement(connection, TestAccount)))
+        PLAYER.forceSet(connection, LocalPlayerEntity(connection.account, connection, signature))
         connection.player.startInit()
-        connection::network.forceSet(TestNetwork())
+        NETWORK.forceSet(connection, TestNetwork())
-        connection::events.forceSet(EventMaster())
+        EVENTS.forceSet(connection, EventMaster())
-        connection::profiles.forceSet(profiles)
+        PROFILES.forceSet(connection, profiles)
-        connection::assetsManager.forceSet(ConnectionAssetsManager(AssetsManagerProperties(PackProperties(version.packFormat))))
+        ASSETS_MANAGER.forceSet(connection, ConnectionAssetsManager(AssetsManagerProperties(PackProperties(version.packFormat))))
-        connection::state.forceSet(DataObserver(PlayConnectionStates.PLAYING))
+        STATE.forceSet(connection, DataObserver(PlayConnectionStates.PLAYING))
-        connection::tags.forceSet(TagManager())
+        TAGS.forceSet(connection, TagManager())
-        connection::legacyTags.forceSet(FALLBACK_TAGS)
+        LEGACY_TAGS.forceSet(connection, FALLBACK_TAGS)
-        connection::camera.forceSet(ConnectionCamera(connection))
+        CAMERA.forceSet(connection, ConnectionCamera(connection))
         connection.camera.init()
         if (worldSize > 0) {
             connection.world.initialize(worldSize)