diff --git a/src/test/java/com/example/myproject/controller/CommentControllerTest.java b/src/test/java/com/example/myproject/controller/CommentControllerTest.java
deleted file mode 100644
index 9dedd29..0000000
--- a/src/test/java/com/example/myproject/controller/CommentControllerTest.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.entity.Comments;
-import com.example.myproject.entity.Users;
-import com.example.myproject.service.CommentService;
-import com.example.myproject.utils.Result;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.*;
-import org.springframework.beans.factory.annotation.Autowired;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.mockito.Mockito.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-class CommentControllerTest {
-
-    @InjectMocks
-    private CommentController commentController;
-    @Mock
-    private CommentService commentService;
-
-    @Mock
-    private Users mockUser;
-
-    @BeforeEach
-    void setup() {
-        MockitoAnnotations.openMocks(this);
-    }
-
-    // 测试添加评论
-    @Test
-    void addCommentTest() {
-        Long postId = 1L;
-        Comments comment = new Comments();
-        comment.setUserId(1L);
-        comment.setContent("This is a comment");
-        comment.setParentComment(0L);
-        // 模拟服务层的行为
-        doNothing().when(commentService).addComment(eq(postId), eq(comment));
-
-        // 调用控制器的方法
-        String result = commentController.addComment(postId, comment);
-
-        // 验证返回的结果
-        assertEquals("Comment added successfully!", result);
-
-        // 验证服务方法是否被调用
-        verify(commentService, times(1)).addComment(eq(postId), eq(comment));
-    }
-
-    // 测试获取评论
-    @Test
-    void getCommentsByPostIdTest() {
-        Long postId = 1L;
-
-        // 模拟评论数据
-        Map<String, Object> commentData = new HashMap<>();
-        commentData.put("commentId", 1L);
-        commentData.put("content", "This is a comment");
-        commentData.put("userId", 1L);
-        commentData.put("nickname", "user1");
-
-        // 模拟服务层的行为
-        when(commentService.getCommentsByPostId(postId)).thenReturn(List.of(commentData));
-
-        // 调用控制器的方法
-        List<Map<String, Object>> comments = commentController.getCommentsByPostId(postId);
-
-        // 验证返回的评论数据
-        assertEquals(1, comments.size());
-        assertEquals("This is a comment", comments.get(0).get("content"));
-        assertEquals("user1", comments.get(0).get("nickname"));
-
-        // 验证服务方法是否被调用
-        verify(commentService, times(1)).getCommentsByPostId(postId);
-    }
-}
diff --git a/src/test/java/com/example/myproject/controller/DynamicControllerTest.java b/src/test/java/com/example/myproject/controller/DynamicControllerTest.java
deleted file mode 100644
index 7392162..0000000
--- a/src/test/java/com/example/myproject/controller/DynamicControllerTest.java
+++ /dev/null
@@ -1,168 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.controller.DynamicController;
-import com.example.myproject.service.DynamicService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.springframework.http.ResponseEntity;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.mockito.Mockito.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-class DynamicControllerTest {
-
-    @InjectMocks
-    private DynamicController dynamicController;
-
-    @Mock
-    private DynamicService dynamicService;
-
-    @BeforeEach
-    void setup() {
-        MockitoAnnotations.openMocks(this);
-    }
-
-    // 测试创建动态接口
-    @Test
-    void testCreateDynamic() {
-        Long userId = 1L;
-        String content = "This is a test dynamic";
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("dynamicId", 123L);
-        mockResponse.put("message", "动态创建成功");
-
-        // 模拟 dynamicService.createDynamic 返回
-        when(dynamicService.createDynamic(userId, null, content, null)).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        Map<String, Object> responseMap = dynamicController.createDynamic(userId, null, content, null);
-        ResponseEntity<Map<String, Object>> responseEntity = ResponseEntity.ok(responseMap);
-
-        // 验证返回的结果
-        assertEquals(200, responseEntity.getStatusCodeValue());
-        assertEquals("动态创建成功", responseEntity.getBody().get("message"));
-        assertEquals(123L, responseEntity.getBody().get("dynamicId"));
-    }
-
-
-    // 测试删除动态接口
-    @Test
-    void testDeleteDynamic() {
-        Long dynamicId = 1L;
-        // 模拟 dynamicService.deleteDynamic 方法行为
-        doNothing().when(dynamicService).deleteDynamic(dynamicId);
-
-        // 调用控制器方法
-        ResponseEntity<String> response = dynamicController.deleteDynamic(dynamicId);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("动态删除成功", response.getBody());
-    }
-
-    // 测试添加评论接口
-    @Test
-    void testAddComment() {
-        Long userId = 1L;
-        Long dynamicId = 1L;
-        Map<String, String> commentContent = new HashMap<>();
-        commentContent.put("content", "This is a test comment");
-
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("comment_id", 101L);
-        mockResponse.put("message", "评论成功");
-
-        // 模拟 dynamicService.addComment 返回
-        when(dynamicService.addComment(userId, dynamicId, "This is a test comment")).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        ResponseEntity<Map<String, Object>> response = dynamicController.addComment(userId, dynamicId, commentContent);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("评论成功", response.getBody().get("message"));
-        assertEquals(101L, response.getBody().get("comment_id"));
-    }
-
-    // 测试获取用户动态接口
-    @Test
-    void testGetAllUserDynamics() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("dynamic", "mock_dynamic_data");
-
-        // 模拟 dynamicService.getAllUserDynamics 返回
-        when(dynamicService.getAllUserDynamics(userId)).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        ResponseEntity<Map<String, Object>> response = dynamicController.getAllUserDynamics(userId);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("success", response.getBody().get("status"));
-        assertNotNull(response.getBody().get("dynamic"));
-    }
-
-    // 测试获取所有好友动态接口
-    @Test
-    void testGetAllUserAndFriendsDynamics() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("dynamic", "mock_friend_dynamic_data");
-
-        // 模拟 dynamicService.getAllUserAndFriendsDynamics 返回
-        when(dynamicService.getAllUserAndFriendsDynamics(anyList())).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        ResponseEntity<Map<String, Object>> response = dynamicController.getAllUserAndFriendsDynamics(userId);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("success", response.getBody().get("status"));
-        assertNotNull(response.getBody().get("dynamic"));
-    }
-
-    // 测试点赞动态接口
-    @Test
-    void testLikeDynamic() {
-        Map<String, Long> request = new HashMap<>();
-        request.put("userId", 1L);
-        request.put("dynamicId", 1L);
-
-        // 模拟 dynamicService.likeDynamic 返回
-        when(dynamicService.likeDynamic(1L, 1L)).thenReturn(true);
-
-        // 调用控制器方法
-        ResponseEntity<String> response = dynamicController.likeDynamic(request);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("Like successful", response.getBody());
-    }
-
-    // 测试取消点赞接口
-    @Test
-    void testUnlikeDynamic() {
-        Map<String, Long> request = new HashMap<>();
-        request.put("userId", 1L);
-        request.put("dynamicId", 1L);
-
-        // 模拟 dynamicService.unlikeDynamic 返回
-        when(dynamicService.unlikeDynamic(1L, 1L)).thenReturn(true);
-
-        // 调用控制器方法
-        ResponseEntity<String> response = dynamicController.unlikeDynamic(request);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("Unlike successful", response.getBody());
-    }
-}
diff --git a/src/test/java/com/example/myproject/controller/GroupControllerTest.java b/src/test/java/com/example/myproject/controller/GroupControllerTest.java
deleted file mode 100644
index d8c8c2c..0000000
--- a/src/test/java/com/example/myproject/controller/GroupControllerTest.java
+++ /dev/null
@@ -1,209 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.controller.GroupController;
-import com.example.myproject.entity.Group;
-import com.example.myproject.entity.GroupComments;
-import com.example.myproject.service.GroupService;
-import com.example.myproject.utils.Result;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.springframework.http.ResponseEntity;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.mockito.Mockito.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-
-class GroupControllerTest {
-
-    @InjectMocks
-    private GroupController groupController;
-
-    @Mock
-    private GroupService groupService;
-
-    @BeforeEach
-    void setup() {
-        MockitoAnnotations.openMocks(this);
-    }
-
-    // 测试创建小组
-
-    @Test
-    void createGroupTest() {
-        Group groupRequest = new Group();
-        groupRequest.setGroupName("Test Group");
-        groupRequest.setDescription("This is a test group");
-
-        // 模拟服务层的返回值
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("group_id", 1L);
-        mockResponse.put("message", "兴趣小组创建成功");
-
-        ResponseEntity<Map<String, Object>> mockResponseEntity = ResponseEntity.ok(mockResponse);
-        when(groupService.createGroup(groupRequest)).thenReturn(mockResponseEntity);
-
-        // 调用控制器的方法
-        ResponseEntity<?> responseEntity = groupController.createGroup(groupRequest);
-        Map<String, Object> resultMap = (Map<String, Object>) responseEntity.getBody();
-        Result<Map<String, Object>> result = Result.success(resultMap, "兴趣小组创建成功");
-
-        // 验证返回的结果
-        assertEquals("200", result.getCode());
-        assertEquals("兴趣小组创建成功", result.getMsg());
-        assertEquals(1L, result.getData().get("group_id"));
-    }
-
-
-    // 测试加入小组接口
-    @Test
-    void testJoinGroup() {
-        Long groupId = 1L;
-        Long userId = 1L;
-
-        // 模拟服务层的返回值
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "成功加入小组");
-        when(groupService.joinGroup(groupId, userId)).thenReturn(ResponseEntity.ok(mockResponse));
-
-        // 调用控制器方法
-        Map<String, Long> requestBody = Map.of("user_id", userId);
-        ResponseEntity<Map<String, Object>> response = groupController.joinGroup(groupId, requestBody);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("success", response.getBody().get("status"));
-        assertEquals("成功加入小组", response.getBody().get("message"));
-    }
-
-    // 测试退出小组接口
-    @Test
-    void testLeaveGroup() {
-        Long groupId = 1L;
-        Long userId = 1L;
-
-        // 模拟服务层的返回值
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "成功退出小组");
-        when(groupService.leaveGroup(groupId, userId)).thenReturn(ResponseEntity.ok(mockResponse));
-
-        // 调用控制器方法
-        Map<String, Long> requestBody = Map.of("user_id", userId);
-        ResponseEntity<Map<String, Object>> response = groupController.leaveGroup(groupId, requestBody);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("success", response.getBody().get("status"));
-        assertEquals("成功退出小组", response.getBody().get("message"));
-    }
-
-    // 测试获取小组成员接口
-    @Test
-    void testGetGroupMembers() {
-        Long groupId = 1L;
-
-        // 模拟服务层的返回值
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("members", "mock_members");
-        when(groupService.getGroupMembers(groupId)).thenReturn(ResponseEntity.ok(mockResponse));
-
-        // 调用控制器方法
-        ResponseEntity<Map<String, Object>> response = groupController.getGroupMembers(groupId);
-
-        // 验证返回的结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("success", response.getBody().get("status"));
-        assertNotNull(response.getBody().get("members"));
-    }
-
-    // 测试发布帖子
-    @Test
-    void createPostTest() {
-        Long groupId = 1L;
-        Long userId = 2L;
-        String postContent = "Test post content";
-        String title = "Test post title";
-
-        // 模拟服务层的返回值
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("post_id", 1L);
-        mockResponse.put("message", "帖子创建成功");
-
-        when(groupService.createPost(groupId, userId, postContent, title, null)).thenReturn(mockResponse);
-
-        // 调用控制器的方法
-        Map<String, Object> result = groupController.createPost(groupId, userId, postContent, title, null).getBody();
-
-        // 验证返回的结果
-        assertEquals("帖子创建成功", result.get("message"));
-        assertEquals(1L, result.get("post_id"));
-    }
-
-    // 测试点赞帖子
-    @Test
-    void likePostTest() {
-        Long postId = 1L;
-
-        // 模拟服务层的返回值
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "点赞成功");
-
-        when(groupService.likePost(postId)).thenReturn(mockResponse);
-
-        // 调用控制器的方法
-        Map<String, Object> resultMap = groupController.likePost(postId).getBody();
-
-        // 验证返回的结果
-        assertEquals("点赞成功", resultMap.get("message"));
-    }
-
-    // 测试取消点赞
-    @Test
-    void unlikePostTest() {
-        Long postId = 1L;
-
-        // 模拟服务层的返回值
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "取消点赞成功");
-
-        when(groupService.unlikePost(postId)).thenReturn(mockResponse);
-
-        // 调用控制器的方法
-        Map<String, Object> resultMap = groupController.unlikePost(postId).getBody();
-
-        // 验证返回的结果
-        assertEquals("取消点赞成功", resultMap.get("message"));
-    }
-
-    // 测试添加评论
-    @Test
-    void addCommentTest() {
-        Long postId = 1L;
-        GroupComments comment = new GroupComments();
-        comment.setUserId(2L);
-        comment.setContent("This is a comment");
-
-        // 模拟服务层的返回值
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "评论成功");
-
-        when(groupService.addComment(postId, comment)).thenReturn(mockResponse);
-
-        // 调用控制器的方法
-        Map<String, Object> resultMap = groupController.addComment(postId, comment).getBody();
-
-        // 验证返回的结果
-        assertEquals("评论成功", resultMap.get("message"));
-    }
-}
diff --git a/src/test/java/com/example/myproject/controller/LevelControllerTest.java b/src/test/java/com/example/myproject/controller/LevelControllerTest.java
deleted file mode 100644
index c3d77b9..0000000
--- a/src/test/java/com/example/myproject/controller/LevelControllerTest.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.controller.LevelController;
-import com.example.myproject.service.LevelService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.springframework.http.ResponseEntity;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.mockito.Mockito.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-class LevelControllerTest {
-
-    @InjectMocks
-    private LevelController levelController;
-
-    @Mock
-    private LevelService levelService;
-
-    @BeforeEach
-    void setup() {
-        MockitoAnnotations.openMocks(this);
-    }
-
-    // 测试获取用户经验接口
-    @Test
-    void testGetExperience() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("current_experience", 1500);
-        mockResponse.put("level", "Intermediate");
-        mockResponse.put("next_level_experience", 2000);
-
-        // 模拟 levelService.getUserExperience 返回
-        when(levelService.getUserExperience(userId)).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        Map<String, Object> response = levelController.getExperience(userId);
-
-        // 验证返回的结果
-        assertEquals(1500, response.get("current_experience"));
-        assertEquals("Intermediate", response.get("level"));
-        assertEquals(2000, response.get("next_level_experience"));
-    }
-
-    // 测试更新用户经验接口
-    @Test
-    void testUpdateExperience() {
-        Long userId = 1L;
-        Integer experience = 500;
-        String source = "Quest";
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "经验更新成功");
-        mockResponse.put("current_experience", 2000);
-
-        Map<String, Object> params = new HashMap<>();
-        params.put("user_id", userId);
-        params.put("experience", experience);
-        params.put("source", source);
-
-        // 模拟 levelService.updateExperience 返回
-        when(levelService.updateExperience(userId, experience, source)).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        Map<String, Object> response = levelController.updateExperience(params);
-
-        // 验证返回的结果
-        assertEquals("success", response.get("status"));
-        assertEquals("经验更新成功", response.get("message"));
-        assertEquals(2000, response.get("current_experience"));
-    }
-
-    // 测试检查用户升级条件接口
-    @Test
-    void testCheckUpgrade() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("can_upgrade", true);
-        mockResponse.put("next_level_experience", 2000);
-        mockResponse.put("current_experience", 1500);
-
-        // 模拟 levelService.checkUpgrade 返回
-        when(levelService.checkUpgrade(userId)).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        Map<String, Object> response = levelController.checkUpgrade(userId);
-
-        // 验证返回的结果
-        assertTrue((Boolean) response.get("can_upgrade"));
-        assertEquals(2000, response.get("next_level_experience"));
-        assertEquals(1500, response.get("current_experience"));
-    }
-
-    // 测试升级用户等级接口
-    @Test
-    void testUpgradeUserLevel() {
-        Long userId = 1L;
-        Boolean canUpgrade = true;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "升级成功");
-        mockResponse.put("new_level", "Advanced");
-
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-        request.put("can_upgrade", canUpgrade);
-
-        // 模拟 levelService.upgradeUserLevel 返回
-        when(levelService.upgradeUserLevel(userId, canUpgrade)).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        Map<String, Object> response = levelController.upgradeUserLevel(request);
-
-        // 验证返回的结果
-        assertEquals("success", response.get("status"));
-        assertEquals("升级成功", response.get("message"));
-        assertEquals("Advanced", response.get("new_level"));
-    }
-}
diff --git a/src/test/java/com/example/myproject/controller/PostControllerTest.java b/src/test/java/com/example/myproject/controller/PostControllerTest.java
deleted file mode 100644
index 21eeddd..0000000
--- a/src/test/java/com/example/myproject/controller/PostControllerTest.java
+++ /dev/null
@@ -1,206 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.entity.Post;
-import com.example.myproject.service.PostService;
-import com.example.myproject.utils.Result;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.*;
-import org.springframework.web.multipart.MultipartFile;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.mockito.Mockito.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-class PostControllerTest {
-
-    @InjectMocks
-    private PostController postController;
-
-    @Mock
-    private PostService postService;
-
-    @BeforeEach
-    void setup() {
-        MockitoAnnotations.openMocks(this);
-    }
-
-    // 测试创建帖子
-    void createPostTest() {
-        Long userId = 1L;
-        String postContent = "Test Post Content";
-        String title = "Test Post Title";
-        MultipartFile[] imageFiles = new MultipartFile[0];  // Empty array for simplicity
-
-        // 模拟服务层的返回值
-        Map<String, Object> responseMap = new HashMap<>();
-        responseMap.put("postNo", 123L);
-        responseMap.put("message", "帖子创建成功");
-
-        when(postService.createPost(userId, postContent, title, imageFiles)).thenReturn(responseMap);
-
-        // 调用控制器的方法
-        Map<String, Object> resultMap = postController.createPost(userId, postContent, title, imageFiles);
-
-        // 手动将 Map<String, Object> 包装到 Result.success()
-        Result<Map<String, Object>> result = Result.success(resultMap, "帖子创建成功");
-
-        // 验证返回的结果
-        assertEquals("200", result.getCode());
-        assertEquals("帖子创建成功", result.getMsg());
-        assertEquals(123L, result.getData().get("postNo"));
-    }
-
-    // 测试编辑帖子
-    @Test
-    void updatePostTest() {
-        Long postId = 1L;
-        Post post = new Post();
-        post.setPostNo(postId);
-        post.setTitle("Updated Title");
-        post.setPostContent("Updated Content");
-
-        // 模拟服务层的行为
-        doNothing().when(postService).updatePost(postId, post);
-
-        // 调用控制器的方法
-        String result = postController.updatePost(postId, post);
-
-        // 验证返回的结果
-        assertEquals("Post updated successfully!", result);
-    }
-
-    // 测试删除帖子
-    @Test
-    void deletePostTest() {
-        Long postId = 1L;
-
-        // 模拟服务层的行为
-        doNothing().when(postService).deletePost(postId);
-
-        // 调用控制器的方法
-        String result = postController.deletePost(postId);
-
-        // 验证返回的结果
-        assertEquals("Post deleted successfully!", result);
-    }
-
-    // 测试点赞帖子
-    @Test
-    void likePostTest() {
-        Long postId = 1L;
-        Long userId = 1L;
-
-        // 模拟服务层的行为
-        doNothing().when(postService).likePost(postId, userId);
-
-        // 创建请求体
-        Map<String, Long> requestBody = new HashMap<>();
-        requestBody.put("user_id", userId);
-
-        // 调用控制器的方法
-        String result = postController.likePost(postId, requestBody);
-
-        // 验证返回的结果
-        assertEquals("Post liked successfully!", result);
-    }
-
-    // 测试取消点赞帖子
-    @Test
-    void unlikePostTest() {
-        Long postId = 1L;
-        Long userId = 1L;
-
-        // 模拟服务层的行为
-        doNothing().when(postService).unlikePost(postId, userId);
-
-        // 创建请求体
-        Map<String, Long> requestBody = new HashMap<>();
-        requestBody.put("user_id", userId);
-
-        // 调用控制器的方法
-        String result = postController.unlikePost(postId, requestBody);
-
-        // 验证返回的结果
-        assertEquals("Post unliked successfully!", result);
-    }
-
-    // 测试收藏帖子
-    @Test
-    void collectPostTest() {
-        Long postId = 1L;
-        Long userId = 1L;
-
-        // 模拟服务层的行为
-        doNothing().when(postService).collectPost(postId, userId);
-
-        // 创建请求体
-        Map<String, Long> requestBody = new HashMap<>();
-        requestBody.put("user_id", userId);
-
-        // 调用控制器的方法
-        String result = postController.collectPost(postId, requestBody);
-
-        // 验证返回的结果
-        assertEquals("Post collected successfully!", result);
-    }
-
-    // 测试取消收藏帖子
-    @Test
-    void uncollectPostTest() {
-        Long postId = 1L;
-        Long userId = 1L;
-
-        // 模拟服务层的行为
-        doNothing().when(postService).uncollectPost(postId, userId);
-
-        // 创建请求体
-        Map<String, Long> requestBody = new HashMap<>();
-        requestBody.put("user_id", userId);
-
-        // 调用控制器的方法
-        String result = postController.uncollectPost(postId, requestBody);
-
-        // 验证返回的结果
-        assertEquals("Post uncollected successfully!", result);
-    }
-
-    // 测试获取所有帖子
-    @Test
-    void getAllPostsTest() {
-        // 模拟服务层的行为
-        Map<String, Object> responseMap = new HashMap<>();
-        responseMap.put("total", 5);
-        responseMap.put("posts", new ArrayList<>());
-
-        when(postService.getAllPosts()).thenReturn(responseMap);
-
-        // 调用控制器的方法
-        Map<String, Object> result = postController.getAllPosts();
-
-        // 验证返回的结果
-        assertEquals(5, result.get("total"));
-    }
-
-    // 测试根据帖子ID获取帖子
-    @Test
-    void getPostByIdTest() {
-        Long postId = 1L;
-        Map<String, Object> responseMap = new HashMap<>();
-        responseMap.put("postNo", 123L);
-        responseMap.put("message", "Post details");
-
-        // 模拟服务层的行为
-        when(postService.getPostById(postId)).thenReturn(responseMap);
-
-        // 调用控制器的方法
-        Map<String, Object> result = postController.getPostById(postId);
-
-        // 验证返回的结果
-        assertEquals("Post details", result.get("message"));
-        assertEquals(123L, result.get("postNo"));
-    }
-}
diff --git a/src/test/java/com/example/myproject/controller/TaskControllerTest.java b/src/test/java/com/example/myproject/controller/TaskControllerTest.java
deleted file mode 100644
index 5d7609d..0000000
--- a/src/test/java/com/example/myproject/controller/TaskControllerTest.java
+++ /dev/null
@@ -1,205 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.controller.TaskController;
-import com.example.myproject.service.TaskService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.springframework.http.ResponseEntity;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.mockito.Mockito.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-class TaskControllerTest {
-
-    @InjectMocks
-    private TaskController taskController;
-
-    @Mock
-    private TaskService taskService;
-
-    @BeforeEach
-    void setup() {
-        MockitoAnnotations.openMocks(this);
-    }
-
-    // 测试获取当前用户的新手任务列表接口
-    @Test
-    void testGetAllTasks() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("tasks", "mock_tasks");
-
-        // 模拟 taskService.getAllTasksForUser 返回
-        when(taskService.getAllTasksForUser(userId)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-
-        // 调用控制器方法
-        Map<String, Object> response = taskController.getAllTasks(request);
-
-        // 验证返回的结果
-        assertEquals("mock_tasks", response.get("tasks"));
-    }
-
-    // 测试更新任务状态接口
-    @Test
-    void testUpdateTaskStatus() {
-        Long userId = 1L;
-        String taskId = "task_123";
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "任务状态已更新");
-
-        // 模拟 taskService.updateTaskStatus 返回
-        when(taskService.updateTaskStatus(userId, taskId)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-        request.put("task_id", taskId);
-
-        // 调用控制器方法
-        Map<String, Object> response = taskController.updateTaskStatus(request);
-
-        // 验证返回的结果
-        assertEquals("success", response.get("status"));
-        assertEquals("任务状态已更新", response.get("message"));
-    }
-
-    // 测试获取当前经验和任务奖励接口
-    @Test
-    void testGetExperience() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("current_experience", 1500);
-        mockResponse.put("level", "Intermediate");
-        mockResponse.put("reward", Map.of("experience", 1000, "points", 200));
-
-        // 模拟 taskService.getUserExperience 返回
-        when(taskService.getUserExperience(userId)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-
-        // 调用控制器方法
-        Map<String, Object> response = taskController.getExperience(request);
-
-        // 验证返回的结果
-        assertEquals(1500, response.get("current_experience"));
-        assertEquals("Intermediate", response.get("level"));
-        assertTrue(response.containsKey("reward"));
-    }
-
-    // 测试获取当前的指引步骤接口
-    @Test
-    void testGetNewStep() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("current_step", "step_1");
-        mockResponse.put("total_steps", 5);
-        mockResponse.put("step_description", "Complete the introduction task");
-
-        // 模拟 taskService.getNewStep 返回
-        when(taskService.getNewStep(userId)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-
-        // 调用控制器方法
-        Map<String, Object> response = taskController.getNewStep(request);
-
-        // 验证返回的结果
-        assertEquals("step_1", response.get("current_step"));
-        assertEquals(5, response.get("total_steps"));
-        assertEquals("Complete the introduction task", response.get("step_description"));
-    }
-
-    // 测试更新进度接口
-    @Test
-    void testUpdateProgress() {
-        Long userId = 1L;
-        String taskId = "task_123";
-        Integer progress = 50;
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "进度已更新");
-
-        // 模拟 taskService.updateTaskProgress 返回
-        when(taskService.updateTaskProgress(userId, taskId, progress)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-        request.put("task_id", taskId);
-        request.put("progress", progress);
-
-        // 调用控制器方法
-        Map<String, Object> response = taskController.updateProgress(request);
-
-        // 验证返回的结果
-        assertEquals("success", response.get("status"));
-        assertEquals("进度已更新", response.get("message"));
-    }
-
-    // 测试领取任务奖励接口
-    @Test
-    void testRewardClaim() {
-        Long userId = 1L;
-        String taskId = "task_123";
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "奖励已领取");
-        mockResponse.put("reward", Map.of("experience", 1000, "points", 200));
-
-        // 模拟 taskService.claimReward 返回
-        when(taskService.claimReward(userId, taskId)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-        request.put("task_id", taskId);
-
-        // 调用控制器方法
-        Map<String, Object> response = taskController.rewardClaim(request);
-
-        // 验证返回的结果
-        assertEquals("success", response.get("status"));
-        assertEquals("奖励已领取", response.get("message"));
-        assertTrue(response.containsKey("reward"));
-    }
-
-    // 测试检查任务奖励状态接口
-    @Test
-    void testRewardReview() {
-        Long userId = 1L;
-        String taskId = "task_123";
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "reward_not_issued");
-        mockResponse.put("message", "任务奖励未被领取");
-
-        // 模拟 taskService.checkRewardStatus 返回
-        when(taskService.checkRewardStatus(userId, taskId)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-        request.put("task_id", taskId);
-
-        // 调用控制器方法
-        Map<String, Object> response = taskController.rewardReview(request);
-
-        // 验证返回的结果
-        assertEquals("reward_not_issued", response.get("status"));
-        assertEquals("任务奖励未被领取", response.get("message"));
-    }
-}
diff --git a/src/test/java/com/example/myproject/controller/UserControllerTest.java b/src/test/java/com/example/myproject/controller/UserControllerTest.java
index a97e169..d332f31 100644
--- a/src/test/java/com/example/myproject/controller/UserControllerTest.java
+++ b/src/test/java/com/example/myproject/controller/UserControllerTest.java
@@ -1,234 +1,162 @@
 package com.example.myproject.controller;
 
