diff --git a/src/test/java/cheattest/cheatsystest.java b/src/test/java/cheattest/cheatsystest.java
index 98ebf73..4f3a035 100644
--- a/src/test/java/cheattest/cheatsystest.java
+++ b/src/test/java/cheattest/cheatsystest.java
@@ -30,7 +30,6 @@
 import entity.config;
 
 public class cheatsystest {
-
     private static EntityManagerFactory emf;
     private static EntityManager em;
     private static Cheat cheat;
@@ -44,15 +43,19 @@
         Map<String, Object> props = new HashMap<>();
         config cfg = new config();
         String jdbcUrl = String.format(
-                "jdbc:mysql://%s/%s?useSSL=false&serverTimezone=UTC",
-                cfg.SqlURL, cfg.TestDatabase);
+            "jdbc:mysql://%s/%s?useSSL=false&serverTimezone=UTC",
+            cfg.SqlURL, cfg.TestDatabase);
         props.put("javax.persistence.jdbc.url", jdbcUrl);
         props.put("javax.persistence.jdbc.user", cfg.SqlUsername);
         props.put("javax.persistence.jdbc.password", cfg.SqlPassword);
         props.put("javax.persistence.jdbc.driver", "com.mysql.cj.jdbc.Driver");
         emf = Persistence.createEntityManagerFactory("myPersistenceUnit", props);
         em = emf.createEntityManager();
-        cheat = new Cheat(emf);
+        cheat = new Cheat();
+        // 通过反射注入 entityManager
+        java.lang.reflect.Field f = Cheat.class.getDeclaredField("entityManager");
+        f.setAccessible(true);
+        f.set(cheat, em);
     }
 
     @AfterAll
