Reformat with Google code style and enforce Checkstyle.

Fixes #125

native/src/test/java/com/velocitypowered/natives/compression/VelocityCompressorTest.java

@@ -1,65 +1,66 @@
 package com.velocitypowered.natives.compression;
 
-import com.velocitypowered.natives.util.Natives;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufUtil;
-import io.netty.buffer.Unpooled;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.EnabledOnOs;
-
-import java.util.Random;
-import java.util.zip.DataFormatException;
-import java.util.zip.Deflater;
-
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.junit.jupiter.api.condition.OS.LINUX;
 import static org.junit.jupiter.api.condition.OS.MAC;
 
+import com.velocitypowered.natives.util.Natives;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.Unpooled;
+import java.util.Random;
+import java.util.zip.DataFormatException;
+import java.util.zip.Deflater;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledOnOs;
+
 class VelocityCompressorTest {
-    @BeforeAll
-    static void checkNatives() {
-        Natives.compressor.getLoadedVariant();
+
+  @BeforeAll
+  static void checkNatives() {
+    Natives.compressor.getLoadedVariant();
+  }
+
+  @Test
+  @EnabledOnOs({MAC, LINUX})
+  void nativeIntegrityCheck() throws DataFormatException {
+    VelocityCompressor compressor = Natives.compressor.get().create(Deflater.DEFAULT_COMPRESSION);
+    if (compressor instanceof JavaVelocityCompressor) {
+      compressor.dispose();
+      fail("Loaded regular compressor");
     }
+    check(compressor);
+  }
 
-    @Test
-    @EnabledOnOs({ MAC, LINUX })
-    void nativeIntegrityCheck() throws DataFormatException {
-        VelocityCompressor compressor = Natives.compressor.get().create(Deflater.DEFAULT_COMPRESSION);
-        if (compressor instanceof JavaVelocityCompressor) {
-            compressor.dispose();
-            fail("Loaded regular compressor");
-        }
-        check(compressor);
-    }
-
-    @Test
-    void javaIntegrityCheck() throws DataFormatException {
-        VelocityCompressor compressor = JavaVelocityCompressor.FACTORY.create(Deflater.DEFAULT_COMPRESSION);
-        check(compressor);
-    }
-
-    private void check(VelocityCompressor compressor) throws DataFormatException {
-        ByteBuf source = Unpooled.directBuffer();
-        ByteBuf dest = Unpooled.directBuffer();
-        ByteBuf decompressed = Unpooled.directBuffer();
-
-        Random random = new Random(1);
-        byte[] randomBytes = new byte[1 << 16];
-        random.nextBytes(randomBytes);
-        source.writeBytes(randomBytes);
-
-        try {
-            compressor.deflate(source, dest);
-            compressor.inflate(dest, decompressed);
-            source.readerIndex(0);
-            assertTrue(ByteBufUtil.equals(source, decompressed));
-        } finally {
-            source.release();
-            dest.release();
-            decompressed.release();
-            compressor.dispose();
-        }
+  @Test
+  void javaIntegrityCheck() throws DataFormatException {
+    VelocityCompressor compressor = JavaVelocityCompressor.FACTORY
+        .create(Deflater.DEFAULT_COMPRESSION);
+    check(compressor);
+  }
+
+  private void check(VelocityCompressor compressor) throws DataFormatException {
+    ByteBuf source = Unpooled.directBuffer();
+    ByteBuf dest = Unpooled.directBuffer();
+    ByteBuf decompressed = Unpooled.directBuffer();
+
+    Random random = new Random(1);
+    byte[] randomBytes = new byte[1 << 16];
+    random.nextBytes(randomBytes);
+    source.writeBytes(randomBytes);
+
+    try {
+      compressor.deflate(source, dest);
+      compressor.inflate(dest, decompressed);
+      source.readerIndex(0);
+      assertTrue(ByteBufUtil.equals(source, decompressed));
+    } finally {
+      source.release();
+      dest.release();
+      decompressed.release();
+      compressor.dispose();
     }
+  }
 }

native/src/test/java/com/velocitypowered/natives/encryption/VelocityCipherTest.java

@@ -1,71 +1,71 @@
 package com.velocitypowered.natives.encryption;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
 import com.velocitypowered.natives.util.Natives;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufUtil;
 import io.netty.buffer.Unpooled;
+import java.security.GeneralSecurityException;
+import java.util.Random;
+import javax.crypto.spec.SecretKeySpec;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
-import javax.crypto.spec.SecretKeySpec;
-import java.security.GeneralSecurityException;
-import java.util.Random;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
 class VelocityCipherTest {
-    private static final int ENCRYPT_DATA_SIZE = 1 << 16;
 
-    @BeforeAll
-    static void checkNatives() {
-        Natives.cipher.getLoadedVariant();
+  private static final int ENCRYPT_DATA_SIZE = 1 << 16;
+
+  @BeforeAll
+  static void checkNatives() {
+    Natives.cipher.getLoadedVariant();
+  }
+
+  @Test
+  @Disabled
+  void nativeIntegrityCheck() throws GeneralSecurityException {
+    VelocityCipherFactory factory = Natives.cipher.get();
+    if (factory == JavaVelocityCipher.FACTORY) {
+      fail("Loaded regular compressor");
     }
+    check(factory);
+  }
 
-    @Test
-    @Disabled
-    void nativeIntegrityCheck() throws GeneralSecurityException {
-        VelocityCipherFactory factory = Natives.cipher.get();
-        if (factory == JavaVelocityCipher.FACTORY) {
-            fail("Loaded regular compressor");
-        }
-        check(factory);
-    }
-
-    @Test
-    void javaIntegrityCheck() throws GeneralSecurityException {
-        check(JavaVelocityCipher.FACTORY);
-    }
-
-    private void check(VelocityCipherFactory factory) throws GeneralSecurityException {
-        // Generate a random 16-byte key.
-        Random random = new Random(1);
-        byte[] key = new byte[16];
-        random.nextBytes(key);
-
-        VelocityCipher decrypt = factory.forDecryption(new SecretKeySpec(key, "AES"));
-        VelocityCipher encrypt = factory.forEncryption(new SecretKeySpec(key, "AES"));
-
-        ByteBuf source = Unpooled.directBuffer(ENCRYPT_DATA_SIZE);
-        ByteBuf dest = Unpooled.directBuffer(ENCRYPT_DATA_SIZE);
-        ByteBuf decryptionBuf = Unpooled.directBuffer(ENCRYPT_DATA_SIZE);
-
-        byte[] randomBytes = new byte[ENCRYPT_DATA_SIZE];
-        random.nextBytes(randomBytes);
-        source.writeBytes(randomBytes);
-
-        try {
-            encrypt.process(source, dest);
-            decrypt.process(dest, decryptionBuf);
-            source.readerIndex(0);
-            assertTrue(ByteBufUtil.equals(source, decryptionBuf));
-        } finally {
-            source.release();
-            dest.release();
-            decryptionBuf.release();
-            decrypt.dispose();
-            encrypt.dispose();
-        }
+  @Test
+  void javaIntegrityCheck() throws GeneralSecurityException {
+    check(JavaVelocityCipher.FACTORY);
+  }
+
+  private void check(VelocityCipherFactory factory) throws GeneralSecurityException {
+    // Generate a random 16-byte key.
+    Random random = new Random(1);
+    byte[] key = new byte[16];
+    random.nextBytes(key);
+
+    VelocityCipher decrypt = factory.forDecryption(new SecretKeySpec(key, "AES"));
+    VelocityCipher encrypt = factory.forEncryption(new SecretKeySpec(key, "AES"));
+
+    ByteBuf source = Unpooled.directBuffer(ENCRYPT_DATA_SIZE);
+    ByteBuf dest = Unpooled.directBuffer(ENCRYPT_DATA_SIZE);
+    ByteBuf decryptionBuf = Unpooled.directBuffer(ENCRYPT_DATA_SIZE);
+
+    byte[] randomBytes = new byte[ENCRYPT_DATA_SIZE];
+    random.nextBytes(randomBytes);
+    source.writeBytes(randomBytes);
+
+    try {
+      encrypt.process(source, dest);
+      decrypt.process(dest, decryptionBuf);
+      source.readerIndex(0);
+      assertTrue(ByteBufUtil.equals(source, decryptionBuf));
+    } finally {
+      source.release();
+      dest.release();
+      decryptionBuf.release();
+      decrypt.dispose();
+      encrypt.dispose();
     }
+  }
 }