-import com.example.myproject.entity.Users;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.example.myproject.entity.User;
+import com.example.myproject.service.EmailService;
 import com.example.myproject.service.UserService;
-import com.example.myproject.repository.UserRepository;
+import com.example.myproject.mapper.UserMapper;
+import com.example.myproject.mapper.VerificationTokenMapper;
+import com.example.myproject.common.base.Result;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.*;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.AuthenticationException;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-
-import static org.mockito.Mockito.*;
 import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
 
 class UserControllerTest {
 
-    @Mock
-    private UserService userService;
-
-    @Mock
-    private UserRepository userRepository;
-
     @InjectMocks
     private UserController userController;
 
+    @Mock
+    private UserService userService;
+    @Mock
+    private UserMapper userMapper;
+    @Mock
+    private EmailService emailService;
+    @Mock
+    private AuthenticationManager authenticationManager;
+    @Mock
+    private VerificationTokenMapper verificationTokenMapper;
+
     @BeforeEach
-    void setUp() {
-        // 初始化模拟对象
+    void setup() {
         MockitoAnnotations.openMocks(this);
     }
 
-    // 测试生成邀请码接口
     @Test
-    void testGenerateInviteCode() {
-        // 设置输入数据
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", 1L);
+    void loginController_success() {
+        String username = "testuser";
+        String password = "testpass";
+        User mockUser = new User();
+        mockUser.setUsername(username);
 
-        // 模拟服务层的返回
-        Map<String, Object> responseMap = new HashMap<>();
-        responseMap.put("status", "success");
-        responseMap.put("message", "邀请码生成成功");
-        responseMap.put("invite_code", "ABC123XYZ");
+        Authentication mockAuth = mock(Authentication.class);
+        when(authenticationManager.authenticate(any())).thenReturn(mockAuth);
+        when(userMapper.selectOne(any(QueryWrapper.class))).thenReturn(mockUser);
 
-        when(userService.generateInviteCode(1L)).thenReturn(responseMap);
+        Result result = userController.loginController(username, password);
 
-        // 调用控制器方法
-        Map<String, Object> resultMap = userController.generateInviteCode(request);
-
-        // 验证返回结果
-        assertEquals("success", resultMap.get("status"));
-        assertEquals("邀请码生成成功", resultMap.get("message"));
-        assertEquals("ABC123XYZ", resultMap.get("invite_code"));
-
-        // 验证服务层方法是否被调用
-        verify(userService, times(1)).generateInviteCode(1L);
+        assertEquals("200", result.getCode());
+        assertEquals(mockUser, result.getData());
     }
 
-    // 测试用户修改密码接口
+
     @Test
-    void testChangePassword() {
-        Long userId = 1L;
-        Map<String, Object> request = new HashMap<>();
-        request.put("user_id", userId);
-        request.put("old_password", "oldPassword");
-        request.put("new_password", "newPassword");
-        request.put("confirm_password", "newPassword");
+    void loginController_failure() {
+        String username = "user";
+        String password = "wrongpass";
 
-        // 模拟服务层的返回
-        String resultMessage = "密码修改成功";
-        when(userService.changePassword(userId, "oldPassword", "newPassword", "newPassword"))
-                .thenReturn(resultMessage);
+        // 模拟认证失败，抛出 Bad credentials 异常
+        when(authenticationManager.authenticate(any()))
+                .thenThrow(new AuthenticationException("Bad credentials") {});
 
-        // 调用控制器方法
-        Map<String, Object> resultMap = userController.changePassword(request);
 
-        // 验证返回结果
-        assertEquals("密码修改成功", resultMap.get("message"));
-        assertEquals("success", resultMap.get("status"));
+        // 调用登录接口
+        Result result = userController.loginController(username, password);
 
-        // 验证服务层方法是否被调用
-        verify(userService, times(1)).changePassword(userId, "oldPassword", "newPassword", "newPassword");
-    }
-
-    // 测试用户注册接口
-    @Test
-    void testRegister() {
-        // 设置输入数据
-        Map<String, Object> request = new HashMap<>();
-        request.put("username", "testUser");
-        request.put("email", "test@example.com");
-        request.put("password", "password");
-        request.put("role", "USER");
-        request.put("inviteCode", "12345");
-
-        // 模拟服务层的返回
-        String resultMessage = "用户注册成功";
-        when(userService.registerUser("testUser", "test@example.com", "password", "USER", "12345"))
-                .thenReturn(resultMessage);
-
-        // 调用控制器方法
-        Map<String, Object> resultMap = userController.register(request);
-
-        // 验证返回结果
-        assertEquals("用户注册成功", resultMap.get("msg"));
-
-        // 验证服务层方法是否被调用
-        verify(userService, times(1)).registerUser("testUser", "test@example.com", "password", "USER", "12345");
+        // 断言返回的状态码和消息
+        assertEquals("401", result.getCode());
+        assertTrue(result.getMsg().contains("登录失败"));
     }
 
     @Test
-    void testLogin() {
-        String username = "testUser";
-        String password = "password";
-
-        // 模拟服务层的返回
-        String loginMessage = "登录成功";
-        when(userService.loginUser("testUser", "password")).thenReturn(loginMessage);
-
-        // 模拟用户查询
-        Users user = new Users();
-        user.setUserId(1L);
-        user.setUsername("testUser");
+    void registerController_emailExists() {
+        User user = new User();
         user.setEmail("test@example.com");
-        when(userRepository.findByUsername("testUser")).thenReturn(Optional.of(user));
 
-        // 设置请求数据
-        Map<String, Object> request = new HashMap<>();
-        request.put("username", username);
-        request.put("password", password);
+        when(userService.checkEmailExists(user.getEmail())).thenReturn(true);
 
-        // 调用控制器方法
-        Map<String, Object> resultMap = userController.login(request);
+        Result result = userController.registerController(user);
 
-        // 验证返回结果
-        assertEquals("登录成功", resultMap.get("msg"));
-
-        // 验证 user 不是 Map 类型，而是 Users 对象
-        Users loggedInUser = (Users) resultMap.get("user");
-        assertNotNull(loggedInUser);
-        assertEquals("testUser", loggedInUser.getUsername());
-        assertEquals("test@example.com", loggedInUser.getEmail());
-
-        // 验证服务层方法是否被调用
-        verify(userService, times(1)).loginUser("testUser", "password");
+        assertEquals("邮箱冲突", result.getCode());
     }
 
-
-    // 测试获取用户个人资料接口
     @Test
-    void testGetProfile() {
-        Long userId = 1L;
-
-        // Mock 用户数据
-        Users user = new Users();
-        user.setUserId(userId);
-        user.setUsername("testUser");
+    void registerController_success() {
+        User user = new User();
         user.setEmail("test@example.com");
-        user.setAvatarUrl("https://example.com/avatar.jpg");
 
-        // 模拟服务层返回
-        Map<String, Object> profileData = new HashMap<>();
-        profileData.put("avatarUrl", user.getAvatarUrl());
-        profileData.put("username", user.getUsername());
-        profileData.put("email", user.getEmail());
-        when(userService.getProfile(userId)).thenReturn(profileData);
+        when(userService.checkEmailExists(user.getEmail())).thenReturn(false);
+        when(userService.preRegisterUser(user)).thenReturn(true);
 
-        // 调用控制器方法
-        Map<String, Object> resultMap = userController.getProfile(userId);
+        Result result = userController.registerController(user);
 
-        // 验证返回结果
-        assertEquals("testUser", resultMap.get("username"));
-        assertEquals("test@example.com", resultMap.get("email"));
-        assertEquals("https://example.com/avatar.jpg", resultMap.get("avatarUrl"));
-
-        // 验证服务层方法是否被调用
-        verify(userService, times(1)).getProfile(userId);
-    }
-
-    // 测试修改用户个人资料接口
-    @Test
-    void testEditProfile() {
-        Long userId = 1L;
-        Map<String, Object> profileData = new HashMap<>();
-        profileData.put("avatarUrl", "https://example.com/avatar.jpg");
-        profileData.put("nickname", "newNickname");
-        profileData.put("gender", "Male");
-        profileData.put("description", "Updated description");
-        profileData.put("hobbies", "Reading, Hiking");
-
-        // 模拟服务层的返回
-        when(userService.editProfile(userId, "https://example.com/avatar.jpg", "newNickname", "Male", "Updated description", "Reading, Hiking"))
-                .thenReturn(true);
-
-        // 调用控制器方法
-        Map<String, String> resultMap = userController.editProfile(userId, profileData);
-
-        // 验证返回结果
-        assertEquals("用户资料更新成功", resultMap.get("message"));
-
-        // 验证服务层方法是否被调用
-        verify(userService, times(1)).editProfile(userId, "https://example.com/avatar.jpg", "newNickname", "Male", "Updated description", "Reading, Hiking");
+        assertEquals("200", result.getCode());
+        assertEquals(user.getEmail(), ((User) result.getData()).getEmail());
     }
 
     @Test
-    public void testCalculateShareRate() {
-        Long userId = 1L;
+    void verifyEmailCode_success() {
+        when(userService.verifyEmail("test@example.com", "123456")).thenReturn(true);
 
-        // 模拟 UserService 返回的结果
-        Map<String, Object> expectedResponse = Map.of(
-                "status", "success",
-                "message", "分享率计算成功",
-                "shareRate", 0.5f
-        );
+        UserController.VerificationRequest request = new UserController.VerificationRequest();
+        request.setEmail("test@example.com");
+        request.setCode("123456");
 
-        // 设置用户数据
-        Users user = new Users();
-        user.setUserId(userId);
-        user.setUploadCount(50f);  // 上传量为50
-        user.setDownloadCount(100f);  // 下载量为100
-        when(userService.calculateShareRate(userId)).thenReturn(expectedResponse);
+        Result result = userController.verifyEmailCode(request);
 
-        // 调用接口
-        Map<String, Object> result = userController.calculateShareRate(userId);
+        assertEquals("200", result.getCode());
+    }
 
-        // 验证结果
-        assertEquals(expectedResponse, result);
-        verify(userService, times(1)).calculateShareRate(userId);  // 验证服务方法是否被调用
+    @Test
+    void verifyEmailCode_failure() {
+        when(userService.verifyEmail("test@example.com", "000000")).thenReturn(false);
+
+        UserController.VerificationRequest request = new UserController.VerificationRequest();
+        request.setEmail("test@example.com");
+        request.setCode("000000");
+
+        Result result = userController.verifyEmailCode(request);
+
+        assertEquals("验证失败", result.getCode());
+    }
+
+    @Test
+    void checkPassword_success() {
+        when(userService.checkPassword(1L, "abc123")).thenReturn(true);
+
+        Result<String> result = userController.checkPassword(1L, "abc123");
+
+        assertEquals("200", result.getCode());
+        assertEquals("原始密码输入正确", result.getMsg());
+    }
+
+    @Test
+    void checkPassword_failure() {
+        when(userService.checkPassword(1L, "wrong")).thenReturn(false);
+
+        Result<String> result = userController.checkPassword(1L, "wrong");
+
+        assertEquals("305", result.getCode());
+        assertEquals("原始密码输入错误", result.getMsg());
+    }
+
+    @Test
+    void sendVerificationEmail_userNotFound() {
+        UserController.EmailRequest request = new UserController.EmailRequest();
+        request.setEmail("notfound@example.com");
+
+        when(userMapper.selectOne(any())).thenReturn(null);
+
+        ResponseEntity<Result> response = userController.sendVerificationEmail(request);
+
+        assertEquals(400, response.getStatusCodeValue());
+        assertEquals("1", response.getBody().getCode());
     }
 }
diff --git a/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java b/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java
deleted file mode 100644
index 29bf47f..0000000
--- a/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java
+++ /dev/null
@@ -1,132 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.controller.UserFollowController;
-import com.example.myproject.service.UserFollowService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.springframework.http.ResponseEntity;
-import java.util.List;
-
-import java.util.Map;
-
-import static org.mockito.Mockito.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-class UserFollowControllerTest {
-
-    @InjectMocks
-    private UserFollowController userFollowController;
-
-    @Mock
-    private UserFollowService userFollowService;
-
-    @BeforeEach
-    void setup() {
-        MockitoAnnotations.openMocks(this);
-    }
-
-    // 测试用户关注接口
-    @Test
-    void testFollow() {
-        Long followerId = 1L;
-        Long followedId = 2L;
-        Map<String, Object> mockResponse = Map.of(
-                "status", "success",
-                "message", "关注成功"
-        );
-
-        // 模拟 userFollowService.follow() 返回
-        when(userFollowService.follow(followerId, followedId)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Long> request = Map.of("follower_id", followerId);
-
-        // 调用控制器方法
-        ResponseEntity<Map<String, Object>> responseEntity = userFollowController.follow(followedId, request);
-
-        // 验证返回的状态码和内容
-        assertEquals(200, responseEntity.getStatusCodeValue());
-        assertEquals("success", responseEntity.getBody().get("status"));
-        assertEquals("关注成功", responseEntity.getBody().get("message"));
-    }
-
-    // 测试取消关注接口
-    @Test
-    void testUnfollow() {
-        Long followerId = 1L;
-        Long followedId = 2L;
-        Map<String, Object> mockResponse = Map.of(
-                "status", "success",
-                "message", "取消关注成功"
-        );
-
-        // 模拟 userFollowService.unfollow() 返回
-        when(userFollowService.unfollow(followerId, followedId)).thenReturn(mockResponse);
-
-        // 创建请求体
-        Map<String, Long> request = Map.of("follower_id", followerId);
-
-        // 调用控制器方法
-        ResponseEntity<Map<String, Object>> responseEntity = userFollowController.unfollow(followedId, request);
-
-        // 验证返回的状态码和内容
-        assertEquals(200, responseEntity.getStatusCodeValue());
-        assertEquals("success", responseEntity.getBody().get("status"));
-        assertEquals("取消关注成功", responseEntity.getBody().get("message"));
-    }
-
-    // 测试获取某个用户的粉丝列表接口
-    @Test
-    void testGetFollowers() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = Map.of(
-                "status", "success",
-                "total", 2,
-                "followers", List.of(
-                        Map.of("user_id", 2L, "username", "user2", "avatar_url", "url2"),
-                        Map.of("user_id", 3L, "username", "user3", "avatar_url", "url3")
-                )
-        );
-
-        // 模拟 userFollowService.getFollowers() 返回
-        when(userFollowService.getFollowers(userId)).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        ResponseEntity<Map<String, Object>> responseEntity = userFollowController.getFollowers(userId);
-
-        // 验证返回的状态码和内容
-        assertEquals(200, responseEntity.getStatusCodeValue());
-        assertEquals("success", responseEntity.getBody().get("status"));
-        assertEquals(2, responseEntity.getBody().get("total"));
-        assertEquals(2, ((List<?>) responseEntity.getBody().get("followers")).size());
-    }
-
-    // 测试获取某个用户的关注列表接口
-    @Test
-    void testGetFollowing() {
-        Long userId = 1L;
-        Map<String, Object> mockResponse = Map.of(
-                "status", "success",
-                "total", 2,
-                "following", List.of(
-                        Map.of("user_id", 2L, "username", "user2", "avatar_url", "url2"),
-                        Map.of("user_id", 3L, "username", "user3", "avatar_url", "url3")
-                )
-        );
-
-        // 模拟 userFollowService.getFollowing() 返回
-        when(userFollowService.getFollowing(userId)).thenReturn(mockResponse);
-
-        // 调用控制器方法
-        ResponseEntity<Map<String, Object>> responseEntity = userFollowController.getFollowing(userId);
-
-        // 验证返回的状态码和内容
-        assertEquals(200, responseEntity.getStatusCodeValue());
-        assertEquals("success", responseEntity.getBody().get("status"));
-        assertEquals(2, responseEntity.getBody().get("total"));
-        assertEquals(2, ((List<?>) responseEntity.getBody().get("following")).size());
-    }
-}
diff --git a/src/test/java/com/example/myproject/controller/UserMessageControllerTest.java b/src/test/java/com/example/myproject/controller/UserMessageControllerTest.java
deleted file mode 100644
index 4fcbcc7..0000000
--- a/src/test/java/com/example/myproject/controller/UserMessageControllerTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.service.UserMessageService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.springframework.http.ResponseEntity;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.Mockito.when;
-
-class UserMessageControllerTest {
-
-    @InjectMocks
-    private UserMessageController userMessageController;
-
-    @Mock
-    private UserMessageService userMessageService;
-
-    @BeforeEach
-    void setup() {
-        MockitoAnnotations.openMocks(this);
-    }
-
-    @Test
-    void testSendMessage() {
-        // 准备测试数据
-        Map<String, Object> params = new HashMap<>();
-        params.put("sender_id", 1L);
-        params.put("receiver_id", 2L);
-        params.put("content", "测试消息");
-
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", "私信发送成功");
-        mockResponse.put("message_id", 100L);
-
-        // 模拟Service方法调用
-        when(userMessageService.sendMessage(1L, 2L, "测试消息")).thenReturn(mockResponse);
-
-        // 执行测试
-        ResponseEntity<Map<String, Object>> response = userMessageController.sendMessage(params);
-
-        // 验证结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("success", response.getBody().get("status"));
-        assertEquals("私信发送成功", response.getBody().get("message"));
-        assertEquals(100L, response.getBody().get("message_id"));
-    }
-
-    @Test
-    void testGetUserMessages() {
-        // 准备测试数据
-        Long userId = 1L;
-
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("messages", new HashMap<>());
-
-        // 模拟Service方法调用
-        when(userMessageService.getUserMessages(userId)).thenReturn(mockResponse);
-
-        // 执行测试
-        ResponseEntity<Map<String, Object>> response = userMessageController.getUserMessages(userId);
-
-        // 验证结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("success", response.getBody().get("status"));
-    }
-
-    @Test
-    void testGetMessage() {
-        // 准备测试数据
-        Long messageId = 1L;
-
-        Map<String, Object> mockResponse = new HashMap<>();
-        mockResponse.put("status", "success");
-        mockResponse.put("message", new HashMap<>());
-
-        // 模拟Service方法调用
-        when(userMessageService.getMessage(messageId)).thenReturn(mockResponse);
-
-        // 执行测试
-        ResponseEntity<Map<String, Object>> response = userMessageController.getMessage(messageId);
-
-        // 验证结果
-        assertEquals(200, response.getStatusCodeValue());
-        assertEquals("success", response.getBody().get("status"));
-    }
-}
\ No newline at end of file