@@ -85,7 +88,7 @@
         if (em != null && em.isOpen()) {
             em.getTransaction().begin();
             List<String> insertedUserIds = em.createQuery("SELECT u.userid FROM User u WHERE u.accountstate = true", String.class)
-                    .getResultList();
+                                             .getResultList();
             for (String userId : insertedUserIds) {
                 User user = em.find(User.class, userId);
                 if (user != null) {
@@ -96,58 +99,54 @@
         }
 
         // 关闭 EntityManager 和 EntityManagerFactory
-        if (em != null && em.isOpen()) {
-            em.close();
-        }
-        if (emf != null && emf.isOpen()) {
-            emf.close();
-        }
+        if (em != null && em.isOpen()) em.close();
+        if (emf != null && emf.isOpen()) emf.close();
     }
 
     @TestFactory
     Collection<DynamicTest> testAddAppeal() {
         // 查询数据库中已存在的一个用户
         String userId = em.createQuery("SELECT u.userid FROM User u", String.class)
-                .setMaxResults(1)
-                .getSingleResult();
+                          .setMaxResults(1)
+                          .getSingleResult();
 
         return IntStream.range(0, 10)
-                .mapToObj(i -> DynamicTest.dynamicTest("AddAppeal test #" + i, () -> {
-            // 插入 Appeal
-            String appealId = UUID.randomUUID().toString();
-            Appeal appeal = new Appeal();
-            appeal.appealid = appealId;
-            appeal.appealuserid = userId;
-            appeal.content = "Test appeal content " + i;
-            appeal.fileURL = "http://example.com/file" + i;
-            appeal.status = 0;
+            .mapToObj(i -> DynamicTest.dynamicTest("AddAppeal test #" + i, () -> {
+                // 插入 Appeal
+                String appealId = UUID.randomUUID().toString();
+                Appeal appeal = new Appeal();
+                appeal.appealid = appealId;
+                appeal.appealuserid = userId;
+                appeal.content = "Test appeal content " + i;
+                appeal.fileURL = "http://example.com/file" + i;
+                appeal.status = 0;
 
-            em.getTransaction().begin();
-            boolean result = cheat.AddAppeal(appeal);
-            em.getTransaction().commit();
+                em.getTransaction().begin();
+                boolean result = cheat.AddAppeal(appeal);
+                em.getTransaction().commit();
 
-            Assertions.assertTrue(result, "AddAppeal 应返回 true");
+                Assertions.assertTrue(result, "AddAppeal 应返回 true");
 
-            // 验证 Appeal 是否插入
-            Appeal fetched = em.find(Appeal.class, appealId);
-            Assertions.assertNotNull(fetched, "数据库应能查到新插入的 Appeal");
-            Assertions.assertEquals(userId, fetched.appealuserid);
-            Assertions.assertEquals("Test appeal content " + i, fetched.content);
+                // 验证 Appeal 是否插入
+                Appeal fetched = em.find(Appeal.class, appealId);
+                Assertions.assertNotNull(fetched, "数据库应能查到新插入的 Appeal");
+                Assertions.assertEquals(userId, fetched.appealuserid);
+                Assertions.assertEquals("Test appeal content " + i, fetched.content);
 
-            // 清理
-            em.getTransaction().begin();
-            em.remove(fetched);
-            em.getTransaction().commit();
-        }))
-                .collect(Collectors.toList());
+                // 清理
+                em.getTransaction().begin();
+                em.remove(fetched);
+                em.getTransaction().commit();
+            }))
+            .collect(Collectors.toList());
     }
 
     @TestFactory
     Collection<DynamicTest> testGetAppeal() {
         // 查询数据库中已存在的10个Appeal
         List<Appeal> appeals = em.createQuery("SELECT a FROM Appeal a", Appeal.class)
-                .setMaxResults(10)
-                .getResultList();
+                             .setMaxResults(10)
+                             .getResultList();
 
         List<DynamicTest> tests = new ArrayList<>();
 
@@ -179,140 +178,140 @@
     Collection<DynamicTest> testGetAppealList() {
         // 查询数据库中已存在的一个用户
         String userId = em.createQuery("SELECT u.userid FROM User u", String.class)
-                .setMaxResults(1)
-                .getSingleResult();
+                      .setMaxResults(1)
+                      .getSingleResult();
         // 用于记录测试过程中插入的 Appeal ID
 
         return IntStream.range(0, 10)
-                .mapToObj(i -> DynamicTest.dynamicTest("GetAppealList test #" + i, () -> {
-            // 插入一个新的 Appeal
-            String appealId = UUID.randomUUID().toString();
-            Appeal appeal = new Appeal();
-            appeal.appealid = appealId;
-            appeal.appealuserid = userId;
-            appeal.content = "GetAppealList test content " + i;
-            appeal.fileURL = "http://example.com/file" + i;
-            appeal.status = 0;
+            .mapToObj(i -> DynamicTest.dynamicTest("GetAppealList test #" + i, () -> {
+                // 插入一个新的 Appeal
+                String appealId = UUID.randomUUID().toString();
+                Appeal appeal = new Appeal();
+                appeal.appealid = appealId;
+                appeal.appealuserid = userId;
+                appeal.content = "GetAppealList test content " + i;
+                appeal.fileURL = "http://example.com/file" + i;
+                appeal.status = 0;
 
-            em.getTransaction().begin();
-            em.persist(appeal);
-            em.getTransaction().commit();
+                em.getTransaction().begin();
+                em.persist(appeal);
+                em.getTransaction().commit();
 
-            // 记录插入的 Appeal ID
-            insertedAppealIds.add(appealId);
+                // 记录插入的 Appeal ID
+                insertedAppealIds.add(appealId);
 
-            // 调用 GetAppealList 并验证
-            Appeal[] appeals = cheat.GetAppealList();
-            Assertions.assertNotNull(appeals, "GetAppealList 应返回非空");
+                // 调用 GetAppealList 并验证
+                Appeal[] appeals = cheat.GetAppealList();
+                Assertions.assertNotNull(appeals, "GetAppealList 应返回非空");
 
-            // 检查整个列表是否包含所有插入的数据
-            for (String id : insertedAppealIds) {
-                boolean found = Arrays.stream(appeals)
-                        .anyMatch(a -> a.appealid.equals(id));
-                Assertions.assertTrue(found, "GetAppealList 应包含插入的 Appeal ID: " + id);
-            }
-        }))
-                .collect(Collectors.toList());
+                // 检查整个列表是否包含所有插入的数据
+                for (String id : insertedAppealIds) {
+                    boolean found = Arrays.stream(appeals)
+                                           .anyMatch(a -> a.appealid.equals(id));
+                    Assertions.assertTrue(found, "GetAppealList 应包含插入的 Appeal ID: " + id);
+                }
+            }))
+            .collect(Collectors.toList());
     }
 
     @TestFactory
     Collection<DynamicTest> testHandleAppeal() {
         // 查询数据库中已存在的一个用户
         String userId = em.createQuery("SELECT u.userid FROM User u", String.class)
-                .setMaxResults(1)
-                .getSingleResult();
+                          .setMaxResults(1)
+                          .getSingleResult();
 
         return IntStream.range(0, 10)
-                .mapToObj(i -> DynamicTest.dynamicTest("HandleAppeal test #" + i, () -> {
-            // 插入一个新的 Appeal
-            String appealId = UUID.randomUUID().toString();
-            Appeal appeal = new Appeal();
-            appeal.appealid = appealId;
-            appeal.appealuserid = userId;
-            appeal.content = "HandleAppeal test content " + i;
-            appeal.fileURL = "http://example.com/file" + i;
-            appeal.status = 0;
+            .mapToObj(i -> DynamicTest.dynamicTest("HandleAppeal test #" + i, () -> {
+                // 插入一个新的 Appeal
+                String appealId = UUID.randomUUID().toString();
+                Appeal appeal = new Appeal();
+                appeal.appealid = appealId;
+                appeal.appealuserid = userId;
+                appeal.content = "HandleAppeal test content " + i;
+                appeal.fileURL = "http://example.com/file" + i;
+                appeal.status = 0;
 
-            em.getTransaction().begin();
-            em.persist(appeal);
-            em.getTransaction().commit();
-
-            // 如果 newStatus 为 1，先将用户的 account_status 设置为 true
-            if (i % 2 == 0) { // 偶数索引对应 newStatus = 1
                 em.getTransaction().begin();
-                User user = em.find(User.class, userId);
-                Assertions.assertNotNull(user, "数据库应能查到相关用户");
-                user.accountstate = true; // 设置为 true
+                em.persist(appeal);
                 em.getTransaction().commit();
-            }
 
-            // 测试处理申诉
-            int newStatus = (i % 2 == 0) ? 1 : 2; // 偶数索引通过申诉，奇数索引拒绝申诉
-            boolean result = cheat.HandleAppeal(appealId, newStatus);
-            Assertions.assertTrue(result, "HandleAppeal 应返回 true");
+                // 如果 newStatus 为 1，先将用户的 account_status 设置为 true
+                if (i % 2 == 0) { // 偶数索引对应 newStatus = 1
+                    em.getTransaction().begin();
+                    User user = em.find(User.class, userId);
+                    Assertions.assertNotNull(user, "数据库应能查到相关用户");
+                    user.accountstate = true; // 设置为 true
+                    em.getTransaction().commit();
+                }
 
-            // 验证 Appeal 状态是否更新
-            Appeal updatedAppeal = em.find(Appeal.class, appealId);
-            Assertions.assertNotNull(updatedAppeal, "数据库应能查到更新后的 Appeal");
-            Assertions.assertEquals(newStatus, updatedAppeal.status, "Appeal 的状态应被更新为: " + newStatus);
+                // 测试处理申诉
+                int newStatus = (i % 2 == 0) ? 1 : 2; // 偶数索引通过申诉，奇数索引拒绝申诉
+                boolean result = cheat.HandleAppeal(appealId, newStatus);
+                Assertions.assertTrue(result, "HandleAppeal 应返回 true");
 
-            // 如果申诉通过，验证用户的 account_status 是否被设置为 false
-            if (newStatus == 1) {
-                User user = em.find(User.class, userId);
-                Assertions.assertNotNull(user, "数据库应能查到相关用户");
-                Assertions.assertFalse(user.accountstate, "通过申诉后用户的 account_status 应为 false");
-            }
+                // 验证 Appeal 状态是否更新
+                Appeal updatedAppeal = em.find(Appeal.class, appealId);
+                Assertions.assertNotNull(updatedAppeal, "数据库应能查到更新后的 Appeal");
+                Assertions.assertEquals(newStatus, updatedAppeal.status, "Appeal 的状态应被更新为: " + newStatus);
 
-            // 清理测试数据
-            em.getTransaction().begin();
-            em.remove(updatedAppeal);
-            em.getTransaction().commit();
-        }))
-                .collect(Collectors.toList());
+                // 如果申诉通过，验证用户的 account_status 是否被设置为 false
+                if (newStatus == 1) {
+                    User user = em.find(User.class, userId);
+                    Assertions.assertNotNull(user, "数据库应能查到相关用户");
+                    Assertions.assertFalse(user.accountstate, "通过申诉后用户的 account_status 应为 false");
+                }
+
+                // 清理测试数据
+                em.getTransaction().begin();
+                em.remove(updatedAppeal);
+                em.getTransaction().commit();
+            }))
+            .collect(Collectors.toList());
     }
 
     @TestFactory
     Collection<DynamicTest> testGetFakeSeed() {
         return IntStream.range(0, 10)
-                .mapToObj(i -> DynamicTest.dynamicTest("GetFakeSeed test #" + i, () -> {
-            // 插入一个新的假种子
-            String seedId = UUID.randomUUID().toString();
-            String userId = em.createQuery("SELECT u.userid FROM User u", String.class)
-                    .setMaxResults(1)
-                    .getSingleResult();
+            .mapToObj(i -> DynamicTest.dynamicTest("GetFakeSeed test #" + i, () -> {
+                // 插入一个新的假种子
+                String seedId = UUID.randomUUID().toString();
+                String userId = em.createQuery("SELECT u.userid FROM User u", String.class)
+                                  .setMaxResults(1)
+                                  .getSingleResult();
 
-            Seed seed = new Seed();
-            seed.seedid = seedId;
-            seed.seeduserid = userId;
-            seed.faketime = 100 + i; // 设置为大于 config.FakeTime 的值
-            seed.lastfakecheck = new Date();
-            seed.outurl = "http://example.com/fake" + i;
-            seed.title = "Fake Seed " + i;
-            seed.subtitle = "Subtitle " + i;
-            seed.seedsize = "100MB";
-            seed.seedtag = "test,fake";
-            seed.downloadtimes = 0;
-            seed.url = "http://example.com/seed" + i;
+                Seed seed = new Seed();
+                seed.seedid = seedId;
+                seed.seeduserid = userId;
+                seed.faketime = 100 + i; // 设置为大于 config.FakeTime 的值
+                seed.lastfakecheck = new Date();
+                seed.outurl = "http://example.com/fake" + i;
+                seed.title = "Fake Seed " + i;
+                seed.subtitle = "Subtitle " + i;
+                seed.seedsize = "100MB";
+                seed.seedtag = "test,fake";
+                seed.downloadtimes = 0;
+                seed.url = "http://example.com/seed" + i;
 
-            em.getTransaction().begin();
-            em.persist(seed);
-            em.getTransaction().commit();
+                em.getTransaction().begin();
+                em.persist(seed);
+                em.getTransaction().commit();
 
-            // 记录插入的 Seed ID
-            insertedSeedIds.add(seedId);
+                // 记录插入的 Seed ID
+                insertedSeedIds.add(seedId);
 
-            // 调用 GetFakeSeed 并验证
-            Pair<String, String>[] fakeSeeds = cheat.GetFakeSeed();
-            Assertions.assertNotNull(fakeSeeds, "GetFakeSeed 应返回非空");
+                // 调用 GetFakeSeed 并验证
+                Pair<String, String>[] fakeSeeds = cheat.GetFakeSeed();
+                Assertions.assertNotNull(fakeSeeds, "GetFakeSeed 应返回非空");
 
-            // 验证返回的假种子列表是否包含所有插入的假种子
-            for (String id : insertedSeedIds) {
-                boolean found = Arrays.stream(fakeSeeds)
-                        .anyMatch(pair -> pair.getLeft().equals(id));
-                Assertions.assertTrue(found, "GetFakeSeed 应包含插入的假种子 ID: " + id);
-            }
-        }))
-                .collect(Collectors.toList());
+                // 验证返回的假种子列表是否包含所有插入的假种子
+                for (String id : insertedSeedIds) {
+                    boolean found = Arrays.stream(fakeSeeds)
+                                           .anyMatch(pair -> pair.getLeft().equals(id));
+                    Assertions.assertTrue(found, "GetFakeSeed 应包含插入的假种子 ID: " + id);
+                }
+            }))
+            .collect(Collectors.toList());
     }
 
     @TestFactory
@@ -320,47 +319,47 @@
         List<String> insertedUserIds = new ArrayList<>(); // 用于记录插入的用户 ID
 
         return IntStream.range(0, 10)
-                .mapToObj(i -> DynamicTest.dynamicTest("GetPunishedUserList test #" + i, () -> {
-            // 插入一个新的用户，accountstate 设置为 true
-            String userId = UUID.randomUUID().toString();
-            User user = new User();
-            user.userid = userId;
-            user.email = "test" + i + "@example.com";
-            user.username = "TestUser" + i;
-            user.password = "password" + i;
-            user.sex = "M";
-            user.detectedCount = 0;
-            user.lastDetectedTime = new Date();
-            user.school = "TestSchool";
-            user.pictureurl = "http://example.com/avatar" + i;
-            user.profile = "Test profile " + i;
-            user.accountstate = true; // 设置为 true
-            user.invitetimes = 5;
+            .mapToObj(i -> DynamicTest.dynamicTest("GetPunishedUserList test #" + i, () -> {
+                // 插入一个新的用户，accountstate 设置为 true
+                String userId = UUID.randomUUID().toString();
+                User user = new User();
+                user.userid = userId;
+                user.email = "test" + i + "@example.com";
+                user.username = "TestUser" + i;
+                user.password = "password" + i;
+                user.sex = "M";
+                user.detectedCount = 0;
+                user.lastDetectedTime = new Date();
+                user.school = "TestSchool";
+                user.pictureurl = "http://example.com/avatar" + i;
+                user.profile = "Test profile " + i;
+                user.accountstate = true; // 设置为 true
+                user.invitetimes = 5;
 
-            // 创建并设置 UserPT 实例
-            UserPT userPT = new UserPT();
-            userPT.user = user; // 关联 User 实例
-            user.userPT = userPT;
+                // 创建并设置 UserPT 实例
+                UserPT userPT = new UserPT();
+                userPT.user = user; // 关联 User 实例
+                user.userPT = userPT;
 
-            em.getTransaction().begin();
-            em.persist(user);
-            em.persist(userPT); // 持久化 UserPT 实例
-            em.getTransaction().commit();
+                em.getTransaction().begin();
+                em.persist(user);
+                em.persist(userPT); // 持久化 UserPT 实例
+                em.getTransaction().commit();
 
-            // 记录插入的用户 ID
-            insertedUserIds.add(userId);
+                // 记录插入的用户 ID
+                insertedUserIds.add(userId);
 
-            // 调用 GetPunishedUserList 并验证
-            String[] punishedUsers = cheat.GetPunishedUserList();
-            Assertions.assertNotNull(punishedUsers, "GetPunishedUserList 应返回非空");
+                // 调用 GetPunishedUserList 并验证
+                String[] punishedUsers = cheat.GetPunishedUserList();
+                Assertions.assertNotNull(punishedUsers, "GetPunishedUserList 应返回非空");
 
-            // 验证返回的用户列表是否包含所有插入的用户
-            for (String id : insertedUserIds) {
-                boolean found = Arrays.stream(punishedUsers).anyMatch(returnedId -> returnedId.equals(id));
-                Assertions.assertTrue(found, "GetPunishedUserList 应包含插入的用户 ID: " + id);
-            }
-        }))
-                .collect(Collectors.toList());
+                // 验证返回的用户列表是否包含所有插入的用户
+                for (String id : insertedUserIds) {
+                    boolean found = Arrays.stream(punishedUsers).anyMatch(returnedId -> returnedId.equals(id));
+                    Assertions.assertTrue(found, "GetPunishedUserList 应包含插入的用户 ID: " + id);
+                }
+            }))
+            .collect(Collectors.toList());
     }
 
     @TestFactory
@@ -368,76 +367,76 @@
         List<String> insertedUserIds = new ArrayList<>(); // 用于记录插入的用户 ID
 
         return IntStream.range(0, 10)
-                .mapToObj(i -> DynamicTest.dynamicTest("PunishUser test #" + i, () -> {
-            // 配置参数
-            int cheatTime = config.CheatTime;
-            int fakeTime = config.FakeTime;
+            .mapToObj(i -> DynamicTest.dynamicTest("PunishUser test #" + i, () -> {
+                // 配置参数
+                int cheatTime = config.CheatTime;
+                int fakeTime = config.FakeTime;
 
-            // 插入用户 1（作弊用户）
-            String userId1 = UUID.randomUUID().toString();
-            User user1 = new User();
-            user1.userid = userId1;
-            user1.email = "cheater" + i + "_" + UUID.randomUUID().toString() + "@example.com"; // 确保唯一性
-            user1.username = "Cheater" + i;
-            user1.password = "password" + i;
-            user1.sex = "M";
-            user1.detectedCount = cheatTime + 1; // detectedCount 超过 cheatTime
-            user1.fakeDetectedCount = 0;
-            user1.lastDetectedTime = new Date();
-            user1.fakeLastDetectedTime = new Date();
-            user1.accountstate = false; // 初始状态为未封禁
-            user1.invitetimes = 5;
+                // 插入用户 1（作弊用户）
+                String userId1 = UUID.randomUUID().toString();
+                User user1 = new User();
+                user1.userid = userId1;
+                user1.email = "cheater" + i + "_" + UUID.randomUUID().toString() + "@example.com"; // 确保唯一性
+                user1.username = "Cheater" + i;
+                user1.password = "password" + i;
+                user1.sex = "M";
+                user1.detectedCount = cheatTime + 1; // detectedCount 超过 cheatTime
+                user1.fakeDetectedCount = 0;
+                user1.lastDetectedTime = new Date();
+                user1.fakeLastDetectedTime = new Date();
+                user1.accountstate = false; // 初始状态为未封禁
+                user1.invitetimes = 5;
 
-            // 创建并设置 UserPT 实例
-            UserPT userPT1 = new UserPT();
-            userPT1.user = user1; // 关联 User 实例
-            user1.userPT = userPT1;
+                // 创建并设置 UserPT 实例
+                UserPT userPT1 = new UserPT();
+                userPT1.user = user1; // 关联 User 实例
+                user1.userPT = userPT1;
 
-            // 插入用户 2（非作弊用户）
-            String userId2 = UUID.randomUUID().toString();
-            User user2 = new User();
-            user2.userid = userId2;
-            user2.email = "normal" + i + "_" + UUID.randomUUID().toString() + "@example.com"; // 确保唯一性
-            user2.username = "NormalUser" + i;
-            user2.password = "password" + i;
-            user2.sex = "F";
-            user2.detectedCount = 0;
-            user2.fakeDetectedCount = fakeTime - 1; // fakeDetectedCount 未超过 fakeTime
-            user2.lastDetectedTime = new Date();
-            user2.fakeLastDetectedTime = new Date();
-            user2.accountstate = false; // 初始状态为未封禁
-            user2.invitetimes = 5;
+                // 插入用户 2（非作弊用户）
+                String userId2 = UUID.randomUUID().toString();
+                User user2 = new User();
+                user2.userid = userId2;
+                user2.email = "normal" + i + "_" + UUID.randomUUID().toString() + "@example.com"; // 确保唯一性
+                user2.username = "NormalUser" + i;
+                user2.password = "password" + i;
+                user2.sex = "F";
+                user2.detectedCount = 0;
+                user2.fakeDetectedCount = fakeTime - 1; // fakeDetectedCount 未超过 fakeTime
+                user2.lastDetectedTime = new Date();
+                user2.fakeLastDetectedTime = new Date();
+                user2.accountstate = false; // 初始状态为未封禁
+                user2.invitetimes = 5;
 
-            // 创建并设置 UserPT 实例
-            UserPT userPT2 = new UserPT();
-            userPT2.user = user2; // 关联 User 实例
-            user2.userPT = userPT2;
+                // 创建并设置 UserPT 实例
+                UserPT userPT2 = new UserPT();
+                userPT2.user = user2; // 关联 User 实例
+                user2.userPT = userPT2;
 
-            em.getTransaction().begin();
-            em.persist(user1);
-            em.persist(userPT1); // 持久化 UserPT 实例
-            em.persist(user2);
-            em.persist(userPT2); // 持久化 UserPT 实例
-            em.getTransaction().commit();
+                em.getTransaction().begin();
+                em.persist(user1);
+                em.persist(userPT1); // 持久化 UserPT 实例
+                em.persist(user2);
+                em.persist(userPT2); // 持久化 UserPT 实例
+                em.getTransaction().commit();
 
-            // 记录插入的用户 ID
-            insertedUserIds.add(userId1);
-            insertedUserIds.add(userId2);
+                // 记录插入的用户 ID
+                insertedUserIds.add(userId1);
+                insertedUserIds.add(userId2);
 
-            // 调用 PunishUser 方法
-            cheat.PunishUser();
+                // 调用 PunishUser 方法
+                cheat.PunishUser();
 
-            // 验证用户 1 是否被封禁
-            User punishedUser1 = em.find(User.class, userId1);
-            Assertions.assertNotNull(punishedUser1, "数据库应能查到用户 1");
-            Assertions.assertTrue(punishedUser1.accountstate, "作弊用户应被封禁");
+                // 验证用户 1 是否被封禁
+                User punishedUser1 = em.find(User.class, userId1);
+                Assertions.assertNotNull(punishedUser1, "数据库应能查到用户 1");
+                Assertions.assertTrue(punishedUser1.accountstate, "作弊用户应被封禁");
 
-            // 验证用户 2 是否未被封禁
-            User punishedUser2 = em.find(User.class, userId2);
-            Assertions.assertNotNull(punishedUser2, "数据库应能查到用户 2");
-            Assertions.assertFalse(punishedUser2.accountstate, "非作弊用户不应被封禁");
-        }))
-                .collect(Collectors.toList());
+                // 验证用户 2 是否未被封禁
+                User punishedUser2 = em.find(User.class, userId2);
+                Assertions.assertNotNull(punishedUser2, "数据库应能查到用户 2");
+                Assertions.assertFalse(punishedUser2.accountstate, "非作弊用户不应被封禁");
+            }))
+            .collect(Collectors.toList());
     }
 
     // @TestFactory
