PR #35 - Update Old Weibo Tasks and Add New Ones

rewards/weibo.py

@@ -3,7 +3,7 @@ Reward functions for Weibo app tasks.
 """
 
 import logging
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, Tuple, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -51,7 +51,8 @@ def _validate_navigatepost(initial_state: Dict[str, Any], final_state: Dict[str,
     This function validates the final state matches the expected target state:
     - currentView should be "post"
     - viewedPostId should match the expected post ID
-    - commentTab should be set appropriately
+    - viewedPostCommentTab should be set appropriately
+    - The viewed post should have the expected content
     
     Args:
         initial_state: The initial state before navigation
@@ -67,17 +68,30 @@ def _validate_navigatepost(initial_state: Dict[str, Any], final_state: Dict[str,
     if current_view != "post":
         return 0.0, f"Not on post detail page, current view: {current_view}"
     
-    # Check 2: viewedPostId is "4"
+    # Check 2: viewedPostId exists
     viewed_post_id = final_state.get("viewedPostId")
-    if viewed_post_id != "4":
-        return 0.0, f"Expected viewedPostId to be '4', got '{viewed_post_id}'"
+    if viewed_post_id is None:
+        return 0.0, "viewedPostId is None"
     
-    # Check 3: commentTab is "hot" (default tab for post detail)
-    comment_tab = final_state.get("commentTab")
+    # Check 3: Find the post in allPosts and validate content
+    all_posts = final_state.get("allPosts", [])
+    target_post = next((p for p in all_posts if p.get("id") == viewed_post_id), None)
+    
+    if target_post is None:
+        return 0.0, f"Post with ID '{viewed_post_id}' not found in allPosts"
+    
+    # Check 4: Post should have expected content
+    expected_content = "旅行途中看到的美景，分享给大家一起欣赏"
+    post_content = target_post.get("content", "")
+    if post_content != expected_content:
+        return 0.0, f"Expected post content to be '{expected_content}', got '{post_content}'"
+    
+    # Check 5: viewedPostCommentTab is "hot" (default tab for post detail)
+    comment_tab = final_state.get("viewedPostCommentTab")
     if comment_tab != "hot":
-        return 0.0, f"Expected commentTab to be 'hot', got '{comment_tab}'"
+        return 0.0, f"Expected viewedPostCommentTab to be 'hot', got '{comment_tab}'"
     
-    return 1.0, "Successfully navigated to post 4 detail page"
+    return 1.0, "Successfully navigated to post detail page"
 
 
 def _validate_loadmoreposts(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
@@ -86,7 +100,7 @@ def _validate_loadmoreposts(initial_state: Dict[str, Any], final_state: Dict[str
     
     This function validates the final state matches the expected target state:
     - currentView should remain "feed"
-    - displayedPosts should have increased (from 10 to 30 posts)
+    - feedDisplayedPosts should have increased
     - isLoadingPosts should be False (loading completed)
     
     Args:
@@ -103,9 +117,9 @@ def _validate_loadmoreposts(initial_state: Dict[str, Any], final_state: Dict[str
     if current_view != "feed":
         return 0.0, f"Not on feed page, current view: {current_view}"
     
-    # Check 2: displayedPosts has increased
-    initial_posts = initial_state.get("displayedPosts", [])
-    final_posts = final_state.get("displayedPosts", [])
+    # Check 2: feedDisplayedPosts has increased
+    initial_posts = initial_state.get("feedDisplayedPosts", [])
+    final_posts = final_state.get("feedDisplayedPosts", [])
     
     initial_count = len(initial_posts)
     final_count = len(final_posts)
@@ -113,11 +127,7 @@ def _validate_loadmoreposts(initial_state: Dict[str, Any], final_state: Dict[str
     if final_count <= initial_count:
         return 0.0, f"Posts did not increase: {initial_count} -> {final_count} (expected increase)"
     
-    # Check 3: Final count should be 30 posts
-    if final_count != 30:
-        return 0.0, f"Expected 30 posts in final state, got {final_count}"
-    
-    # Check 4: isLoadingPosts should be False (loading completed)
+    # Check 3: isLoadingPosts should be False (loading completed)
     is_loading = final_state.get("isLoadingPosts")
     if is_loading:
         return 0.0, f"Expected isLoadingPosts to be False after loading, got {is_loading}"
@@ -132,9 +142,10 @@ def _validate_postfromprofile(initial_state: Dict[str, Any], final_state: Dict[s
     This function validates the final state matches the expected target state:
     - currentView should be "post"
     - viewedPostId should match the expected post ID (31)
-    - commentTab should be "hot" (default tab)
+    - viewedPostCommentTab should be "hot" (default tab)
     - viewedUserId should be None (cleared when navigating to post detail)
-    - displayedPosts should remain unchanged (persisted across pages)
+    - loadedPosts should remain unchanged (persisted across pages)
+    - The viewed post should have the expected content
     
     Args:
         initial_state: The initial state before navigation
@@ -150,32 +161,45 @@ def _validate_postfromprofile(initial_state: Dict[str, Any], final_state: Dict[s
     if current_view != "post":
         return 0.0, f"Not on post detail page, current view: {current_view}"
     
-    # Check 2: viewedPostId is "31"
+    # Check 2: viewedPostId exists
     viewed_post_id = final_state.get("viewedPostId")
-    if viewed_post_id != "31":
-        return 0.0, f"Expected viewedPostId to be '31', got '{viewed_post_id}'"
+    if viewed_post_id is None:
+        return 0.0, "viewedPostId is None"
     
-    # Check 3: commentTab is "hot" (default tab for post detail)
-    comment_tab = final_state.get("commentTab")
+    # Check 3: Find the post in allPosts and validate content
+    all_posts = final_state.get("allPosts", [])
+    target_post = next((p for p in all_posts if p.get("id") == viewed_post_id), None)
+    
+    if target_post is None:
+        return 0.0, f"Post with ID '{viewed_post_id}' not found in allPosts"
+    
+    # Check 4: Post should have expected content
+    expected_content = "今天和朋友们一起聚餐，聊得很开心。友谊是最珍贵的财富。"
+    post_content = target_post.get("content", "")
+    if post_content != expected_content:
+        return 0.0, f"Expected post content to be '{expected_content}', got '{post_content}'"
+    
+    # Check 5: viewedPostCommentTab is "hot" (default tab for post detail)
+    comment_tab = final_state.get("viewedPostCommentTab")
     if comment_tab != "hot":
-        return 0.0, f"Expected commentTab to be 'hot', got '{comment_tab}'"
+        return 0.0, f"Expected viewedPostCommentTab to be 'hot', got '{comment_tab}'"
     
-    # Check 4: viewedUserId should be None (cleared when navigating to post)
+    # Check 6: viewedUserId should be None (cleared when navigating to post)
     viewed_user_id = final_state.get("viewedUserId")
     if viewed_user_id is not None:
         return 0.0, f"Expected viewedUserId to be None after navigating to post, got '{viewed_user_id}'"
     
-    # Check 5: displayedPosts should remain unchanged (persisted across pages)
-    initial_posts = initial_state.get("displayedPosts", [])
-    final_posts = final_state.get("displayedPosts", [])
+    # Check 7: loadedPosts should remain unchanged (persisted across pages)
+    initial_loaded = initial_state.get("loadedPosts", [])
+    final_loaded = final_state.get("loadedPosts", [])
     
-    initial_count = len(initial_posts)
-    final_count = len(final_posts)
+    initial_count = len(initial_loaded)
+    final_count = len(final_loaded)
     
     if initial_count != final_count:
-        return 0.0, f"displayedPosts count changed: {initial_count} -> {final_count} (should remain unchanged)"
+        return 0.0, f"loadedPosts count changed: {initial_count} -> {final_count} (should remain unchanged)"
     
-    return 1.0, "Successfully navigated to post 31 detail page from profile"
+    return 1.0, "Successfully navigated to post detail page from profile"
 
 
 def _validate_partialsearchquery(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
@@ -389,10 +413,11 @@ def _validate_postfromsearch(initial_state: Dict[str, Any], final_state: Dict[st
     
     This function validates the final state matches the expected target state:
     - currentView should be "post"
-    - viewedPostId should match the expected post ID (35)
-    - commentTab should be "hot" (default tab)
+    - viewedPostId should match the expected post ID
+    - viewedPostCommentTab should be "hot" (default tab)
     - searchQuery should be empty (cleared after navigation)
     - viewedUserId should be None (cleared when navigating to post detail)
+    - The viewed post should be from the expected user and have the expected content
     
     Args:
         initial_state: The initial state before navigation (on search results page)
@@ -408,27 +433,46 @@ def _validate_postfromsearch(initial_state: Dict[str, Any], final_state: Dict[st
     if current_view != "post":
         return 0.0, f"Not on post detail page, current view: {current_view}"
     
-    # Check 2: viewedPostId is "35"
+    # Check 2: viewedPostId exists
     viewed_post_id = final_state.get("viewedPostId")
-    if viewed_post_id != "35":
-        return 0.0, f"Expected viewedPostId to be '35', got '{viewed_post_id}'"
+    if viewed_post_id is None:
+        return 0.0, "viewedPostId is None"
+    
+    # Check 3: Find the post in allPosts and validate user and content
+    all_posts = final_state.get("allPosts", [])
+    target_post = next((p for p in all_posts if p.get("id") == viewed_post_id), None)
     
-    # Check 3: commentTab is "hot" (default tab for post detail)
-    comment_tab = final_state.get("commentTab")
+    if target_post is None:
+        return 0.0, f"Post with ID '{viewed_post_id}' not found in allPosts"
+    
+    # Check 4: Post should be from user "科技资讯"
+    post_user = target_post.get("user", {})
+    user_name = post_user.get("name", "")
+    if user_name != "科技资讯":
+        return 0.0, f"Expected post to be from user '科技资讯', got '{user_name}'"
+    
+    # Check 5: Post should have expected content
+    expected_content = "最新的科技新闻分享，AI技术的应用越来越广泛，未来可期！"
+    post_content = target_post.get("content", "")
+    if post_content != expected_content:
+        return 0.0, f"Expected post content to be '{expected_content}', got '{post_content}'"
+    
+    # Check 6: viewedPostCommentTab is "hot" (default tab for post detail)
+    comment_tab = final_state.get("viewedPostCommentTab")
     if comment_tab != "hot":
-        return 0.0, f"Expected commentTab to be 'hot', got '{comment_tab}'"
+        return 0.0, f"Expected viewedPostCommentTab to be 'hot', got '{comment_tab}'"
     
-    # Check 4: searchQuery should be empty (cleared after navigation)
+    # Check 7: searchQuery should be empty (cleared after navigation)
     search_query = final_state.get("searchQuery")
     if search_query != "":
         return 0.0, f"Expected searchQuery to be empty after navigation, got '{search_query}'"
     
-    # Check 5: viewedUserId should be None (cleared when navigating to post)
+    # Check 8: viewedUserId should be None (cleared when navigating to post)
     viewed_user_id = final_state.get("viewedUserId")
     if viewed_user_id is not None:
         return 0.0, f"Expected viewedUserId to be None after navigating to post, got '{viewed_user_id}'"
     
-    return 1.0, "Successfully navigated to post 35 detail page from search results"
+    return 1.0, "Successfully navigated to post detail page from search results"
 
 
 def _validate_acceptsearchsuggestion(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
@@ -608,7 +652,7 @@ def _validate_loadmanyposts(initial_state: Dict[str, Any], final_state: Dict[str
     This function validates the final state matches the expected target state:
     - currentView should be "post"
     - viewedPostId should match the expected post ID (23)
-    - commentTab should be "hot" (default tab)
+    - viewedPostCommentTab should be "hot" (default tab)
     - The post should be from user "读书笔记"
     - The post should have exactly 3 attachments (media items)
     
@@ -631,10 +675,10 @@ def _validate_loadmanyposts(initial_state: Dict[str, Any], final_state: Dict[str
     if viewed_post_id != "23":
         return 0.0, f"Expected viewedPostId to be '23', got '{viewed_post_id}'"
     
-    # Check 3: commentTab is "hot" (default tab for post detail)
-    comment_tab = final_state.get("commentTab")
+    # Check 3: viewedPostCommentTab is "hot" (default tab for post detail)
+    comment_tab = final_state.get("viewedPostCommentTab")
     if comment_tab != "hot":
-        return 0.0, f"Expected commentTab to be 'hot', got '{comment_tab}'"
+        return 0.0, f"Expected viewedPostCommentTab to be 'hot', got '{comment_tab}'"
     
     # Check 4: Find the post in allPosts and validate user name and attachments
     all_posts = final_state.get("allPosts", [])
@@ -761,7 +805,7 @@ def _validate_videopostfromprofile(initial_state: Dict[str, Any], final_state: D
     This function validates the final state matches the expected target state:
     - currentView should be "post"
     - viewedPostId should match the expected post ID (23)
-    - commentTab should be "hot" (default tab)
+    - viewedPostCommentTab should be "hot" (default tab)
     - The post should be from user "读书笔记"
     - The post should have at least one video attachment (media item with type "video")
     
@@ -784,10 +828,10 @@ def _validate_videopostfromprofile(initial_state: Dict[str, Any], final_state: D
     if viewed_post_id != "23":
         return 0.0, f"Expected viewedPostId to be '23', got '{viewed_post_id}'"
     
-    # Check 3: commentTab is "hot" (default tab for post detail)
-    comment_tab = final_state.get("commentTab")
+    # Check 3: viewedPostCommentTab is "hot" (default tab for post detail)
+    comment_tab = final_state.get("viewedPostCommentTab")
     if comment_tab != "hot":
-        return 0.0, f"Expected commentTab to be 'hot', got '{comment_tab}'"
+        return 0.0, f"Expected viewedPostCommentTab to be 'hot', got '{comment_tab}'"
     
     # Check 4: Find the post in allPosts and validate user name and video attachment
     all_posts = final_state.get("allPosts", [])
@@ -898,6 +942,837 @@ def _validate_searchusers(initial_state: Dict[str, Any], final_state: Dict[str,
     return 1.0, f"Successfully navigated to users search results page with {len(users)} users"
 
 
+def _find_user_by_name(users: list, name: str) -> Optional[Dict[str, Any]]:
+    """Find a user by name in the users list."""
+    for user in users:
+        if user.get("name") == name:
+            return user
+    return None
+
+
+def _find_post_by_user_name(all_posts: list, user_name: str, index: int = 0) -> Optional[Dict[str, Any]]:
+    """Find a post by user name and index (0-based)."""
+    posts_by_user = [p for p in all_posts if p.get("user", {}).get("name") == user_name]
+    if index < len(posts_by_user):
+        return posts_by_user[index]
+    return None
+
+
+def _validate_navigatetoemptylatestfeed(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully navigated to the latest feed page which should be empty.
+    
+    Args:
+        initial_state: The initial state before navigation
+        final_state: The final state after navigation
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check 1: currentView is "latest"
+    current_view = final_state.get("currentView")
+    if current_view != "latest":
+        return 0.0, f"Not on latest feed page, current view: {current_view}"
+    
+    # Check 2: latestDisplayedPosts is empty
+    latest_posts = final_state.get("latestDisplayedPosts", [])
+    if len(latest_posts) != 0:
+        return 0.0, f"Expected latestDisplayedPosts to be empty, got {len(latest_posts)} posts"
+    
+    return 1.0, "Successfully navigated to empty latest feed page"
+
+
+def _validate_likepostfrommainfeed(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully liked a post from the main feed.
+    
+    Args:
+        initial_state: The initial state before liking
+        final_state: The final state after liking
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find post 1 (first post by 用户小王)
+    all_posts = final_state.get("allPosts", [])
+    users = final_state.get("users", [])
+    user_xiaowang = _find_user_by_name(users, "用户小王")
+    
+    if user_xiaowang is None:
+        return 0.0, "User '用户小王' not found in users list"
+    
+    post_1 = _find_post_by_user_name(all_posts, "用户小王", 0)
+    if post_1 is None:
+        return 0.0, "Post 1 (first post by 用户小王) not found"
+    
+    post_1_id = post_1.get("id")
+    
+    # Check: Post 1's like count has increased
+    initial_post = next((p for p in initial_state.get("allPosts", []) if p.get("id") == post_1_id), None)
+    if initial_post is None:
+        return 0.0, f"Post 1 (ID: {post_1_id}) not found in initial state"
+    
+    initial_likes = initial_post.get("likeCount", 0)
+    final_likes = post_1.get("likeCount", 0)
+    
+    if final_likes <= initial_likes:
+        return 0.0, f"Post 1's like count did not increase: {initial_likes} -> {final_likes}"
+    
+    return 1.0, f"Successfully liked post 1 (ID: {post_1_id}), like count increased from {initial_likes} to {final_likes}"
+
+
+def _validate_openinlinecommentssection(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully opened the inline comments section for a post.
+    
+    Args:
+        initial_state: The initial state before opening comments
+        final_state: The final state after opening comments
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find the first post in feedDisplayedPosts
+    feed_posts = final_state.get("feedDisplayedPosts", [])
+    if len(feed_posts) == 0:
+        return 0.0, "No posts in feedDisplayedPosts"
+    
+    first_post = feed_posts[0]
+    post_id = first_post.get("id")
+    
+    # Check: isCommentsOpen should be true
+    comments_open = first_post.get("isCommentsOpen", False)
+    if not comments_open:
+        return 0.0, f"Comments section is not open for post {post_id}"
+    
+    return 1.0, f"Successfully opened comments section for post {post_id}"
+
+
+def _validate_navigateviatrendingtopic(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully navigated to search results via trending topic.
+    
+    Args:
+        initial_state: The initial state before navigation
+        final_state: The final state after navigation
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check 1: currentView is "search"
+    current_view = final_state.get("currentView")
+    if current_view != "search":
+        return 0.0, f"Not on search results page, current view: {current_view}"
+    
+    # Check 2: searchQuery is set (should match trending topic text)
+    search_query = final_state.get("searchQuery")
+    if not search_query or search_query == "":
+        return 0.0, "searchQuery is not set"
+    
+    # Check 3: search results are displayed (if any) - this is optional per success criteria
+    # Navigation is successful as long as we're on search page with query set
+    
+    return 1.0, f"Successfully navigated to search results with query '{search_query}'"
+
+
+def _validate_openpostcomposermoredropdown(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully typed in post composer and opened the more dropdown.
+    
+    Args:
+        initial_state: The initial state before typing
+        final_state: The final state after opening dropdown
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check 1: postComposerText contains typed text
+    composer_text = final_state.get("postComposerText", "")
+    if composer_text == "":
+        return 0.0, "postComposerText is empty"
+    
+    # Check 2: moreOptionsDropdownOpen is true
+    more_dropdown_open = final_state.get("moreOptionsDropdownOpen", False)
+    if not more_dropdown_open:
+        return 0.0, "moreOptionsDropdownOpen is not true"
+    
+    return 1.0, f"Successfully typed text and opened more dropdown"
+
+
+def _validate_unlikeallpostsonprofile(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully unliked all posts on a profile page.
+    
+    Args:
+        initial_state: The initial state before unliking (all posts liked)
+        final_state: The final state after unliking
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Get viewed user ID
+    viewed_user_id = final_state.get("viewedUserId")
+    if viewed_user_id is None:
+        return 0.0, "viewedUserId is None"
+    
+    # Find all posts by this user
+    all_posts = final_state.get("allPosts", [])
+    user_posts = [p for p in all_posts if p.get("user", {}).get("id") == viewed_user_id]
+    
+    if len(user_posts) == 0:
+        return 0.0, f"No posts found for user {viewed_user_id}"
+    
+    # Check: None of the user's posts should be in likedPostIds
+    liked_post_ids = final_state.get("likedPostIds", set())
+    if isinstance(liked_post_ids, list):
+        liked_post_ids = set(liked_post_ids)
+    
+    for post in user_posts:
+        post_id = post.get("id")
+        if post_id in liked_post_ids:
+            return 0.0, f"Post {post_id} is still in likedPostIds"
+    
+    # Check: All post like counts should have decreased
+    initial_posts = {p.get("id"): p for p in initial_state.get("allPosts", [])}
+    for post in user_posts:
+        post_id = post.get("id")
+        initial_post = initial_posts.get(post_id)
+        if initial_post:
+            initial_likes = initial_post.get("likeCount", 0)
+            final_likes = post.get("likeCount", 0)
+            if final_likes >= initial_likes:
+                return 0.0, f"Post {post_id} like count did not decrease: {initial_likes} -> {final_likes}"
+    
+    return 1.0, f"Successfully unliked all {len(user_posts)} posts on profile"
+
+
+def _validate_followuserandchecklatestfeed(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully followed a user and their posts appear in latest feed.
+    
+    Args:
+        initial_state: The initial state before following
+        final_state: The final state after navigating to latest feed
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find user 1 (用户小王)
+    users = final_state.get("users", [])
+    user_1 = _find_user_by_name(users, "用户小王")
+    
+    if user_1 is None:
+        return 0.0, "User '用户小王' not found in users list"
+    
+    user_1_id = user_1.get("id")
+    
+    # Check 1: User 1's ID is in followedUsers
+    followed_users = final_state.get("followedUsers", {})
+    if user_1_id not in followed_users:
+        return 0.0, f"User 1's ID '{user_1_id}' is not in followedUsers"
+    
+    # Check 2: currentView is "latest"
+    current_view = final_state.get("currentView")
+    if current_view != "latest":
+        return 0.0, f"Not on latest feed page, current view: {current_view}"
+    
+    # Check 3: latestDisplayedPosts contains posts from user 1
+    latest_posts = final_state.get("latestDisplayedPosts", [])
+    user_1_posts = [p for p in latest_posts if p.get("user", {}).get("id") == user_1_id]
+    
+    if len(user_1_posts) == 0:
+        return 0.0, f"No posts from user 1 found in latestDisplayedPosts"
+    
+    return 1.0, f"Successfully followed user 1 and found {len(user_1_posts)} posts in latest feed"
+
+
+def _validate_changetrendingtabandnavigate(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully changed trending tab and navigated to search results.
+    
+    Args:
+        initial_state: The initial state before changing tab
+        final_state: The final state after navigation
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check 1: hotSearchTab is "trending"
+    hot_search_tab = final_state.get("hotSearchTab")
+    if hot_search_tab != "trending":
+        return 0.0, f"Expected hotSearchTab to be 'trending', got '{hot_search_tab}'"
+    
+    # Check 2: currentView is "search"
+    current_view = final_state.get("currentView")
+    if current_view != "search":
+        return 0.0, f"Not on search results page, current view: {current_view}"
+    
+    # Check 3: searchQuery is set to trending topic text
+    search_query = final_state.get("searchQuery")
+    if not search_query or search_query == "":
+        return 0.0, "searchQuery is not set"
+    
+    # Check 4: Search results page displays a hashtag banner (check if hashtagTopics exists)
+    # If searchQuery is a hashtag (wrapped in #), extract the text between # symbols
+    # hashtagTopics keys are the plain text without # symbols
+    hashtag_topics = final_state.get("hashtagTopics", {})
+    query = search_query.strip()
+    hashtag_text = query
+    
+    # Extract hashtag text if wrapped in # symbols (e.g., "#习近平欢迎西班牙国王访华#" -> "习近平欢迎西班牙国王访华")
+    if query.startswith("#") and query.endswith("#"):
+        hashtag_text = query[1:-1]  # Remove # from both ends
+    
+    if hashtag_text not in hashtag_topics:
+        return 0.0, f"Hashtag '{hashtag_text}' not found in hashtagTopics (banner may not be displayed)"
+    
+    return 1.0, f"Successfully changed tab and navigated to search results with query '{search_query}'"
+
+
+def _validate_createcustomgroupandnavigate(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully created a custom group and navigated to its feed.
+    
+    Args:
+        initial_state: The initial state before creating group
+        final_state: The final state after navigation
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check 1: A custom group with label "test" exists in customGroups
+    custom_groups = final_state.get("customGroups", [])
+    test_group = next((g for g in custom_groups if g.get("label") == "test"), None)
+    
+    if test_group is None:
+        return 0.0, "Custom group with label 'test' not found in customGroups"
+    
+    test_group_id = test_group.get("id")
+    
+    # Check 2: currentView is "custom-group-{groupId}"
+    current_view = final_state.get("currentView")
+    expected_view = f"custom-group-{test_group_id}"
+    if current_view != expected_view:
+        return 0.0, f"Expected currentView to be '{expected_view}', got '{current_view}'"
+    
+    # Check 3: Custom group feed is displayed
+    custom_group_displayed_posts = final_state.get("customGroupDisplayedPosts", {})
+    group_posts = custom_group_displayed_posts.get(test_group_id, [])
+    
+    # Feed should exist (even if empty)
+    if test_group_id not in custom_group_displayed_posts:
+        return 0.0, f"Custom group feed not found for group {test_group_id}"
+    
+    return 1.0, f"Successfully created custom group 'test' and navigated to its feed"
+
+
+def _validate_deletecustomgroup(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully deleted the first custom group.
+    
+    Args:
+        initial_state: The initial state before deletion
+        final_state: The final state after deletion
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Get first custom group from initial state
+    initial_groups = initial_state.get("customGroups", [])
+    if len(initial_groups) == 0:
+        return 0.0, "No custom groups in initial state"
+    
+    first_group_id = initial_groups[0].get("id")
+    
+    # Check: First custom group no longer exists in customGroups
+    final_groups = final_state.get("customGroups", [])
+    deleted_group = next((g for g in final_groups if g.get("id") == first_group_id), None)
+    
+    if deleted_group is not None:
+        return 0.0, f"First custom group (ID: {first_group_id}) still exists in customGroups"
+    
+    return 1.0, f"Successfully deleted first custom group (ID: {first_group_id})"
+
+
+def _validate_editcustomgroupname(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully edited the first custom group's name.
+    
+    Args:
+        initial_state: The initial state before editing
+        final_state: The final state after editing
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Get first custom group from initial state
+    initial_groups = initial_state.get("customGroups", [])
+    if len(initial_groups) == 0:
+        return 0.0, "No custom groups in initial state"
+    
+    first_group_id = initial_groups[0].get("id")
+    initial_label = initial_groups[0].get("label")
+    
+    # Check: First custom group's label has been updated
+    final_groups = final_state.get("customGroups", [])
+    updated_group = next((g for g in final_groups if g.get("id") == first_group_id), None)
+    
+    if updated_group is None:
+        return 0.0, f"First custom group (ID: {first_group_id}) not found in final state"
+    
+    final_label = updated_group.get("label")
+    if final_label == initial_label:
+        return 0.0, f"Group label was not updated: still '{initial_label}'"
+    
+    return 1.0, f"Successfully updated group label from '{initial_label}' to '{final_label}'"
+
+
+def _validate_followandunfollowfromprofile(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully followed then unfollowed a user from their profile.
+    
+    Args:
+        initial_state: The initial state before following
+        final_state: The final state after unfollowing
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find user 2 (need to identify which user this is - checking task details suggests it's a specific user)
+    # Since we don't have the exact user name, we'll check that a user was followed then unfollowed
+    # by checking that current view is profile and user is not in followedUsers
+    
+    # Check 1: currentView is "profile"
+    current_view = final_state.get("currentView")
+    if current_view != "profile":
+        return 0.0, f"Not on profile page, current view: {current_view}"
+    
+    # Check 2: viewedUserId matches user 2
+    viewed_user_id = final_state.get("viewedUserId")
+    if viewed_user_id is None:
+        return 0.0, "viewedUserId is None"
+    
+    # Check 3: User 2's ID is not in followedUsers (was unfollowed)
+    followed_users = final_state.get("followedUsers", {})
+    if viewed_user_id in followed_users:
+        return 0.0, f"User 2's ID '{viewed_user_id}' is still in followedUsers (not unfollowed)"
+    
+    # Verify that user was initially followed (check initial state had them not followed)
+    initial_followed = initial_state.get("followedUsers", {})
+    if viewed_user_id in initial_followed:
+        return 0.0, f"User 2 was already followed in initial state"
+    
+    return 1.0, f"Successfully followed then unfollowed user {viewed_user_id}"
+
+
+def _validate_unassignspecialattentionandgroups(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully unassigned special attention and groups from a user.
+    
+    Args:
+        initial_state: The initial state before unassigning
+        final_state: The final state after unassigning
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Get viewed user ID
+    viewed_user_id = final_state.get("viewedUserId")
+    if viewed_user_id is None:
+        return 0.0, "viewedUserId is None"
+    
+    # Check 1: User's ID is in followedUsers
+    followed_users = final_state.get("followedUsers", {})
+    if viewed_user_id not in followed_users:
+        return 0.0, f"User's ID '{viewed_user_id}' is not in followedUsers"
+    
+    user_follow_data = followed_users.get(viewed_user_id, {})
+    
+    # Check 2: isSpecialAttention is false (or not set)
+    is_special = user_follow_data.get("isSpecialAttention", False)
+    if is_special:
+        return 0.0, f"isSpecialAttention is still true for user {viewed_user_id}"
+    
+    # Check 3: User is not assigned to any groups (groups array is empty/not set)
+    groups = user_follow_data.get("groups", [])
+    if groups and len(groups) > 0:
+        return 0.0, f"User is still assigned to groups: {groups}"
+    
+    return 1.0, f"Successfully unassigned special attention and groups from user {viewed_user_id}"
+
+
+def _validate_createcommentwithinlinesection(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully created a comment using the inline comments section.
+    
+    Args:
+        initial_state: The initial state before creating comment
+        final_state: The final state after creating comment
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find post 2 (posted by 科技资讯)
+    all_posts = final_state.get("allPosts", [])
+    post_2 = _find_post_by_user_name(all_posts, "科技资讯", 0)  # First post by 科技资讯
+    
+    if post_2 is None:
+        return 0.0, "Post 2 (posted by 科技资讯) not found"
+    
+    post_2_id = post_2.get("id")
+    
+    # Check 1: Post 2's comments section is open
+    feed_posts = final_state.get("feedDisplayedPosts", [])
+    displayed_post = next((p for p in feed_posts if p.get("id") == post_2_id), None)
+    
+    if displayed_post is None:
+        return 0.0, f"Post 2 not found in feedDisplayedPosts"
+    
+    comments_open = displayed_post.get("isCommentsOpen", False)
+    if not comments_open:
+        return 0.0, f"Post 2's comments section is not open"
+    
+    # Check 2: A new comment has been added to post 2's comments array
+    initial_post = next((p for p in initial_state.get("allPosts", []) if p.get("id") == post_2_id), None)
+    initial_comments = initial_post.get("comments", []) if initial_post else []
+    final_comments = post_2.get("comments", [])
+    
+    if len(final_comments) <= len(initial_comments):
+        return 0.0, f"No new comment added: {len(initial_comments)} -> {len(final_comments)}"
+    
+    return 1.0, f"Successfully created comment on post 2 (comments: {len(initial_comments)} -> {len(final_comments)})"
+
+
+def _validate_followandsetspecialattentionflow(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully followed users and set special attention, then verified posts in feed.
+    
+    Args:
+        initial_state: The initial state before following
+        final_state: The final state after navigating to special follow feed
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find users
+    users = final_state.get("users", [])
+    user_1 = _find_user_by_name(users, "用户小王")
+    user_2 = _find_user_by_name(users, "科技资讯")
+    
+    if user_1 is None:
+        return 0.0, "User '用户小王' not found"
+    if user_2 is None:
+        return 0.0, "User '科技资讯' not found"
+    
+    user_1_id = user_1.get("id")
+    user_2_id = user_2.get("id")
+    
+    # Check 1: User 1's ID is in followedUsers
+    followed_users = final_state.get("followedUsers", {})
+    if user_1_id not in followed_users:
+        return 0.0, f"User 1's ID '{user_1_id}' is not in followedUsers"
+    
+    # Check 2: User 2's ID is in followedUsers with isSpecialAttention: true
+    if user_2_id not in followed_users:
+        return 0.0, f"User 2's ID '{user_2_id}' is not in followedUsers"
+    
+    user_2_data = followed_users.get(user_2_id, {})
+    is_special = user_2_data.get("isSpecialAttention", False)
+    if not is_special:
+        return 0.0, f"User 2's isSpecialAttention is not true"
+    
+    # Check 3: currentView is "special-follow"
+    current_view = final_state.get("currentView")
+    if current_view != "special-follow":
+        return 0.0, f"Not on special follow feed, current view: {current_view}"
+    
+    # Check 4: specialFollowDisplayedPosts contains posts from user 2
+    special_posts = final_state.get("specialFollowDisplayedPosts", [])
+    user_2_posts = [p for p in special_posts if p.get("user", {}).get("id") == user_2_id]
+    
+    if len(user_2_posts) == 0:
+        return 0.0, f"No posts from user 2 found in specialFollowDisplayedPosts"
+    
+    return 1.0, f"Successfully followed users and found {len(user_2_posts)} posts from user 2 in special follow feed"
+
+
+def _validate_createpostwithexpressions(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully created a post with expressions.
+    
+    Args:
+        initial_state: The initial state before creating post
+        final_state: The final state after creating post
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check: A new post has been created
+    initial_posts = initial_state.get("allPosts", [])
+    final_posts = final_state.get("allPosts", [])
+    
+    if len(final_posts) <= len(initial_posts):
+        return 0.0, f"No new post created: {len(initial_posts)} -> {len(final_posts)}"
+    
+    # Find the new post (should be first in feedDisplayedPosts and not in initial allPosts)
+    feed_posts = final_state.get("feedDisplayedPosts", [])
+    if len(feed_posts) == 0:
+        return 0.0, "No posts in feedDisplayedPosts"
+    
+    new_post_id = feed_posts[0].get("id")
+    initial_post_ids = {p.get("id") for p in initial_posts}
+    
+    if new_post_id in initial_post_ids:
+        return 0.0, f"Post {new_post_id} already existed in initial state"
+    
+    new_post = next((p for p in final_posts if p.get("id") == new_post_id), None)
+    if new_post is None:
+        return 0.0, f"New post {new_post_id} not found in allPosts"
+    
+    # Check: Post content includes typed text and expressions
+    post_content = new_post.get("content", "")
+    if post_content == "":
+        return 0.0, "New post content is empty"
+    
+    # Check if content contains expressions (typically emoji-like characters)
+    # Expressions might be embedded in content or stored separately
+    # For now, just verify content exists and post is visible
+    
+    # Check: Post is visible in main feed
+    if new_post_id != feed_posts[0].get("id"):
+        return 0.0, "New post is not first in feedDisplayedPosts"
+    
+    return 1.0, f"Successfully created post with expressions (ID: {new_post_id})"
+
+
+def _validate_createcommentwithexpressionsondetail(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully created a comment with expressions on post detail page.
+    
+    Args:
+        initial_state: The initial state before creating comment
+        final_state: The final state after creating comment
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check 1: currentView is "post"
+    current_view = final_state.get("currentView")
+    if current_view != "post":
+        return 0.0, f"Not on post detail page, current view: {current_view}"
+    
+    # Check 2: viewedPostId is post 2's ID
+    viewed_post_id = final_state.get("viewedPostId")
+    if viewed_post_id is None:
+        return 0.0, "viewedPostId is None"
+    
+    # Find post 2 (posted by 科技资讯)
+    all_posts = final_state.get("allPosts", [])
+    post_2 = _find_post_by_user_name(all_posts, "科技资讯", 0)
+    
+    if post_2 is None:
+        return 0.0, "Post 2 (posted by 科技资讯) not found"
+    
+    if post_2.get("id") != viewed_post_id:
+        return 0.0, f"viewedPostId '{viewed_post_id}' does not match post 2"
+    
+    # Check 3: A new comment has been added with expressions
+    initial_post = next((p for p in initial_state.get("allPosts", []) if p.get("id") == viewed_post_id), None)
+    initial_comments = initial_post.get("comments", []) if initial_post else []
+    final_comments = post_2.get("comments", [])
+    
+    if len(final_comments) <= len(initial_comments):
+        return 0.0, f"No new comment added: {len(initial_comments)} -> {len(final_comments)}"
+    
+    return 1.0, f"Successfully created comment with expressions on post 2 (comments: {len(initial_comments)} -> {len(final_comments)})"
+
+
+def _validate_followassigntogroupandnavigate(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully followed a user, assigned them to a group, and navigated to group feed.
+    
+    Args:
+        initial_state: The initial state before following
+        final_state: The final state after navigating to group feed
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find user 1 (用户小王)
+    users = final_state.get("users", [])
+    user_1 = _find_user_by_name(users, "用户小王")
+    
+    if user_1 is None:
+        return 0.0, "User '用户小王' not found"
+    
+    user_1_id = user_1.get("id")
+    
+    # Check 1: User 1's ID is in followedUsers with groups array containing a custom group ID
+    followed_users = final_state.get("followedUsers", {})
+    if user_1_id not in followed_users:
+        return 0.0, f"User 1's ID '{user_1_id}' is not in followedUsers"
+    
+    user_1_data = followed_users.get(user_1_id, {})
+    groups = user_1_data.get("groups", [])
+    
+    if len(groups) == 0:
+        return 0.0, f"User 1 is not assigned to any groups"
+    
+    group_id = groups[0]  # Get first group
+    
+    # Check 2: currentView is "custom-group-{groupId}"
+    current_view = final_state.get("currentView")
+    expected_view = f"custom-group-{group_id}"
+    if current_view != expected_view:
+        return 0.0, f"Expected currentView to be '{expected_view}', got '{current_view}'"
+    
+    # Check 3: customGroupDisplayedPosts for that group contains posts from user 1
+    custom_group_posts = final_state.get("customGroupDisplayedPosts", {})
+    group_posts = custom_group_posts.get(group_id, [])
+    user_1_posts = [p for p in group_posts if p.get("user", {}).get("id") == user_1_id]
+    
+    if len(user_1_posts) == 0:
+        return 0.0, f"No posts from user 1 found in custom group feed"
+    
+    return 1.0, f"Successfully followed user 1, assigned to group, and found {len(user_1_posts)} posts in group feed"
+
+
+def _validate_searchfollowlastuser(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully searched and followed the last user from search results.
+    
+    Args:
+        initial_state: The initial state before searching
+        final_state: The final state after following
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check 1: currentView is "search"
+    current_view = final_state.get("currentView")
+    if current_view != "search":
+        return 0.0, f"Not on search results page, current view: {current_view}"
+    
+    # Check 2: searchQuery is "用"
+    search_query = final_state.get("searchQuery")
+    if search_query != "用":
+        return 0.0, f"Expected searchQuery to be '用', got '{search_query}'"
+    
+    # Check 3: searchCategory is "users"
+    search_category = final_state.get("searchCategory")
+    if search_category != "users":
+        return 0.0, f"Expected searchCategory to be 'users', got '{search_category}'"
+    
+    # Check 4: searchPageResults.users contains multiple users
+    search_page_results = final_state.get("searchPageResults", {})
+    users = search_page_results.get("users", [])
+    
+    if len(users) < 2:
+        return 0.0, f"Expected multiple users in search results, got {len(users)}"
+    
+    # Check 5: Last user's ID is in followedUsers
+    last_user = users[-1]
+    last_user_id = last_user.get("id")
+    
+    followed_users = final_state.get("followedUsers", {})
+    if last_user_id not in followed_users:
+        return 0.0, f"Last user's ID '{last_user_id}' is not in followedUsers"
+    
+    return 1.0, f"Successfully searched and followed last user (ID: {last_user_id})"
+
+
+def _validate_followcreategroupandassignflow(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """
+    Validate that the user successfully followed a user, created a group, and assigned the user to it.
+    
+    Args:
+        initial_state: The initial state before following
+        final_state: The final state after assigning
+        
+    Returns:
+        Tuple of (score, reason) where score is 1.0 for success, 0.0 for failure
+    """
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Get viewed user ID
+    viewed_user_id = final_state.get("viewedUserId")
+    if viewed_user_id is None:
+        return 0.0, "viewedUserId is None"
+    
+    # Check 1: User's ID is in followedUsers
+    followed_users = final_state.get("followedUsers", {})
+    if viewed_user_id not in followed_users:
+        return 0.0, f"User's ID '{viewed_user_id}' is not in followedUsers"
+    
+    # Check 2: A new custom group exists in customGroups
+    initial_groups = initial_state.get("customGroups", [])
+    final_groups = final_state.get("customGroups", [])
+    
+    if len(final_groups) <= len(initial_groups):
+        return 0.0, f"No new custom group created: {len(initial_groups)} -> {len(final_groups)}"
+    
+    # Find the new group (should be one that wasn't in initial state)
+    initial_group_ids = {g.get("id") for g in initial_groups}
+    new_group = next((g for g in final_groups if g.get("id") not in initial_group_ids), None)
+    
+    if new_group is None:
+        return 0.0, "No new custom group found"
+    
+    new_group_id = new_group.get("id")
+    
+    # Check 3: User's ID is in followedUsers with groups array containing the new group ID
+    user_data = followed_users.get(viewed_user_id, {})
+    groups = user_data.get("groups", [])
+    
+    if new_group_id not in groups:
+        return 0.0, f"User is not assigned to new group '{new_group_id}'"
+    
+    # Check 4: manageGroupsModalOpen is false (modal closed)
+    modal_open = final_state.get("manageGroupsModalOpen", False)
+    if modal_open:
+        return 0.0, "manageGroupsModalOpen is still true (modal not closed)"
+    
+    return 1.0, f"Successfully followed user, created group '{new_group.get('label')}', and assigned user to it"
+
+
 # Registry of all Weibo reward functions
 REWARD_FUNCTIONS_WEIBO = {
     "_validate_navigateprofile": _validate_navigateprofile,
@@ -920,5 +1795,25 @@ REWARD_FUNCTIONS_WEIBO = {
     "_validate_videopostfromprofile": _validate_videopostfromprofile,
     "_validate_profilefromreply": _validate_profilefromreply,
     "_validate_searchusers": _validate_searchusers,
+    # New breadth 1 tasks
+    "_validate_navigatetoemptylatestfeed": _validate_navigatetoemptylatestfeed,
+    "_validate_likepostfrommainfeed": _validate_likepostfrommainfeed,
+    "_validate_openinlinecommentssection": _validate_openinlinecommentssection,
+    "_validate_navigateviatrendingtopic": _validate_navigateviatrendingtopic,
+    "_validate_openpostcomposermoredropdown": _validate_openpostcomposermoredropdown,
+    "_validate_unlikeallpostsonprofile": _validate_unlikeallpostsonprofile,
+    "_validate_followuserandchecklatestfeed": _validate_followuserandchecklatestfeed,
+    "_validate_changetrendingtabandnavigate": _validate_changetrendingtabandnavigate,
+    "_validate_createcustomgroupandnavigate": _validate_createcustomgroupandnavigate,
+    "_validate_deletecustomgroup": _validate_deletecustomgroup,
+    "_validate_editcustomgroupname": _validate_editcustomgroupname,
+    "_validate_followandunfollowfromprofile": _validate_followandunfollowfromprofile,
+    "_validate_unassignspecialattentionandgroups": _validate_unassignspecialattentionandgroups,
+    "_validate_createcommentwithinlinesection": _validate_createcommentwithinlinesection,
+    "_validate_followandsetspecialattentionflow": _validate_followandsetspecialattentionflow,
+    "_validate_createpostwithexpressions": _validate_createpostwithexpressions,
+    "_validate_createcommentwithexpressionsondetail": _validate_createcommentwithexpressionsondetail,
+    "_validate_followassigntogroupandnavigate": _validate_followassigntogroupandnavigate,
+    "_validate_searchfollowlastuser": _validate_searchfollowlastuser,
+    "_validate_followcreategroupandassignflow": _validate_followcreategroupandassignflow,
 }
-