src/graphics/display/drivers/coordinator/client-vsync-queue-test.cc

// Copyright 2025 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/graphics/display/drivers/coordinator/client-vsync-queue.h"

#include <lib/driver/testing/cpp/scoped_global_logger.h>
#include <lib/zx/time.h>

#include <vector>

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "src/graphics/display/lib/api-types/cpp/config-stamp.h"
#include "src/graphics/display/lib/api-types/cpp/display-id.h"
#include "src/graphics/display/lib/api-types/cpp/vsync-ack-cookie.h"

namespace display_coordinator {

namespace {

class ClientVsyncQueueTest : public ::testing::Test {
 private:
  fdf_testing::ScopedGlobalLogger logger_;
};

constexpr ClientVsyncQueue::Message CreateTestMessage(int sequence_number) {
  return {
      .display_id = display::DisplayId(1000 + sequence_number),
      .timestamp = zx::time_monotonic(2000 + sequence_number),
      .config_stamp = display::ConfigStamp(3000 + sequence_number),
  };
}

TEST_F(ClientVsyncQueueTest, PushSingleMessage) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  static constexpr ClientVsyncQueue::Message kTestMessage = CreateTestMessage(0);
  queue.Push(kTestMessage);

  std::vector<ClientVsyncQueue::Message> sent_messages;
  queue.DrainUntilThrottled(
      [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie ack_cookie) {
        static_assert(ClientVsyncQueue::kRequestAckWatermark > 1);
        EXPECT_EQ(ack_cookie, display::kInvalidVsyncAckCookie);

        sent_messages.push_back(message);
      });

  EXPECT_THAT(sent_messages, ::testing::ElementsAre(kTestMessage));
}

TEST_F(ClientVsyncQueueTest, PushUpToRequestWatermark) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  for (int index = 0; index < ClientVsyncQueue::kRequestAckWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(index);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie ack_cookie) {
          EXPECT_EQ(ack_cookie, display::kInvalidVsyncAckCookie);
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::ElementsAre(test_message));
  }
}

TEST_F(ClientVsyncQueueTest, PushGeneratesCookieAtRequestWatermark) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  for (int index = 0; index < ClientVsyncQueue::kRequestAckWatermark; ++index) {
    queue.Push(CreateTestMessage(index));
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie ack_cookie) {
          ASSERT_EQ(ack_cookie, display::kInvalidVsyncAckCookie);
        });
  }

  static constexpr ClientVsyncQueue::Message kMessageWithCookie =
      CreateTestMessage(ClientVsyncQueue::kRequestAckWatermark);
  queue.Push(kMessageWithCookie);
  std::vector<ClientVsyncQueue::Message> sent_messages;
  queue.DrainUntilThrottled(
      [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie ack_cookie) {
        EXPECT_NE(ack_cookie, display::kInvalidVsyncAckCookie);
        sent_messages.push_back(message);
      });
  EXPECT_THAT(sent_messages, ::testing::ElementsAre(kMessageWithCookie));
}

TEST_F(ClientVsyncQueueTest, PushWithoutAckUpToThrottleWatermark) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  for (int index = 0; index < ClientVsyncQueue::kThrottleWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(index);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie ack_cookie) {
          if (index == ClientVsyncQueue::kRequestAckWatermark) {
            EXPECT_NE(ack_cookie, display::kInvalidVsyncAckCookie);
          } else {
            EXPECT_EQ(ack_cookie, display::kInvalidVsyncAckCookie);
          }
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::ElementsAre(test_message));
  }
}

TEST_F(ClientVsyncQueueTest, PushWithoutAckPastBufferSize) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  for (int index = 0; index < ClientVsyncQueue::kThrottleWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(index);
    queue.Push(test_message);

    queue.DrainUntilThrottled([&](const ClientVsyncQueue::Message&, display::VsyncAckCookie) {});
  }

  // Go past the buffer size to ensure that replacing entries in the
  // circular buffer does not result in crashes.
  for (int index = 0; index < ClientVsyncQueue::kThrottleBufferSize * 2; ++index) {
    const ClientVsyncQueue::Message test_message =
        CreateTestMessage(ClientVsyncQueue::kThrottleWatermark + index);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie ack_cookie) {
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::IsEmpty());
  }
}

TEST_F(ClientVsyncQueueTest, AcknowledgeBeforeAckCookieSent) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  static constexpr display::VsyncAckCookie kInvalidCookie(1);
  EXPECT_FALSE(queue.Acknowledge(kInvalidCookie));

  std::vector<ClientVsyncQueue::Message> sent_messages;
  queue.DrainUntilThrottled(
      [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie ack_cookie) {
        sent_messages.push_back(message);
      });
  EXPECT_THAT(sent_messages, ::testing::IsEmpty());
}