@@ -445,6 +444,7 @@
     //     List<String> insertedUserIds = new ArrayList<>(); // 用于记录插入的用户 ID
     //     List<String> insertedSeedIds = new ArrayList<>(); // 用于记录插入的种子 ID
     //     List<String> insertedTransIds = new ArrayList<>(); // 用于记录插入的传输记录 ID
+
     //     return IntStream.range(0, 10)
     //         .mapToObj(i -> DynamicTest.dynamicTest("DetectTrans test #" + i, () -> {
     //             // 插入上传用户
@@ -461,10 +461,12 @@
     //             uploader.fakeLastDetectedTime = new Date();
     //             uploader.accountstate = false;
     //             uploader.invitetimes = 5;
+
     //             // 创建并设置 UserPT 实例
     //             UserPT uploaderPT = new UserPT();
     //             uploaderPT.user = uploader; // 关联 User 实例
     //             uploader.userPT = uploaderPT;
+
     //             // 插入下载用户
     //             String downloaderId = UUID.randomUUID().toString();
     //             User downloader = new User();
@@ -479,10 +481,12 @@
     //             downloader.fakeLastDetectedTime = new Date();
     //             downloader.accountstate = false;
     //             downloader.invitetimes = 5;
+
     //             // 创建并设置 UserPT 实例
     //             UserPT downloaderPT = new UserPT();
     //             downloaderPT.user = downloader; // 关联 User 实例
     //             downloader.userPT = downloaderPT;
