diff --git a/src/test/java/com/example/myproject/controller/CommentControllerTest.java b/src/test/java/com/example/myproject/controller/CommentControllerTest.java
new file mode 100644
index 0000000..9dedd29
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/CommentControllerTest.java
@@ -0,0 +1,81 @@
+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
new file mode 100644
index 0000000..7392162
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/DynamicControllerTest.java
@@ -0,0 +1,168 @@
+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
new file mode 100644
index 0000000..d8c8c2c
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/GroupControllerTest.java
@@ -0,0 +1,209 @@
+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
new file mode 100644
index 0000000..c3d77b9
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/LevelControllerTest.java
@@ -0,0 +1,126 @@
+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
new file mode 100644
index 0000000..21eeddd
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/PostControllerTest.java
@@ -0,0 +1,206 @@
+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
new file mode 100644
index 0000000..5d7609d
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/TaskControllerTest.java
@@ -0,0 +1,205 @@
+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 d332f31..a97e169 100644
--- a/src/test/java/com/example/myproject/controller/UserControllerTest.java
+++ b/src/test/java/com/example/myproject/controller/UserControllerTest.java
@@ -1,162 +1,234 @@
 package com.example.myproject.controller;
 
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.example.myproject.entity.User;
-import com.example.myproject.service.EmailService;
+import com.example.myproject.entity.Users;
 import com.example.myproject.service.UserService;
-import com.example.myproject.mapper.UserMapper;
-import com.example.myproject.mapper.VerificationTokenMapper;
-import com.example.myproject.common.base.Result;
+import com.example.myproject.repository.UserRepository;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-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 org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 
-import static org.junit.jupiter.api.Assertions.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
 import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 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 loginController_success() {
-        String username = "testuser";
-        String password = "testpass";
-        User mockUser = new User();
-        mockUser.setUsername(username);
+    void testGenerateInviteCode() {
+        // 设置输入数据
+        Map<String, Object> request = new HashMap<>();
+        request.put("user_id", 1L);
 
-        Authentication mockAuth = mock(Authentication.class);
-        when(authenticationManager.authenticate(any())).thenReturn(mockAuth);
-        when(userMapper.selectOne(any(QueryWrapper.class))).thenReturn(mockUser);
+        // 模拟服务层的返回
+        Map<String, Object> responseMap = new HashMap<>();
+        responseMap.put("status", "success");
+        responseMap.put("message", "邀请码生成成功");
+        responseMap.put("invite_code", "ABC123XYZ");
 
-        Result result = userController.loginController(username, password);
+        when(userService.generateInviteCode(1L)).thenReturn(responseMap);
 
-        assertEquals("200", result.getCode());
-        assertEquals(mockUser, result.getData());
+        // 调用控制器方法
+        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);
     }
 
-
+    // 测试用户修改密码接口
     @Test
-    void loginController_failure() {
-        String username = "user";
-        String password = "wrongpass";
+    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");
 
-        // 模拟认证失败，抛出 Bad credentials 异常
-        when(authenticationManager.authenticate(any()))
-                .thenThrow(new AuthenticationException("Bad credentials") {});
+        // 模拟服务层的返回
+        String resultMessage = "密码修改成功";
+        when(userService.changePassword(userId, "oldPassword", "newPassword", "newPassword"))
+                .thenReturn(resultMessage);
 
+        // 调用控制器方法
+        Map<String, Object> resultMap = userController.changePassword(request);
 
-        // 调用登录接口
-        Result result = userController.loginController(username, password);
+        // 验证返回结果
+        assertEquals("密码修改成功", resultMap.get("message"));
+        assertEquals("success", resultMap.get("status"));
 
-        // 断言返回的状态码和消息
-        assertEquals("401", result.getCode());
-        assertTrue(result.getMsg().contains("登录失败"));
+        // 验证服务层方法是否被调用
+        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");
     }
 
     @Test
-    void registerController_emailExists() {
-        User user = new User();
+    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");
         user.setEmail("test@example.com");
+        when(userRepository.findByUsername("testUser")).thenReturn(Optional.of(user));
 
-        when(userService.checkEmailExists(user.getEmail())).thenReturn(true);
+        // 设置请求数据
+        Map<String, Object> request = new HashMap<>();
+        request.put("username", username);
+        request.put("password", password);
 
-        Result result = userController.registerController(user);
+        // 调用控制器方法
+        Map<String, Object> resultMap = userController.login(request);
 
-        assertEquals("邮箱冲突", result.getCode());
+        // 验证返回结果
+        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");
     }
 
+
+    // 测试获取用户个人资料接口
     @Test
-    void registerController_success() {
-        User user = new User();
+    void testGetProfile() {
+        Long userId = 1L;
+
+        // Mock 用户数据
+        Users user = new Users();
+        user.setUserId(userId);
+        user.setUsername("testUser");
         user.setEmail("test@example.com");
+        user.setAvatarUrl("https://example.com/avatar.jpg");
 
-        when(userService.checkEmailExists(user.getEmail())).thenReturn(false);
-        when(userService.preRegisterUser(user)).thenReturn(true);
+        // 模拟服务层返回
+        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);
 
-        Result result = userController.registerController(user);
+        // 调用控制器方法
+        Map<String, Object> resultMap = userController.getProfile(userId);
 
-        assertEquals("200", result.getCode());
-        assertEquals(user.getEmail(), ((User) result.getData()).getEmail());
+        // 验证返回结果
+        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");
     }
 
     @Test
-    void verifyEmailCode_success() {
-        when(userService.verifyEmail("test@example.com", "123456")).thenReturn(true);
+    public void testCalculateShareRate() {
+        Long userId = 1L;
 
-        UserController.VerificationRequest request = new UserController.VerificationRequest();
-        request.setEmail("test@example.com");
-        request.setCode("123456");
+        // 模拟 UserService 返回的结果
+        Map<String, Object> expectedResponse = Map.of(
+                "status", "success",
+                "message", "分享率计算成功",
+                "shareRate", 0.5f
+        );
 
-        Result result = userController.verifyEmailCode(request);
+        // 设置用户数据
+        Users user = new Users();
+        user.setUserId(userId);
+        user.setUploadCount(50f);  // 上传量为50
+        user.setDownloadCount(100f);  // 下载量为100
+        when(userService.calculateShareRate(userId)).thenReturn(expectedResponse);
 
-        assertEquals("200", result.getCode());
-    }
+        // 调用接口
+        Map<String, Object> result = userController.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());
+        // 验证结果
+        assertEquals(expectedResponse, result);
+        verify(userService, times(1)).calculateShareRate(userId);  // 验证服务方法是否被调用
     }
 }
diff --git a/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java b/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java
new file mode 100644
index 0000000..29bf47f
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java
@@ -0,0 +1,132 @@
+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
new file mode 100644
index 0000000..4fcbcc7
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/UserMessageControllerTest.java
@@ -0,0 +1,95 @@
+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