TEST_F(ClientVsyncQueueTest, AcknowledgeBeforeThrottle) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  display::VsyncAckCookie ack_cookie = display::kInvalidVsyncAckCookie;

  for (int index = 0; index < ClientVsyncQueue::kThrottleWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(index);
    queue.Push(test_message);

    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          if (cookie != display::kInvalidVsyncAckCookie) {
            ASSERT_EQ(ack_cookie, display::kInvalidVsyncAckCookie)
                << "New VSync cookie generated before old cookie acknowledged";
            ack_cookie = cookie;
          }
        });
  }
  ASSERT_NE(ack_cookie, display::kInvalidVsyncAckCookie) << "No VSync cookie generated";

  ASSERT_TRUE(queue.Acknowledge(ack_cookie));

  {
    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie ack_cookie) {
          sent_messages.push_back(message);
        });
    ASSERT_THAT(sent_messages, ::testing::IsEmpty())
        << "Messages queued before throttling was expected";
  }

  for (int index = 0; index < ClientVsyncQueue::kRequestAckWatermark; ++index) {
    const ClientVsyncQueue::Message test_message =
        CreateTestMessage(ClientVsyncQueue::kThrottleWatermark + index);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::ElementsAre(test_message))
        << "Incorrect queue state after cookie acknowledged";
  }
}

TEST_F(ClientVsyncQueueTest, AcknowledgeAfterThrottleBeforeDrop) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  display::VsyncAckCookie ack_cookie = display::kInvalidVsyncAckCookie;

  for (int index = 0; index < ClientVsyncQueue::kThrottleWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(index);
    queue.Push(test_message);

    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          if (cookie != display::kInvalidVsyncAckCookie) {
            ASSERT_EQ(ack_cookie, display::kInvalidVsyncAckCookie)
                << "New VSync cookie generated before old cookie acknowledged";
            ack_cookie = cookie;
          }
        });
  }
  ASSERT_NE(ack_cookie, display::kInvalidVsyncAckCookie) << "No VSync cookie generated";

  {
    std::vector<ClientVsyncQueue::Message> throttled_messages;
    for (int index = 0; index < ClientVsyncQueue::kThrottleBufferSize; ++index) {
      const ClientVsyncQueue::Message test_message =
          CreateTestMessage(ClientVsyncQueue::kThrottleWatermark + index);
      queue.Push(test_message);
      throttled_messages.push_back(test_message);

      std::vector<ClientVsyncQueue::Message> sent_messages;
      queue.DrainUntilThrottled(
          [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
            EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);
            sent_messages.push_back(message);
          });
      EXPECT_THAT(sent_messages, ::testing::IsEmpty())
          << "Message sent after throttling criteria met";
    }

    ASSERT_TRUE(queue.Acknowledge(ack_cookie));
    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled([&](const ClientVsyncQueue::Message& message,
                                  display::VsyncAckCookie cookie) {
      static_assert(ClientVsyncQueue::kThrottleBufferSize < ClientVsyncQueue::kRequestAckWatermark);
      EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);

      sent_messages.push_back(message);
    });
    EXPECT_THAT(sent_messages, ::testing::ElementsAreArray(throttled_messages))
        << "Throttled messages not sent after cookie acknowledged";
  }

  static constexpr int kMessagesLeftBeforeRequestWatermark =
      ClientVsyncQueue::kRequestAckWatermark - ClientVsyncQueue::kThrottleBufferSize;
  for (int index = 0; index < kMessagesLeftBeforeRequestWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(
        ClientVsyncQueue::kThrottleWatermark + ClientVsyncQueue::kThrottleBufferSize + index);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::ElementsAre(test_message))
        << "Incorrect queue state after cookie acknowledged";
  }

  {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(
        ClientVsyncQueue::kThrottleWatermark + ClientVsyncQueue::kRequestAckWatermark);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          EXPECT_NE(cookie, display::kInvalidVsyncAckCookie);
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::ElementsAre(test_message))
        << "Incorrect queue state after cookie acknowledged";
  }
}