+
     //             em.getTransaction().begin();
     //             em.persist(uploader);
     //             em.persist(uploaderPT); // 持久化 UserPT 实例
@@ -491,6 +495,7 @@
     //             em.getTransaction().commit();
     //             insertedUserIds.add(uploaderId);
     //             insertedUserIds.add(downloaderId);
+
     //             // 插入种子
     //             String seedId = UUID.randomUUID().toString();
     //             Seed seed = new Seed();
@@ -505,10 +510,12 @@
     //             seed.seedtag = "test";
     //             seed.downloadtimes = 0;
     //             seed.url = "http://example.com/seed" + i;
+
     //             em.getTransaction().begin();
     //             em.persist(seed);
     //             em.getTransaction().commit();
     //             insertedSeedIds.add(seedId);
+
     //             // 插入正常和异常的传输记录
     //             List<TransRecord> transRecords = new ArrayList<>();
     //             for (int j = 0; j < 15; j++) {
@@ -521,14 +528,17 @@
     //                 transRecord.download = (j < 13) ? 90 : 10; // 异常数据的上传量远大于下载量
     //                 transRecord.maxupload = 200;
     //                 transRecord.maxdownload = 200;
+
     //                 em.getTransaction().begin();
     //                 em.persist(transRecord);
     //                 em.getTransaction().commit();
     //                 insertedTransIds.add(transRecord.taskid);
     //                 transRecords.add(transRecord);
     //             }
+
     //             // 调用 DetectTrans 方法
     //             cheat.DetectTrans();
+
     //             // 验证下载用户的 detectedCount 是否增加
     //             User detectedDownloader = em.find(User.class, downloaderId);
     //             Assertions.assertNotNull(detectedDownloader, "数据库应能查到上传用户");
diff --git a/src/test/java/databasetest/databasesystest.java b/src/test/java/databasetest/databasesystest.java
index f4b22f1..f802360 100644
--- a/src/test/java/databasetest/databasesystest.java
+++ b/src/test/java/databasetest/databasesystest.java
@@ -45,7 +45,10 @@
         props.put("javax.persistence.jdbc.driver", "com.mysql.cj.jdbc.Driver");
         emf = Persistence.createEntityManagerFactory("myPersistenceUnit", props);
         em = emf.createEntityManager();
-        db = new Database1(emf);
+        db = new Database1();
+        java.lang.reflect.Field f = Database1.class.getDeclaredField("entitymanager");
+        f.setAccessible(true);
+        f.set(db, em);
         testUserIds = new ArrayList<>();
         testEmails = new ArrayList<>();
         for (int i = 0; i < 10; i++) {