Add some unit tests

45 files changed, 1905 insertions, 32 deletions

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bc3588a..5f3cea9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,7 +16,12 @@ env:
 
 jobs:
   build-gradle:
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    runs-on: ${{ matrix.os }}
+
     steps:
       - name: Checkout repository
         uses: actions/checkout@v3
@@ -34,11 +39,12 @@ jobs:
       - name: Setup Gradle
         uses: gradle/gradle-build-action@v2
 
-      - name: Run build with Gradle wrapper
-        run: ./gradlew build
+      - name: Run build and tests with Gradle wrapper
+        run: ./gradlew test build
 
       - name: Upload all artifacts
         uses: actions/upload-artifact@v3
+        if: matrix.os == 'ubuntu-latest'
         with:
           name: jars
           path: |
diff --git a/build.gradle b/build.gradle
index 6dc9600..5d15ff2 100644
--- a/build.gradle
+++ b/build.gradle
@@ -2,6 +2,9 @@ plugins {
     id 'org.cadixdev.licenser' version '0.6.1' apply false
 }
 
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+
 allprojects {
     group = 'me.lucko'
     version = '1.10-SNAPSHOT'
@@ -25,6 +28,16 @@ subprojects {
         options.release = 8
     }
 
+    tasks.withType(Test).configureEach {
+        testLogging {
+            events = [TestLogEvent.PASSED, TestLogEvent.FAILED, TestLogEvent.SKIPPED]
+            exceptionFormat = TestExceptionFormat.FULL
+            showExceptions = true
+            showCauses = true
+            showStackTraces = true
+        }
+    }
+
     processResources {
         duplicatesStrategy = DuplicatesStrategy.INCLUDE
     }
diff --git a/spark-common/build.gradle b/spark-common/build.gradle
index 0eaf711..5bc4bda 100644
--- a/spark-common/build.gradle
+++ b/spark-common/build.gradle
@@ -20,17 +20,17 @@ dependencies {
         exclude(module: 'slf4j-api')
     }
 
-    api('net.kyori:adventure-api:4.13.1') {
+    api('net.kyori:adventure-api:4.17.0') {
         exclude(module: 'adventure-bom')
         exclude(module: 'checker-qual')
         exclude(module: 'annotations')
     }
-    api('net.kyori:adventure-text-serializer-gson:4.13.1') {
+    api('net.kyori:adventure-text-serializer-gson:4.17.0') {
         exclude(module: 'adventure-bom')
         exclude(module: 'adventure-api')
         exclude(module: 'gson')
     }
-    api('net.kyori:adventure-text-serializer-legacy:4.13.1') {
+    api('net.kyori:adventure-text-serializer-legacy:4.17.0') {
         exclude(module: 'adventure-bom')
         exclude(module: 'adventure-api')
     }
@@ -40,6 +40,22 @@ dependencies {
     compileOnly 'com.google.code.gson:gson:2.7'
     compileOnly 'com.google.guava:guava:19.0'
     compileOnly 'org.checkerframework:checker-qual:3.44.0'
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.11.0-M2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.11.0-M2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.11.0-M2'
+    // testImplementation "org.testcontainers:junit-jupiter:1.19.8"
+    // testImplementation 'org.mockito:mockito-core:5.12.0'
+    // testImplementation 'org.mockito:mockito-junit-jupiter:5.12.0'
+
+    testImplementation 'com.google.code.gson:gson:2.7'
+    testImplementation 'com.google.guava:guava:19.0'
+    testImplementation 'org.checkerframework:checker-qual:3.44.0'
+
+    testImplementation('net.kyori:adventure-text-serializer-ansi:4.17.0') {
+        exclude(module: 'adventure-bom')
+        exclude(module: 'adventure-api')
+    }
 }
 
 protobuf {
@@ -56,3 +72,8 @@ protobuf {
         }
     }
 }
+
+test {
+    useJUnitPlatform {}
+    systemProperty('net.kyori.ansi.colorLevel', 'indexed16')
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/SparkPlatform.java b/spark-common/src/main/java/me/lucko/spark/common/SparkPlatform.java
index 733510d..5e25d91 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/SparkPlatform.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/SparkPlatform.java
@@ -52,10 +52,12 @@ import me.lucko.spark.common.sampler.source.ClassSourceLookup;
 import me.lucko.spark.common.tick.TickHook;
 import me.lucko.spark.common.tick.TickReporter;
 import me.lucko.spark.common.util.BytebinClient;
-import me.lucko.spark.common.util.Configuration;
 import me.lucko.spark.common.util.SparkStaticLogger;
 import me.lucko.spark.common.util.TemporaryFiles;
 import me.lucko.spark.common.util.classfinder.ClassFinder;
+import me.lucko.spark.common.util.config.Configuration;
+import me.lucko.spark.common.util.config.FileConfiguration;
+import me.lucko.spark.common.util.config.RuntimeConfiguration;
 import me.lucko.spark.common.ws.TrustedKeyStore;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.event.ClickEvent;
@@ -71,6 +73,7 @@ import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.ReentrantLock;
@@ -121,7 +124,11 @@ public class SparkPlatform {
         SparkStaticLogger.setLogger(plugin::log);
 
         this.temporaryFiles = new TemporaryFiles(this.plugin.getPluginDirectory().resolve("tmp"));
-        this.configuration = new Configuration(this.plugin.getPluginDirectory().resolve("config.json"));
+        this.configuration = Configuration.combining(
+                RuntimeConfiguration.SYSTEM_PROPERTIES,
+                RuntimeConfiguration.ENVIRONMENT_VARIABLES,
+                new FileConfiguration(this.plugin.getPluginDirectory().resolve("config.json"))
+        );
 
         this.viewerUrl = this.configuration.getString("viewerUrl", "https://spark.lucko.me/");
         String bytebinUrl = this.configuration.getString("bytebinUrl", "https://spark-usercontent.lucko.me/");
@@ -330,7 +337,8 @@ public class SparkPlatform {
         return !getAvailableCommands(sender).isEmpty();
     }
 
-    public void executeCommand(CommandSender sender, String[] args) {
+    public CompletableFuture<Void> executeCommand(CommandSender sender, String[] args) {
+        CompletableFuture<Void> future = new CompletableFuture<>();
         AtomicReference<Thread> executorThread = new AtomicReference<>();
         AtomicReference<Thread> timeoutThread = new AtomicReference<>();
         AtomicBoolean completed = new AtomicBoolean(false);
@@ -341,9 +349,11 @@ public class SparkPlatform {
             this.commandExecuteLock.lock();
             try {
                 executeCommand0(sender, args);
+                future.complete(null);
             } catch (Exception e) {
                 this.plugin.log(Level.SEVERE, "Exception occurred whilst executing a spark command");
                 e.printStackTrace();
+                future.completeExceptionally(e);
             } finally {
                 this.commandExecuteLock.unlock();
                 executorThread.set(null);
@@ -393,6 +403,8 @@ public class SparkPlatform {
                 timeoutThread.set(null);
             }
         });
+
+        return future;
     }
 
     private void executeCommand0(CommandSender sender, String[] args) {
diff --git a/spark-common/src/main/java/me/lucko/spark/common/command/modules/SamplerModule.java b/spark-common/src/main/java/me/lucko/spark/common/command/modules/SamplerModule.java
index 9e2647a..334e416 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/command/modules/SamplerModule.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/command/modules/SamplerModule.java
@@ -59,6 +59,7 @@ import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
+import java.util.function.Supplier;
 
 import static net.kyori.adventure.text.Component.empty;
 import static net.kyori.adventure.text.Component.space;
@@ -208,7 +209,7 @@ public class SamplerModule implements CommandModule {
             }
         }
 
-        ThreadGrouper threadGrouper;
+        Supplier<ThreadGrouper> threadGrouper;
         if (arguments.boolFlag("combine-all")) {
             threadGrouper = ThreadGrouper.AS_ONE;
         } else if (arguments.boolFlag("not-combined")) {
diff --git a/spark-common/src/main/java/me/lucko/spark/common/heapdump/HeapDumpSummary.java b/spark-common/src/main/java/me/lucko/spark/common/heapdump/HeapDumpSummary.java
index 364edd6..4d34d4a 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/heapdump/HeapDumpSummary.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/heapdump/HeapDumpSummary.java
@@ -20,6 +20,7 @@
 
 package me.lucko.spark.common.heapdump;
 
+import com.google.common.annotations.VisibleForTesting;
 import me.lucko.spark.common.SparkPlatform;
 import me.lucko.spark.common.command.sender.CommandSender;
 import me.lucko.spark.proto.SparkHeapProtos.HeapData;
@@ -123,6 +124,11 @@ public final class HeapDumpSummary {
         this.entries = entries;
     }
 
+    @VisibleForTesting
+    List<Entry> getEntries() {
+        return this.entries;
+    }
+
     public HeapData toProto(SparkPlatform platform, CommandSender.Data creator) {
         HeapMetadata.Builder metadata = HeapMetadata.newBuilder()
                 .setPlatformMetadata(platform.getPlugin().getPlatformInfo().toData().toProto())
@@ -186,6 +192,16 @@ public final class HeapDumpSummary {
                     .setType(this.type)
                     .build();
         }
+
+        @Override
+        public String toString() {
+            return "Entry{" +
+                    "order=" + this.order +
+                    ", instances=" + this.instances +
+                    ", bytes=" + this.bytes +
+                    ", type='" + this.type + '\'' +
+                    '}';
+        }
     }
 
     public interface DiagnosticCommandMXBean {
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/MacosSysctl.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/MacosSysctl.java
new file mode 100644
index 0000000..c279f31
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/MacosSysctl.java
@@ -0,0 +1,67 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.monitor;
+
+import org.checkerframework.checker.nullness.qual.NonNull;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Utility for reading from sysctl on macOS systems.
+ */
+public enum MacosSysctl {
+
+    SYSCTL("sysctl", "-a"),;
+
+    private static final boolean SUPPORTED = System.getProperty("os.name").toLowerCase(Locale.ROOT).replace(" ", "").equals("macosx");
+
+    private final String[] cmdArgs;
+
+    MacosSysctl(String... cmdArgs) {
+        this.cmdArgs = cmdArgs;
+    }
+
+    public @NonNull List<String> read() {
+        if (SUPPORTED) {
+            ProcessBuilder process = new ProcessBuilder(this.cmdArgs).redirectErrorStream(true);
+            try (BufferedReader buf = new BufferedReader(new InputStreamReader(process.start().getInputStream()))) {
+                List<String> lines = new ArrayList<>();
+
+                String line;
+                while ((line = buf.readLine()) != null) {
+                    lines.add(line);
+                }
+
+                return lines;
+            } catch (Exception e) {
+                // ignore
+            }
+        }
+
+        return Collections.emptyList();
+    }
+}
+
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/cpu/CpuInfo.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/cpu/CpuInfo.java
index 9954bd5..07875cc 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/monitor/cpu/CpuInfo.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/cpu/CpuInfo.java
@@ -21,6 +21,7 @@
 package me.lucko.spark.common.monitor.cpu;
 
 import me.lucko.spark.common.monitor.LinuxProc;
+import me.lucko.spark.common.monitor.MacosSysctl;
 import me.lucko.spark.common.monitor.WindowsWmic;
 
 import java.util.regex.Pattern;
@@ -52,6 +53,12 @@ public enum CpuInfo {
             }
         }
 
+        for (String line : MacosSysctl.SYSCTL.read()) {
+            if (line.startsWith("machdep.cpu.brand_string:")) {
+                return line.substring("machdep.cpu.brand_string:".length()).trim();
+            }
+        }
+
         return "";
     }
 
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/net/NetworkInterfaceInfo.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/net/NetworkInterfaceInfo.java
index eed695e..c2ba1da 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/monitor/net/NetworkInterfaceInfo.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/net/NetworkInterfaceInfo.java
@@ -20,6 +20,7 @@
 
 package me.lucko.spark.common.monitor.net;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableMap;
 import me.lucko.spark.common.monitor.LinuxProc;
 import org.checkerframework.checker.nullness.qual.NonNull;
@@ -200,7 +201,8 @@ public final class NetworkInterfaceInfo {
 
     private static final Pattern PROC_NET_DEV_PATTERN = Pattern.compile("^\\s*(\\w+):([\\d\\s]+)$");
 
-    private static @NonNull Map<String, NetworkInterfaceInfo> read(List<String> output) {
+    @VisibleForTesting
+    static @NonNull Map<String, NetworkInterfaceInfo> read(List<String> output) {
         // Inter-|   Receive                                                |  Transmit
         //  face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
         //     lo: 2776770   11307    0    0    0     0          0         0  2776770   11307    0    0    0     0       0          0
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/BackgroundSamplerManager.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/BackgroundSamplerManager.java
index 4e9ca9e..1889304 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/sampler/BackgroundSamplerManager.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/BackgroundSamplerManager.java
@@ -22,8 +22,9 @@ package me.lucko.spark.common.sampler;
 
 import me.lucko.spark.common.SparkPlatform;
 import me.lucko.spark.common.platform.PlatformInfo;
-import me.lucko.spark.common.util.Configuration;
+import me.lucko.spark.common.util.config.Configuration;
 
+import java.util.function.Supplier;
 import java.util.logging.Level;
 
 public class BackgroundSamplerManager {
@@ -103,7 +104,7 @@ public class BackgroundSamplerManager {
     private void startSampler() {
         boolean forceJavaEngine = this.configuration.getString(OPTION_ENGINE, "async").equals("java");
 
-        ThreadGrouper threadGrouper = ThreadGrouper.parseConfigSetting(this.configuration.getString(OPTION_THREAD_GROUPER, "by-pool"));
+        Supplier<ThreadGrouper> threadGrouper = ThreadGrouper.parseConfigSetting(this.configuration.getString(OPTION_THREAD_GROUPER, "by-pool"));
         ThreadDumper threadDumper = ThreadDumper.parseConfigSetting(this.configuration.getString(OPTION_THREAD_DUMPER, "default"));
         if (threadDumper == null) {
             threadDumper = this.platform.getPlugin().getDefaultThreadDumper();
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/SamplerBuilder.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/SamplerBuilder.java
index b6895ce..3046d92 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/sampler/SamplerBuilder.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/SamplerBuilder.java
@@ -28,6 +28,7 @@ import me.lucko.spark.common.sampler.java.JavaSampler;
 import me.lucko.spark.common.tick.TickHook;
 
 import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
 
 /**
  * Builds {@link Sampler} instances.
@@ -44,7 +45,7 @@ public class SamplerBuilder {
     private long autoEndTime = -1;
     private boolean background = false;
     private ThreadDumper threadDumper = ThreadDumper.ALL;
-    private ThreadGrouper threadGrouper = ThreadGrouper.BY_NAME;
+    private Supplier<ThreadGrouper> threadGrouper = ThreadGrouper.BY_NAME;
 
     private int ticksOver = -1;
     private TickHook tickHook = null;
@@ -80,7 +81,7 @@ public class SamplerBuilder {
         return this;
     }
 
-    public SamplerBuilder threadGrouper(ThreadGrouper threadGrouper) {
+    public SamplerBuilder threadGrouper(Supplier<ThreadGrouper> threadGrouper) {
         this.threadGrouper = threadGrouper;
         return this;
     }
@@ -131,7 +132,7 @@ public class SamplerBuilder {
                 this.samplingInterval
         );
 
-        SamplerSettings settings = new SamplerSettings(interval, this.threadDumper, this.threadGrouper, this.autoEndTime, this.background);
+        SamplerSettings settings = new SamplerSettings(interval, this.threadDumper, this.threadGrouper.get(), this.autoEndTime, this.background);
 
         Sampler sampler;
         if (this.mode == SamplerMode.ALLOCATION) {
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/ThreadGrouper.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/ThreadGrouper.java
index b6cfbea..c8d5b3c 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/sampler/ThreadGrouper.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/ThreadGrouper.java
@@ -26,6 +26,7 @@ import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -64,7 +65,7 @@ public interface ThreadGrouper {
      * @param setting the config setting
      * @return the thread grouper
      */
-    static ThreadGrouper parseConfigSetting(String setting) {
+    static Supplier<ThreadGrouper> parseConfigSetting(String setting) {
         switch (setting) {
             case "as-one":
                 return AS_ONE;
@@ -76,9 +77,14 @@ public interface ThreadGrouper {
     }
 
     /**
+     * Supplier for {@link ByName} thread groupers.
+     */
+    Supplier<ThreadGrouper> BY_NAME = ByName::new;
+
+    /**
      * Implementation of {@link ThreadGrouper} that just groups by thread name.
      */
-    ThreadGrouper BY_NAME = new ThreadGrouper() {
+    class ByName implements ThreadGrouper {
         @Override
         public String getGroup(long threadId, String threadName) {
             return threadName;
@@ -93,7 +99,12 @@ public interface ThreadGrouper {
         public SamplerMetadata.DataAggregator.ThreadGrouper asProto() {
             return SamplerMetadata.DataAggregator.ThreadGrouper.BY_NAME;
         }
-    };
+    }
+
+    /**
+     * Supplier for {@link ByPool} thread groupers.
+     */
+    Supplier<ThreadGrouper> BY_POOL = ByPool::new;
 
     /**
      * Implementation of {@link ThreadGrouper} that attempts to group by the name of the pool
@@ -102,8 +113,8 @@ public interface ThreadGrouper {
      * <p>The regex pattern used to match pools expects a digit at the end of the thread name,
      * separated from the pool name with any of one or more of ' ', '-', or '#'.</p>
      */
-    ThreadGrouper BY_POOL = new ThreadGrouper() {
-        private /* static */ final Pattern pattern = Pattern.compile("^(.*?)[-# ]+\\d+$");
+    class ByPool implements ThreadGrouper {
+        private static final Pattern PATTERN = Pattern.compile("^(.*?)[-# ]+\\d+$");
 
         // thread id -> group
         private final Map<Long, String> cache = new ConcurrentHashMap<>();
@@ -117,7 +128,7 @@ public interface ThreadGrouper {
                 return cached;
             }
 
-            Matcher matcher = this.pattern.matcher(threadName);
+            Matcher matcher = PATTERN.matcher(threadName);
             if (!matcher.matches()) {
                 return threadName;
             }
@@ -141,13 +152,18 @@ public interface ThreadGrouper {
         public SamplerMetadata.DataAggregator.ThreadGrouper asProto() {
             return SamplerMetadata.DataAggregator.ThreadGrouper.BY_POOL;
         }
-    };
+    }
+
+    /**
+     * Supplier for {@link AsOne} thread groupers.
+     */
+    Supplier<ThreadGrouper> AS_ONE = AsOne::new;
 
     /**
      * Implementation of {@link ThreadGrouper} which groups all threads as one, under
      * the name "All".
      */
-    ThreadGrouper AS_ONE = new ThreadGrouper() {
+    class AsOne implements ThreadGrouper {
         private final Set<Long> seen = ConcurrentHashMap.newKeySet();
 
         @Override
diff --git a/spark-common/src/main/java/me/lucko/spark/common/util/JavaVersion.java b/spark-common/src/main/java/me/lucko/spark/common/util/JavaVersion.java
index efeabfc..1dad75b 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/util/JavaVersion.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/util/JavaVersion.java
@@ -20,6 +20,8 @@
 
 package me.lucko.spark.common.util;
 
+import com.google.common.annotations.VisibleForTesting;
+
 public class JavaVersion {
     ;
 
@@ -28,7 +30,8 @@ public class JavaVersion {
         JAVA_VERSION = parseJavaVersion(System.getProperty("java.version"));
     }
 
-    private static int parseJavaVersion(String version) {
+    @VisibleForTesting
+    static int parseJavaVersion(String version) {
         if (version.startsWith("1.")) {
             // Java 8 and below
             return Integer.parseInt(version.substring(2, 3));
diff --git a/spark-common/src/main/java/me/lucko/spark/common/util/config/CombinedConfiguration.java b/spark-common/src/main/java/me/lucko/spark/common/util/config/CombinedConfiguration.java
new file mode 100644
index 0000000..ff7388a
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/util/config/CombinedConfiguration.java
@@ -0,0 +1,132 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util.config;
+
+import com.google.common.collect.ImmutableList;
+
+import java.util.Collections;
+import java.util.List;
+
+class CombinedConfiguration implements Configuration {
+
+    private final List<Configuration> configurations;
+
+    CombinedConfiguration(Configuration... configurations) {
+        this.configurations = ImmutableList.copyOf(configurations).reverse();
+    }
+
+    @Override
+    public void load() {
+        for (Configuration configuration : this.configurations) {
+            configuration.load();
+        }
+    }
+
+    @Override
+    public void save() {
+        for (Configuration configuration : this.configurations) {
+            configuration.save();
+        }
+    }
+
+    @Override
+    public String getString(String path, String def) {
+        String result = def;
+        for (Configuration configuration : this.configurations) {
+            result = configuration.getString(path, result);
+        }
+        return result;
+    }
+
+    @Override
+    public boolean getBoolean(String path, boolean def) {
+        boolean result = def;
+        for (Configuration configuration : this.configurations) {
+            result = configuration.getBoolean(path, result);
+        }
+        return result;
+    }
+
+    @Override
+    public int getInteger(String path, int def) {
+        int result = def;
+        for (Configuration configuration : this.configurations) {
+            result = configuration.getInteger(path, result);
+        }
+        return result;
+    }
+
+    @Override
+    public List<String> getStringList(String path) {
+        for (Configuration configuration : this.configurations) {
+            List<String> result = configuration.getStringList(path);
+            if (!result.isEmpty()) {
+                return result;
+            }
+        }
+        return Collections.emptyList();
+    }
+
+    @Override
+    public void setString(String path, String value) {
+        for (Configuration configuration : this.configurations) {
+            configuration.setString(path, value);
+        }
+    }
+
+    @Override
+    public void setBoolean(String path, boolean value) {
+        for (Configuration configuration : this.configurations) {
+            configuration.setBoolean(path, value);
+        }
+    }
+
+    @Override
+    public void setInteger(String path, int value) {
+        for (Configuration configuration : this.configurations) {
+            configuration.setInteger(path, value);
+        }
+    }
+
+    @Override
+    public void setStringList(String path, List<String> value) {
+        for (Configuration configuration : this.configurations) {
+            configuration.setStringList(path, value);
+        }
+    }
+
+    @Override
+    public boolean contains(String path) {
+        for (Configuration configuration : this.configurations) {
+            if (configuration.contains(path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void remove(String path) {
+        for (Configuration configuration : this.configurations) {
+            configuration.remove(path);
+        }
+    }
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/util/config/Configuration.java b/spark-common/src/main/java/me/lucko/spark/common/util/config/Configuration.java
new file mode 100644
index 0000000..c2c2d88
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/util/config/Configuration.java
@@ -0,0 +1,54 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util.config;
+
+import java.util.List;
+
+public interface Configuration {
+
+    static Configuration combining(Configuration... configurations) {
+        return new CombinedConfiguration(configurations);
+    }
+
+    void load();
+
+    void save();
+
+    String getString(String path, String def);
+
+    boolean getBoolean(String path, boolean def);
+
+    int getInteger(String path, int def);
+
+    List<String> getStringList(String path);
+
+    void setString(String path, String value);
+
+    void setBoolean(String path, boolean value);
+
+    void setInteger(String path, int value);
+
+    void setStringList(String path, List<String> value);
+
+    boolean contains(String path);
+
+    void remove(String path);
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/util/Configuration.java b/spark-common/src/main/java/me/lucko/spark/common/util/config/FileConfiguration.java
index 586a845..72a4681 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/util/Configuration.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/util/config/FileConfiguration.java
@@ -18,7 +18,7 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-package me.lucko.spark.common.util;
+package me.lucko.spark.common.util.config;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
@@ -37,17 +37,18 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-public final class Configuration {
+public class FileConfiguration implements Configuration {
     private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
 
     private final Path file;
     private JsonObject root;
 
-    public Configuration(Path file) {
+    public FileConfiguration(Path file) {
         this.file = file;
         load();
     }
 
+    @Override
     public void load() {
         JsonObject root = null;
         if (Files.exists(this.file)) {
@@ -64,6 +65,7 @@ public final class Configuration {
         this.root = root;
     }
 
+    @Override
     public void save() {
         try {
             Files.createDirectories(this.file.getParent());
@@ -78,6 +80,7 @@ public final class Configuration {
         }
     }
 
+    @Override
     public String getString(String path, String def) {
         JsonElement el = this.root.get(path);
         if (el == null || !el.isJsonPrimitive()) {
@@ -87,6 +90,7 @@ public final class Configuration {
         return el.getAsJsonPrimitive().getAsString();
     }
 
+    @Override
     public boolean getBoolean(String path, boolean def) {
         JsonElement el = this.root.get(path);
         if (el == null || !el.isJsonPrimitive()) {
@@ -97,6 +101,7 @@ public final class Configuration {
         return val.isBoolean() ? val.getAsBoolean() : def;
     }
 
+    @Override
     public int getInteger(String path, int def) {
         JsonElement el = this.root.get(path);
         if (el == null || !el.isJsonPrimitive()) {
@@ -107,6 +112,7 @@ public final class Configuration {
         return val.isNumber() ? val.getAsInt() : def;
     }
 
+    @Override
     public List<String> getStringList(String path) {
         JsonElement el = this.root.get(path);
         if (el == null || !el.isJsonArray()) {
@@ -122,18 +128,22 @@ public final class Configuration {
         return list;
     }
 
+    @Override
     public void setString(String path, String value) {
         this.root.add(path, new JsonPrimitive(value));
     }
 
+    @Override
     public void setBoolean(String path, boolean value) {
         this.root.add(path, new JsonPrimitive(value));
     }
 
+    @Override
     public void setInteger(String path, int value) {
         this.root.add(path, new JsonPrimitive(value));
     }
 
+    @Override
     public void setStringList(String path, List<String> value) {
         JsonArray array = new JsonArray();
         for (String str : value) {
@@ -142,10 +152,12 @@ public final class Configuration {
         this.root.add(path, array);
     }
 
+    @Override
     public boolean contains(String path) {
         return this.root.has(path);
     }
 
+    @Override
     public void remove(String path) {
         this.root.remove(path);
     }
diff --git a/spark-common/src/main/java/me/lucko/spark/common/util/config/RuntimeConfiguration.java b/spark-common/src/main/java/me/lucko/spark/common/util/config/RuntimeConfiguration.java
new file mode 100644
index 0000000..d076554
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/util/config/RuntimeConfiguration.java
@@ -0,0 +1,106 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util.config;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public enum RuntimeConfiguration implements Configuration {
+    SYSTEM_PROPERTIES {
+        @Override
+        public String getString(String path, String def) {
+            return System.getProperty("spark." + path, def);
+        }
+    },
+
+    ENVIRONMENT_VARIABLES {
+        @Override
+        public String getString(String path, String def) {
+            String name = "SPARK_" + path.replace(".", "_").replace("-", "_").toUpperCase();
+            String value = System.getenv(name);
+            return value != null ? value : def;
+        }
+    };
+
+    @Override
+    public boolean getBoolean(String path, boolean def) {
+        return Boolean.parseBoolean(getString(path, Boolean.toString(def)));
+    }
+
+    @Override
+    public int getInteger(String path, int def) {
+        try {
+            return Integer.parseInt(getString(path, Integer.toString(def)));
+        } catch (NumberFormatException e) {
+            return def;
+        }
+    }
+
+    @Override
+    public List<String> getStringList(String path) {
+        String value = getString(path, "");
+        if (value.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(value.split(","));
+    }
+
+    @Override
+    public boolean contains(String path) {
+        return getString(path, null) != null;
+    }
+
+    @Override
+    public void load() {
+        // no-op
+    }
+
+    @Override
+    public void save() {
+        // no-op
+    }
+
+    @Override
+    public void setString(String path, String value) {
+        // no-op
+    }
+
+    @Override
+    public void setBoolean(String path, boolean value) {
+        // no-op
+    }
+
+    @Override
+    public void setInteger(String path, int value) {
+        // no-op
+    }
+
+    @Override
+    public void setStringList(String path, List<String> value) {
+        // no-op
+    }
+
+    @Override
+    public void remove(String path) {
+        // no-op
+    }
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/ws/TrustedKeyStore.java b/spark-common/src/main/java/me/lucko/spark/common/ws/TrustedKeyStore.java
index 1605a38..0d82514 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/ws/TrustedKeyStore.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/ws/TrustedKeyStore.java
@@ -20,7 +20,7 @@
 
 package me.lucko.spark.common.ws;
 
-import me.lucko.spark.common.util.Configuration;
+import me.lucko.spark.common.util.config.Configuration;
 
 import java.security.KeyPair;
 import java.security.PrivateKey;
diff --git a/spark-common/src/test/java/me/lucko/spark/common/SparkPlatformTest.java b/spark-common/src/test/java/me/lucko/spark/common/SparkPlatformTest.java
new file mode 100644
index 0000000..ec3638f
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/SparkPlatformTest.java
@@ -0,0 +1,46 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common;
+
+import me.lucko.spark.test.plugin.TestCommandSender;
+import me.lucko.spark.test.plugin.TestSparkPlugin;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+
+public class SparkPlatformTest {
+
+    @Test
+    public void testEnableDisable(@TempDir Path directory) {
+        System.setProperty("spark.backgroundProfiler", "false");
+
+        SparkPlatform platform = new SparkPlatform(new TestSparkPlugin(directory));
+        platform.enable();
+
+        platform.executeCommand(TestCommandSender.INSTANCE, new String[]{"help"}).join();
+        platform.executeCommand(TestCommandSender.INSTANCE, new String[]{"profiler", "info"}).join();
+        platform.executeCommand(TestCommandSender.INSTANCE, new String[]{"health"}).join();
+
+        platform.disable();
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/activitylog/ActivityLogTest.java b/spark-common/src/test/java/me/lucko/spark/common/activitylog/ActivityLogTest.java
new file mode 100644
index 0000000..a94f954
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/activitylog/ActivityLogTest.java
@@ -0,0 +1,54 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.activitylog;
+
+import me.lucko.spark.common.command.sender.CommandSender;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ActivityLogTest {
+
+    private static final CommandSender.Data USER = new CommandSender.Data("Test", UUID.fromString("5937921d-7051-45e1-bac7-3bbfdc12444f"));
+
+    @Test
+    public void testSaveLoad(@TempDir Path tempDir) {
+        ActivityLog log = new ActivityLog(tempDir.resolve("activity-log.json"));
+        log.addToLog(Activity.fileActivity(USER, 1721937782184L, "Profiler", "path/to/profile.sparkprofile"));
+        log.addToLog(Activity.urlActivity(USER, 1721937782184L, "Profiler", "https://spark.lucko.me/abcd"));
+        log.save();
+
+        ActivityLog log2 = new ActivityLog(tempDir.resolve("activity-log.json"));
+        log2.load();
+
+        // check the log contents
+        assertEquals(
+                log.getLog().stream().map(Activity::serialize).collect(Collectors.toList()),
+                log2.getLog().stream().map(Activity::serialize).collect(Collectors.toList())
+        );
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/activitylog/ActivityTest.java b/spark-common/src/test/java/me/lucko/spark/common/activitylog/ActivityTest.java
new file mode 100644
index 0000000..5bf88f8
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/activitylog/ActivityTest.java
@@ -0,0 +1,78 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.activitylog;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import me.lucko.spark.common.command.sender.CommandSender;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ActivityTest {
+    private static final Gson GSON = new Gson();
+
+    private static final CommandSender.Data USER = new CommandSender.Data("Test", UUID.fromString("5937921d-7051-45e1-bac7-3bbfdc12444f"));
+
+    private static final String FILE_ACTIVITY_JSON = "{\"user\":{\"type\":\"player\",\"name\":\"Test\",\"uniqueId\":\"5937921d-7051-45e1-bac7-3bbfdc12444f\"},\"time\":1721937782184,\"type\":\"Profiler\",\"data\":{\"type\":\"file\",\"value\":\"path/to/profile.sparkprofile\"}}";
+    private static final String URL_ACTIVITY_JSON = "{\"user\":{\"type\":\"player\",\"name\":\"Test\",\"uniqueId\":\"5937921d-7051-45e1-bac7-3bbfdc12444f\"},\"time\":1721937782184,\"type\":\"Profiler\",\"data\":{\"type\":\"url\",\"value\":\"https://spark.lucko.me/abcd\"}}";
+
+    @Test
+    public void testSerialize() {
+        Activity fileActivity = Activity.fileActivity(
+                USER,
+                1721937782184L,
+                "Profiler",
+                "path/to/profile.sparkprofile"
+        );
+        assertEquals(FILE_ACTIVITY_JSON, GSON.toJson(fileActivity.serialize()));
+
+        Activity urlActivity = Activity.urlActivity(
+                USER,
+                1721937782184L,
+                "Profiler",
+                "https://spark.lucko.me/abcd"
+        );
+        assertEquals(URL_ACTIVITY_JSON, GSON.toJson(urlActivity.serialize()));
+    }
+
+    @Test
+    public void testDeserialize() {
+        Activity fileActivity = Activity.deserialize(GSON.fromJson(FILE_ACTIVITY_JSON, JsonElement.class));
+        assertEquals(USER.getUniqueId(), fileActivity.getUser().getUniqueId());
+        assertEquals(USER.getName(), fileActivity.getUser().getName());
+        assertEquals(1721937782184L, fileActivity.getTime());
+        assertEquals("Profiler", fileActivity.getType());
+        assertEquals(Activity.DATA_TYPE_FILE, fileActivity.getDataType());
+        assertEquals("path/to/profile.sparkprofile", fileActivity.getDataValue());
+
+        Activity urlActivity = Activity.deserialize(GSON.fromJson(URL_ACTIVITY_JSON, JsonElement.class));
+        assertEquals(USER.getUniqueId(), urlActivity.getUser().getUniqueId());
+        assertEquals(USER.getName(), urlActivity.getUser().getName());
+        assertEquals(1721937782184L, urlActivity.getTime());
+        assertEquals("Profiler", urlActivity.getType());
+        assertEquals(Activity.DATA_TYPE_URL, urlActivity.getDataType());
+        assertEquals("https://spark.lucko.me/abcd", urlActivity.getDataValue());
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/heapdump/HeapDumpSummaryTest.java b/spark-common/src/test/java/me/lucko/spark/common/heapdump/HeapDumpSummaryTest.java
new file mode 100644
index 0000000..42492d1
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/heapdump/HeapDumpSummaryTest.java
@@ -0,0 +1,47 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.heapdump;
+
+import me.lucko.spark.test.TestClass;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class HeapDumpSummaryTest {
+
+    @Test
+    public void testHeapDumpSummary() throws Exception {
+        TestClass testClass1 = new TestClass();
+        TestClass testClass2 = new TestClass();
+
+        HeapDumpSummary dump = HeapDumpSummary.createNew();
+        List<HeapDumpSummary.Entry> entries = dump.getEntries();
+
+        HeapDumpSummary.Entry thisClassEntry = entries.stream().filter(entry -> entry.getType().equals(TestClass.class.getName())).findAny().orElse(null);
+        assertNotNull(thisClassEntry);
+        assertEquals(2, thisClassEntry.getInstances());
+        assertEquals(32, thisClassEntry.getBytes());
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/heapdump/HeapDumpTest.java b/spark-common/src/test/java/me/lucko/spark/common/heapdump/HeapDumpTest.java
new file mode 100644
index 0000000..5df5c5d
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/heapdump/HeapDumpTest.java
@@ -0,0 +1,41 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.heapdump;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class HeapDumpTest {
+
+    @Test
+    public void testHeapDump(@TempDir Path tempDir) throws Exception {
+        Path file = tempDir.resolve("heapdump.hprof");
+        HeapDump.dumpHeap(file, false);
+        assertTrue(Files.exists(file));
+        Files.delete(file);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/monitor/cpu/CpuInfoTest.java b/spark-common/src/test/java/me/lucko/spark/common/monitor/cpu/CpuInfoTest.java
new file mode 100644
index 0000000..047e80d
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/monitor/cpu/CpuInfoTest.java
@@ -0,0 +1,38 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.monitor.cpu;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class CpuInfoTest {
+
+    @Test
+    public void testCpuInfo() {
+        String model = CpuInfo.queryCpuModel();
+        assertNotNull(model);
+        assertFalse(model.isEmpty());
+        System.out.println(model);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/monitor/cpu/CpuMonitorTest.java b/spark-common/src/test/java/me/lucko/spark/common/monitor/cpu/CpuMonitorTest.java
new file mode 100644
index 0000000..d554976
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/monitor/cpu/CpuMonitorTest.java
@@ -0,0 +1,35 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.monitor.cpu;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class CpuMonitorTest {
+
+    @Test
+    public void testCpuLoad() {
+        assertTrue(CpuMonitor.processLoad() >= 0);
+        assertTrue(CpuMonitor.systemLoad() >= 0);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/monitor/disk/DiskUsageTest.java b/spark-common/src/test/java/me/lucko/spark/common/monitor/disk/DiskUsageTest.java
new file mode 100644
index 0000000..d961b2f
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/monitor/disk/DiskUsageTest.java
@@ -0,0 +1,35 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.monitor.disk;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class DiskUsageTest {
+
+    @Test
+    public void testDiskUsage() {
+        assertTrue(DiskUsage.getUsed() > 0);
+        assertTrue(DiskUsage.getTotal() > 0);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/monitor/memory/MemoryInfoTest.java b/spark-common/src/test/java/me/lucko/spark/common/monitor/memory/MemoryInfoTest.java
new file mode 100644
index 0000000..5ae8fdc
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/monitor/memory/MemoryInfoTest.java
@@ -0,0 +1,36 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.monitor.memory;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class MemoryInfoTest {
+
+    @Test
+    public void testMemoryInfo() {
+        assertTrue(MemoryInfo.getUsedPhysicalMemory() > 0);
+        assertTrue(MemoryInfo.getTotalPhysicalMemory() > 0);
+        assertTrue(MemoryInfo.getAvailablePhysicalMemory() > 0);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/monitor/net/NetworkInterfaceInfoTest.java b/spark-common/src/test/java/me/lucko/spark/common/monitor/net/NetworkInterfaceInfoTest.java
new file mode 100644
index 0000000..6b50584
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/monitor/net/NetworkInterfaceInfoTest.java
@@ -0,0 +1,57 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.monitor.net;
+
+import com.google.common.collect.ImmutableSet;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class NetworkInterfaceInfoTest {
+
+    @Test
+    public void testLinuxProcParse() {
+        String input =
+                "Inter-|   Receive                                                |  Transmit\n" +
+                " face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed\n" +
+                "    lo: 2776770   11307    0    0    0     0          0         0  2776770   11307    0    0    0     0       0          0\n" +
+                "  eth0: 1215645    2751    1    0    0     0          0         0  1782404    4324    2    0    0   427       0          0\n" +
+                "  ppp0: 1622270    5552    1    0    0     0          0         0   354130    5669    0    0    0     0       0          0\n" +
+                "  tap0:    7714      81    0    0    0     0          0         0     7714      81    0    0    0     0       0          0";
+
+        Map<String, NetworkInterfaceInfo> map = NetworkInterfaceInfo.read(Arrays.asList(input.split("\n")));
+        assertNotNull(map);
+        assertEquals(ImmutableSet.of("lo", "eth0", "ppp0", "tap0"), map.keySet());
+
+        NetworkInterfaceInfo eth0 = map.get("eth0");
+        assertEquals(1215645, eth0.getReceivedBytes());
+        assertEquals(2751, eth0.getReceivedPackets());
+        assertEquals(1, eth0.getReceiveErrors());
+        assertEquals(1782404, eth0.getTransmittedBytes());
+        assertEquals(4324, eth0.getTransmittedPackets());
+        assertEquals(2, eth0.getTransmitErrors());
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/monitor/os/OperatingSystemInfoTest.java b/spark-common/src/test/java/me/lucko/spark/common/monitor/os/OperatingSystemInfoTest.java
new file mode 100644
index 0000000..3e4fd13
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/monitor/os/OperatingSystemInfoTest.java
@@ -0,0 +1,42 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.monitor.os;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class OperatingSystemInfoTest {
+
+    @Test
+    public void testOperatingSystemInfo() {
+        OperatingSystemInfo info = OperatingSystemInfo.poll();
+        assertNotNull(info);
+        assertNotNull(info.name());
+        assertNotNull(info.version());
+        assertNotNull(info.arch());
+
+        System.out.println(info.name());
+        System.out.println(info.version());
+        System.out.println(info.arch());
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/platform/serverconfig/ExcludedConfigFilterTest.java b/spark-common/src/test/java/me/lucko/spark/common/platform/serverconfig/ExcludedConfigFilterTest.java
new file mode 100644
index 0000000..ba6f958
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/platform/serverconfig/ExcludedConfigFilterTest.java
@@ -0,0 +1,106 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.platform.serverconfig;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ExcludedConfigFilterTest {
+
+    @Test
+    public void testFilter() {
+        Set<String> excluded = ImmutableSet.<String>builder()
+                .add("database")
+                .add("settings.bungeecord-addresses")
+                .add("rcon<dot>password")
+                .add("world-settings.*.feature-seeds")
+                .add("world-settings.*.seed-*")
+                .build();
+
+        ExcludedConfigFilter filter = new ExcludedConfigFilter(excluded);
+
+        JsonPrimitive value = new JsonPrimitive("hello");
+        JsonObject before = obj(
+                element("hello", value),
+                element("database", obj(
+                        element("username", value),
+                        element("password", value)
+                )),
+                element("settings", obj(
+                        element("hello", value),
+                        element("bungeecord-addresses", value)
+                )),
+                element("rcon.password", value),
+                element("world-settings", obj(
+                        element("world1", obj(
+                                element("hello", value),
+                                element("feature-seeds", value),
+                                element("seed-test", value)
+                        )),
+                        element("world2", obj(
+                                element("hello", value),
+                                element("feature-seeds", value),
+                                element("seed-test", value)
+                        ))
+                ))
+        );
+        JsonObject after = obj(
+                element("hello", value),
+                element("settings", obj(
+                        element("hello", value)
+                )),
+                element("world-settings", obj(
+                        element("world1", obj(
+                                element("hello", value)
+                        )),
+                        element("world2", obj(
+                                element("hello", value)
+                        ))
+                ))
+        );
+
+
+        assertEquals(after, filter.apply(before));
+    }
+
+    @SafeVarargs
+    private static JsonObject obj(Map.Entry<String, JsonElement>... elements) {
+        JsonObject object = new JsonObject();
+        for (Map.Entry<String, JsonElement> element : elements) {
+            object.add(element.getKey(), element.getValue());
+        }
+        return object;
+    }
+
+    private static Map.Entry<String, JsonElement> element(String key, JsonElement value) {
+        return Maps.immutableEntry(key, value);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/platform/serverconfig/PropertiesConfigParserTest.java b/spark-common/src/test/java/me/lucko/spark/common/platform/serverconfig/PropertiesConfigParserTest.java
new file mode 100644
index 0000000..2b686ca
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/platform/serverconfig/PropertiesConfigParserTest.java
@@ -0,0 +1,50 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.platform.serverconfig;
+
+import com.google.common.collect.ImmutableMap;
+import org.junit.jupiter.api.Test;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class PropertiesConfigParserTest {
+
+    @Test
+    public void testParse() throws IOException {
+        String properties =
+                "hello=world\n" +
+                "a.b.c=1\n" +
+                "foo=true\n";
+
+        Map<String, Object> parse = PropertiesConfigParser.INSTANCE.parse(new BufferedReader(new StringReader(properties)));
+        assertEquals(ImmutableMap.of(
+                "hello", "world",
+                "a.b.c", 1L,
+                "foo", true
+        ), parse);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/platform/world/CountMapTest.java b/spark-common/src/test/java/me/lucko/spark/common/platform/world/CountMapTest.java
new file mode 100644
index 0000000..8dcc8a9
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/platform/world/CountMapTest.java
@@ -0,0 +1,49 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.platform.world;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class CountMapTest {
+
+    @Test
+    public void testSimple() {
+        CountMap.Simple<String> countMap = new CountMap.Simple<>(new HashMap<>());
+        assertTrue(countMap.asMap().isEmpty());
+
+        countMap.increment("test");
+        assertTrue(countMap.asMap().containsKey("test"));
+        assertEquals(1, countMap.asMap().get("test").get());
+
+        countMap.add("test", 5);
+        assertEquals(6, countMap.asMap().get("test").get());
+
+        countMap.increment("test2");
+
+        assertEquals(7, countMap.total().get());
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/sampler/ThreadDumperTest.java b/spark-common/src/test/java/me/lucko/spark/common/sampler/ThreadDumperTest.java
new file mode 100644
index 0000000..b96f149
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/sampler/ThreadDumperTest.java
@@ -0,0 +1,64 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.sampler;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ThreadDumperTest {
+
+    @Test
+    public void testAll() {
+        assertTrue(ThreadDumper.ALL.isThreadIncluded(1, "test"));
+        assertTrue(ThreadDumper.ALL.isThreadIncluded(2, "test2"));
+    }
+
+    @Test
+    public void testSpecific() {
+        Thread thread = new Thread(() -> {
+            try {
+                Thread.sleep(100_000);
+            } catch (InterruptedException e) {
+                // ignore
+            }
+        }, "test-thread-1");
+        thread.start();
+
+        ThreadDumper.Specific specific = new ThreadDumper.Specific(thread);
+
+        assertTrue(specific.isThreadIncluded(thread.getId(), "test-thread-1"));
+
+        Set<Thread> threads = specific.getThreads();
+        assertEquals(1, threads.size());
+        assertTrue(threads.contains(thread));
+
+        Set<String> threadNames = specific.getThreadNames();
+        assertEquals(1, threadNames.size());
+        assertTrue(threadNames.contains("test-thread-1"));
+
+        thread.interrupt();
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/sampler/ThreadGrouperTest.java b/spark-common/src/test/java/me/lucko/spark/common/sampler/ThreadGrouperTest.java
new file mode 100644
index 0000000..5f4e5ae
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/sampler/ThreadGrouperTest.java
@@ -0,0 +1,80 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.sampler;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ThreadGrouperTest {
+
+    @Test
+    public void testByName() {
+        ThreadGrouper threadGrouper = ThreadGrouper.BY_NAME.get();
+
+        String group = threadGrouper.getGroup(1, "main");
+        assertEquals("main", group);
+
+        String label = threadGrouper.getLabel("main");
+        assertEquals("main", label);
+    }
+
+    @Test
+    public void testAsOne() {
+        ThreadGrouper threadGrouper = ThreadGrouper.AS_ONE.get();
+
+        String group = threadGrouper.getGroup(1, "main");
+        assertEquals("root", group);
+
+        String label = threadGrouper.getLabel("root");
+        assertEquals("All (x1)", label);
+
+        group = threadGrouper.getGroup(2, "main2");
+        assertEquals("root", group);
+
+        label = threadGrouper.getLabel("root");
+        assertEquals("All (x2)", label);
+    }
+
+    @Test
+    public void testByPool() {
+        ThreadGrouper threadGrouper = ThreadGrouper.BY_POOL.get();
+
+        String group = threadGrouper.getGroup(1, "main");
+        assertEquals("main", group);
+
+        String label = threadGrouper.getLabel("main");
+        assertEquals("main", label);
+
+        group = threadGrouper.getGroup(2, "Test Pool - #1");
+        assertEquals("Test Pool", group);
+
+        label = threadGrouper.getLabel("Test Pool");
+        assertEquals("Test Pool (x1)", label);
+
+        group = threadGrouper.getGroup(3, "Test Pool - #2");
+        assertEquals("Test Pool", group);
+
+        label = threadGrouper.getLabel("Test Pool");
+        assertEquals("Test Pool (x2)", label);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/util/FormatUtilTest.java b/spark-common/src/test/java/me/lucko/spark/common/util/FormatUtilTest.java
new file mode 100644
index 0000000..5b77fb5
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/util/FormatUtilTest.java
@@ -0,0 +1,67 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class FormatUtilTest {
+
+    @Test
+    public void testPercent() {
+        assertEquals("50%", FormatUtil.percent(0.5, 1));
+        assertEquals("100%", FormatUtil.percent(1, 1));
+        assertEquals("0%", FormatUtil.percent(0, 1));
+
+        assertEquals("50%", FormatUtil.percent(50, 100));
+        assertEquals("100%", FormatUtil.percent(100, 100));
+        assertEquals("0%", FormatUtil.percent(0, 100));
+    }
+
+    @Test
+    public void testBytes() {
+        assertEquals("0 bytes", FormatUtil.formatBytes(0));
+        assertEquals("1.0 bytes", FormatUtil.formatBytes(1));
+        assertEquals("1.0 KB", FormatUtil.formatBytes(1024));
+        assertEquals("1.0 MB", FormatUtil.formatBytes(1024 * 1024));
+        assertEquals("1.0 GB", FormatUtil.formatBytes(1024 * 1024 * 1024));
+        assertEquals("1.0 TB", FormatUtil.formatBytes(1024L * 1024 * 1024 * 1024));
+
+        assertEquals("2.5 KB", FormatUtil.formatBytes((long) (1024 * 2.5d)));
+        assertEquals("2.5 MB", FormatUtil.formatBytes((long) (1024 * 1024 * 2.5d)));
+    }
+
+    @Test
+    public void testSeconds() {
+        assertEquals("0s", FormatUtil.formatSeconds(0));
+        assertEquals("1s", FormatUtil.formatSeconds(1));
+        assertEquals("59s", FormatUtil.formatSeconds(59));
+        assertEquals("1m", FormatUtil.formatSeconds(60));
+        assertEquals("1m 1s", FormatUtil.formatSeconds(61));
+        assertEquals("1m 59s", FormatUtil.formatSeconds(119));
+        assertEquals("2m", FormatUtil.formatSeconds(120));
+        assertEquals("2m 1s", FormatUtil.formatSeconds(121));
+        assertEquals("2m 59s", FormatUtil.formatSeconds(179));
+        assertEquals("3m", FormatUtil.formatSeconds(180));
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/util/IndexedListBuilderTest.java b/spark-common/src/test/java/me/lucko/spark/common/util/IndexedListBuilderTest.java
new file mode 100644
index 0000000..bb3820e
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/util/IndexedListBuilderTest.java
@@ -0,0 +1,42 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class IndexedListBuilderTest {
+
+    @Test
+    public void testIndexes() {
+        IndexedListBuilder<String> builder = new IndexedListBuilder<>();
+
+        assertEquals(0, builder.add("a"));
+        assertEquals(1, builder.add("b"));
+        assertEquals(2, builder.add("c"));
+
+        assertEquals(Arrays.asList("a", "b", "c"), builder.build());
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/util/JavaVersionTest.java b/spark-common/src/test/java/me/lucko/spark/common/util/JavaVersionTest.java
new file mode 100644
index 0000000..470f4d0
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/util/JavaVersionTest.java
@@ -0,0 +1,41 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class JavaVersionTest {
+
+    @Test
+    public void testJavaVersion() {
+        assertEquals(7, JavaVersion.parseJavaVersion("1.7"));
+        assertEquals(8, JavaVersion.parseJavaVersion("1.8"));
+        assertEquals(9, JavaVersion.parseJavaVersion("9"));
+        assertEquals(11, JavaVersion.parseJavaVersion("11"));
+        assertEquals(17, JavaVersion.parseJavaVersion("17"));
+        assertEquals(9, JavaVersion.parseJavaVersion("9.0.1"));
+        assertEquals(11, JavaVersion.parseJavaVersion("11.0.1"));
+        assertEquals(17, JavaVersion.parseJavaVersion("17.0.1"));
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/util/MethodDisambiguatorTest.java b/spark-common/src/test/java/me/lucko/spark/common/util/MethodDisambiguatorTest.java
new file mode 100644
index 0000000..f0bea8f
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/util/MethodDisambiguatorTest.java
@@ -0,0 +1,66 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util;
+
+import me.lucko.spark.test.TestClass;
+import me.lucko.spark.common.util.MethodDisambiguator.MethodDescription;
+import me.lucko.spark.common.util.classfinder.FallbackClassFinder;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+public class MethodDisambiguatorTest {
+
+    private static final MethodDisambiguator DISAMBIGUATOR = new MethodDisambiguator(FallbackClassFinder.INSTANCE);
+
+    @ParameterizedTest
+    @CsvSource({
+            "25, test(Ljava/lang/String;)V",
+            "26, test(Ljava/lang/String;)V",
+            "27, test(Ljava/lang/String;)V",
+            "28, test(Ljava/lang/String;)V",
+            "31, test(I)V",
+            "32, test(I)V",
+            "33, test(I)V",
+            "34, test(I)V",
+            "37, test(Z)V",
+            "38, test(Z)V",
+            "39, test(Z)V",
+            "40, test(Z)V",
+    })
+    public void testSuccessfulDisambiguate(int line, String expectedDesc) {
+        MethodDescription method = DISAMBIGUATOR.disambiguate(TestClass.class.getName(), "test", line).orElse(null);
+        assertNotNull(method);
+        assertEquals(expectedDesc, method.toString());
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {24, 29, 100})
+    public void testUnsuccessfulDisambiguate(int line) {
+        MethodDescription method = DISAMBIGUATOR.disambiguate(TestClass.class.getName(), "test", line).orElse(null);
+        assertNull(method);
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/util/RollingAverageTest.java b/spark-common/src/test/java/me/lucko/spark/common/util/RollingAverageTest.java
new file mode 100644
index 0000000..a5b4a00
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/util/RollingAverageTest.java
@@ -0,0 +1,81 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class RollingAverageTest {
+
+    @Test
+    public void testMean() {
+        RollingAverage ra = new RollingAverage(3);
+        ra.add(BigDecimal.valueOf(1));
+        ra.add(BigDecimal.valueOf(2));
+        ra.add(BigDecimal.valueOf(3));
+
+        assertEquals(2, ra.mean());
+        ra.add(BigDecimal.valueOf(4));
+        assertEquals(3, ra.mean());
+        ra.add(BigDecimal.valueOf(5));
+        assertEquals(4, ra.mean());
+        ra.add(BigDecimal.valueOf(6));
+        assertEquals(5, ra.mean());
+    }
+
+    @Test
+    public void testMax() {
+        RollingAverage ra = new RollingAverage(3);
+        ra.add(BigDecimal.valueOf(1));
+        ra.add(BigDecimal.valueOf(2));
+        ra.add(BigDecimal.valueOf(3));
+
+        assertEquals(3, ra.max());
+    }
+
+    @Test
+    public void testMin() {
+        RollingAverage ra = new RollingAverage(3);
+        ra.add(BigDecimal.valueOf(1));
+        ra.add(BigDecimal.valueOf(2));
+        ra.add(BigDecimal.valueOf(3));
+
+        assertEquals(1, ra.min());
+    }
+
+    @Test
+    public void testPercentile() {
+        RollingAverage ra = new RollingAverage(3);
+        ra.add(BigDecimal.valueOf(1));
+        ra.add(BigDecimal.valueOf(2));
+        ra.add(BigDecimal.valueOf(3));
+
+        assertEquals(1, ra.percentile(0));
+        assertEquals(2, ra.percentile(0.25));
+        assertEquals(2, ra.percentile(0.5));
+        assertEquals(3, ra.percentile(0.75));
+        assertEquals(3, ra.percentile(1));
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/common/util/ThreadFinderTest.java b/spark-common/src/test/java/me/lucko/spark/common/util/ThreadFinderTest.java
new file mode 100644
index 0000000..bffbf27
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/common/util/ThreadFinderTest.java
@@ -0,0 +1,50 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ThreadFinderTest {
+
+    @Test
+    public void testFindThread() {
+        Thread thread = new Thread(() -> {
+            try {
+                Thread.sleep(100_000);
+            } catch (InterruptedException e) {
+                // ignore
+            }
+        }, "test-thread-1");
+        thread.start();
+
+        ThreadFinder threadFinder = new ThreadFinder();
+        List<Thread> threads = threadFinder.getThreads().collect(Collectors.toList());
+        assertTrue(threads.contains(thread));
+
+        thread.interrupt();
+    }
+
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/test/TestClass.java b/spark-common/src/test/java/me/lucko/spark/test/TestClass.java
new file mode 100644
index 0000000..bd7ff4a
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/test/TestClass.java
@@ -0,0 +1,41 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.test;
+
+public class TestClass {
+    public void test(String string) {
+        System.out.println("Hello, world!");
+        System.out.println("Hello, world!");
+        System.out.println("Hello, world!");
+    }
+
+    public void test(int integer) {
+        System.out.println("Hello, world!");
+        System.out.println("Hello, world!");
+        System.out.println("Hello, world!");
+    }
+
+    public void test(boolean bool) {
+        System.out.println("Hello, world!");
+        System.out.println("Hello, world!");
+        System.out.println("Hello, world!");
+    }
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/test/plugin/TestCommandSender.java b/spark-common/src/test/java/me/lucko/spark/test/plugin/TestCommandSender.java
new file mode 100644
index 0000000..294b073
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/test/plugin/TestCommandSender.java
@@ -0,0 +1,53 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.test.plugin;
+
+import me.lucko.spark.common.command.sender.CommandSender;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.ansi.ANSIComponentSerializer;
+
+import java.util.UUID;
+
+public enum TestCommandSender implements CommandSender {
+    INSTANCE;
+
+    private final UUID uniqueId = new UUID(0, 0);
+
+    @Override
+    public String getName() {
+        return "Test";
+    }
+
+    @Override
+    public UUID getUniqueId() {
+        return this.uniqueId;
+    }
+
+    @Override
+    public void sendMessage(Component message) {
+        System.out.println(ANSIComponentSerializer.ansi().serialize(message));
+    }
+
+    @Override
+    public boolean hasPermission(String permission) {
+        return true;
+    }
+}
diff --git a/spark-common/src/test/java/me/lucko/spark/test/plugin/TestSparkPlugin.java b/spark-common/src/test/java/me/lucko/spark/test/plugin/TestSparkPlugin.java
new file mode 100644
index 0000000..423e3e3
--- /dev/null
+++ b/spark-common/src/test/java/me/lucko/spark/test/plugin/TestSparkPlugin.java
@@ -0,0 +1,104 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.test.plugin;
+
+import me.lucko.spark.common.SparkPlugin;
+import me.lucko.spark.common.command.sender.CommandSender;
+import me.lucko.spark.common.platform.PlatformInfo;
+
+import java.nio.file.Path;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Stream;
+
+public class TestSparkPlugin implements SparkPlugin {
+
+    private static final Logger LOGGER = Logger.getLogger("spark-test");
+    private static final ScheduledExecutorService EXECUTOR_SERVICE = Executors.newScheduledThreadPool(16);
+
+    private final Path directory;
+
+    public TestSparkPlugin(Path directory) {
+        this.directory = directory;
+    }
+
+    @Override
+    public String getVersion() {
+        return "1.0-test";
+    }
+
+    @Override
+    public Path getPluginDirectory() {
+        return this.directory;
+    }
+
+    @Override
+    public String getCommandName() {
+        return "spark";
+    }
+
+    @Override
+    public Stream<? extends CommandSender> getCommandSenders() {
+        return Stream.of(TestCommandSender.INSTANCE);
+    }
+
+    @Override
+    public void executeAsync(Runnable task) {
+        EXECUTOR_SERVICE.execute(task);
+    }
+
+    @Override
+    public void log(Level level, String msg) {
+        LOGGER.log(level, msg);
+    }
+
+    @Override
+    public PlatformInfo getPlatformInfo() {
+        return new PlatformInfo() {
+            @Override
+            public Type getType() {
+                return Type.SERVER;
+            }
+
+            @Override
+            public String getName() {
+                return "Test";
+            }
+
+            @Override
+            public String getBrand() {
+                return "Test";
+            }
+
+            @Override
+            public String getVersion() {
+                return "v1.0-test";
+            }
+
+            @Override
+            public String getMinecraftVersion() {
+                return null;
+            }
+        };
+    }
+}
diff --git a/spark-nukkit/build.gradle b/spark-nukkit/build.gradle
index 5c709e3..0d572e4 100644
--- a/spark-nukkit/build.gradle
+++ b/spark-nukkit/build.gradle
@@ -4,7 +4,6 @@ plugins {
 
 dependencies {
     implementation project(':spark-common')
-    implementation 'net.kyori:adventure-text-serializer-legacy:4.13.1'
     compileOnly 'cn.nukkit:nukkit:1.0-SNAPSHOT'
 }
 
diff --git a/spark-waterdog/build.gradle b/spark-waterdog/build.gradle
index 9eb4a53..7a25462 100644
--- a/spark-waterdog/build.gradle
+++ b/spark-waterdog/build.gradle
@@ -9,8 +9,9 @@ tasks.withType(JavaCompile) {
 
 dependencies {
     implementation project(':spark-common')
-    implementation 'net.kyori:adventure-text-serializer-legacy:4.13.1'
-    compileOnly 'dev.waterdog.waterdogpe:waterdog:1.2.3'
+    compileOnly('dev.waterdog.waterdogpe:waterdog:1.2.3') {
+        exclude group: 'com.nukkitx.protocol'
+    }
 }
 
 repositories {