TEST_F(ClientVsyncQueueTest, AcknowledgeWithInvalidCookie) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  display::VsyncAckCookie ack_cookie = display::kInvalidVsyncAckCookie;

  for (int index = 0; index < ClientVsyncQueue::kThrottleWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(index);
    queue.Push(test_message);

    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          if (cookie != display::kInvalidVsyncAckCookie) {
            ASSERT_EQ(ack_cookie, display::kInvalidVsyncAckCookie)
                << "New VSync cookie generated before old cookie acknowledged";
            ack_cookie = cookie;
          }
        });
  }
  ASSERT_NE(ack_cookie, display::kInvalidVsyncAckCookie) << "No VSync cookie generated";

  {
    std::vector<ClientVsyncQueue::Message> throttled_messages;
    for (int index = 0; index < ClientVsyncQueue::kThrottleBufferSize; ++index) {
      const ClientVsyncQueue::Message test_message =
          CreateTestMessage(ClientVsyncQueue::kThrottleWatermark + index);
      queue.Push(test_message);
      throttled_messages.push_back(test_message);

      std::vector<ClientVsyncQueue::Message> sent_messages;
      queue.DrainUntilThrottled(
          [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
            EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);
            sent_messages.push_back(message);
          });
      EXPECT_THAT(sent_messages, ::testing::IsEmpty())
          << "Message sent after throttling criteria met";
    }

    const display::VsyncAckCookie invalid_cookie(~ack_cookie.value());
    EXPECT_FALSE(queue.Acknowledge(invalid_cookie));
    {
      std::vector<ClientVsyncQueue::Message> sent_messages;
      queue.DrainUntilThrottled(
          [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
            sent_messages.push_back(message);
          });
      EXPECT_THAT(sent_messages, ::testing::IsEmpty())
          << "Throttled messages sent after incorrect cookie acknowledgement";
    }

    ASSERT_TRUE(queue.Acknowledge(ack_cookie));
    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled([&](const ClientVsyncQueue::Message& message,
                                  display::VsyncAckCookie cookie) {
      static_assert(ClientVsyncQueue::kThrottleBufferSize < ClientVsyncQueue::kRequestAckWatermark);
      EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);

      sent_messages.push_back(message);
    });
    EXPECT_THAT(sent_messages, ::testing::ElementsAreArray(throttled_messages))
        << "Throttled messages not sent after correct cookie acknowledged";
  }
}

TEST_F(ClientVsyncQueueTest, AcknowledgeAfterDrop) {
  ClientVsyncQueue queue(/*cookie_salt=*/0x11000);

  display::VsyncAckCookie ack_cookie = display::kInvalidVsyncAckCookie;

  for (int index = 0; index < ClientVsyncQueue::kThrottleWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(index);
    queue.Push(test_message);

    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          if (cookie != display::kInvalidVsyncAckCookie) {
            ASSERT_EQ(ack_cookie, display::kInvalidVsyncAckCookie)
                << "New VSync cookie generated before old cookie acknowledged";
            ack_cookie = cookie;
          }
        });
  }
  ASSERT_NE(ack_cookie, display::kInvalidVsyncAckCookie) << "No VSync cookie generated";

  for (int index = 0; index < ClientVsyncQueue::kThrottleWatermark; ++index) {
    const ClientVsyncQueue::Message test_message =
        CreateTestMessage(ClientVsyncQueue::kThrottleWatermark + index);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::IsEmpty())
        << "Message sent after throttling criteria met";
  }

  {
    std::vector<ClientVsyncQueue::Message> bufferred_messages;
    for (int index = 0; index < ClientVsyncQueue::kThrottleBufferSize; ++index) {
      const ClientVsyncQueue::Message test_message =
          CreateTestMessage((2 * ClientVsyncQueue::kThrottleWatermark) + index);
      queue.Push(test_message);
      bufferred_messages.push_back(test_message);

      std::vector<ClientVsyncQueue::Message> sent_messages;
      queue.DrainUntilThrottled(
          [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
            EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);
            sent_messages.push_back(message);
          });
      EXPECT_THAT(sent_messages, ::testing::IsEmpty())
          << "Message sent after throttling criteria met";
    }

    ASSERT_TRUE(queue.Acknowledge(ack_cookie));
    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled([&](const ClientVsyncQueue::Message& message,
                                  display::VsyncAckCookie cookie) {
      static_assert(ClientVsyncQueue::kThrottleBufferSize < ClientVsyncQueue::kRequestAckWatermark);
      EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);

      sent_messages.push_back(message);
    });
    EXPECT_THAT(sent_messages, ::testing::ElementsAreArray(bufferred_messages))
        << "Bufferred messages not sent after cookie acknowledged";
  }

  static constexpr int kMessagesLeftBeforeRequestWatermark =
      ClientVsyncQueue::kRequestAckWatermark - ClientVsyncQueue::kThrottleBufferSize;
  for (int index = 0; index < kMessagesLeftBeforeRequestWatermark; ++index) {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(
        (2 * ClientVsyncQueue::kThrottleWatermark) + ClientVsyncQueue::kThrottleBufferSize + index);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          EXPECT_EQ(cookie, display::kInvalidVsyncAckCookie);
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::ElementsAre(test_message))
        << "Incorrect queue state after cookie acknowledged";
  }

  {
    const ClientVsyncQueue::Message test_message = CreateTestMessage(
        (2 * ClientVsyncQueue::kThrottleWatermark) + ClientVsyncQueue::kRequestAckWatermark);
    queue.Push(test_message);

    std::vector<ClientVsyncQueue::Message> sent_messages;
    queue.DrainUntilThrottled(
        [&](const ClientVsyncQueue::Message& message, display::VsyncAckCookie cookie) {
          EXPECT_NE(cookie, display::kInvalidVsyncAckCookie);
          sent_messages.push_back(message);
        });
    EXPECT_THAT(sent_messages, ::testing::ElementsAre(test_message))
        << "Incorrect queue state after cookie acknowledged";
  }
}

}  // namespace

}  // namespace display_coordinator