screenshot_assertion.h

Go to the documentation of this file.

#ifndef YAZE_APP_TEST_SCREENSHOT_ASSERTION_H
#define YAZE_APP_TEST_SCREENSHOT_ASSERTION_H
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
 
namespace yaze {
namespace test {
 
struct ScreenRegion {
  int x = 0;
  int y = 0;
  int width = 0;   // 0 = full width
  int height = 0;  // 0 = full height
 
  bool IsFullScreen() const { return width == 0 && height == 0; }
 
  static ScreenRegion FullScreen() { return {0, 0, 0, 0}; }
  static ScreenRegion At(int x, int y, int w, int h) { return {x, y, w, h}; }
};
 
struct ComparisonResult {
  bool passed = false;
  float similarity = 0.0f;             // 0.0 to 1.0 (1.0 = identical)
  float difference_percentage = 0.0f;  // Percentage of pixels that differ
  int total_pixels = 0;
  int differing_pixels = 0;
 
  // Difference visualization
  std::string diff_image_path;                  // Path to generated diff image
  std::vector<ScreenRegion> differing_regions;  // Clusters of differences
 
  // Performance
  std::chrono::milliseconds comparison_time{0};
  std::string error_message;
};
 
struct ComparisonConfig {
  float tolerance = 0.95f;  // Minimum similarity to pass (0.95 = 95%)
 
  // Per-pixel tolerance (for anti-aliasing, etc.)
  int color_threshold = 10;  // Max RGB difference per channel (0-255)
 
  // Ignore regions (for dynamic content like timers)
  std::vector<ScreenRegion> ignore_regions;
 
  // Output options
  bool generate_diff_image = true;
  std::string diff_output_dir = "/tmp/yaze_test_diffs";
 
  // Comparison algorithm
  enum class Algorithm {
    kPixelExact,      // Exact pixel match (with color threshold)
    kPerceptualHash,  // Perceptual hashing (more tolerant)
    kStructuralSim,   // SSIM-like structural comparison
  };
  Algorithm algorithm = Algorithm::kPixelExact;
};
 
struct Screenshot {
  std::vector<uint8_t> data;  // RGBA pixel data
  int width = 0;
  int height = 0;
  std::string source;  // Path or description of source
 
  bool IsValid() const {
    return !data.empty() && width > 0 && height > 0 &&
           data.size() == static_cast<size_t>(width * height * 4);
  }
 
  size_t GetPixelIndex(int x, int y) const {
    return static_cast<size_t>((y * width + x) * 4);
  }
};
 
class ScreenshotAssertion {
 public:
  ScreenshotAssertion();
  ~ScreenshotAssertion() = default;
 
  // Configuration
  void SetConfig(const ComparisonConfig& config) { config_ = config; }
  const ComparisonConfig& GetConfig() const { return config_; }
 
  // Screenshot capture
  using CaptureCallback = std::function<absl::StatusOr<Screenshot>()>;
  void SetCaptureCallback(CaptureCallback callback) {
    capture_callback_ = std::move(callback);
  }
 
  // --- Core Assertions ---
 
  absl::StatusOr<ComparisonResult> AssertMatchesReference(
      const std::string& reference_path);
 
  absl::StatusOr<ComparisonResult> AssertMatchesScreenshot(
      const Screenshot& expected);
 
  absl::StatusOr<ComparisonResult> AssertRegionMatches(
      const std::string& reference_path, const ScreenRegion& region);
 
  absl::StatusOr<ComparisonResult> AssertChanged(
      const std::string& baseline_name);
 
  absl::StatusOr<ComparisonResult> AssertUnchanged(
      const std::string& baseline_name);
 
  // --- Baseline Management ---
 
  absl::Status CaptureBaseline(const std::string& name);
 
  absl::Status SaveAsReference(const std::string& path);
 
  absl::StatusOr<Screenshot> LoadReference(const std::string& path);
 
  absl::StatusOr<Screenshot> GetBaseline(const std::string& name) const;
 
  void ClearBaselines() { baselines_.clear(); }
 
  // --- Comparison Utilities ---
 
  ComparisonResult Compare(const Screenshot& actual,
                           const Screenshot& expected);
 
  ComparisonResult CompareRegion(const Screenshot& actual,
                                 const Screenshot& expected,
                                 const ScreenRegion& region);
 
  absl::StatusOr<std::string> GenerateDiffImage(const Screenshot& actual,
                                                const Screenshot& expected,
                                                const std::string& output_path);
 
  // --- Pixel-Level Assertions ---
 
  absl::StatusOr<bool> AssertPixelColor(int x, int y, uint8_t r, uint8_t g,
                                        uint8_t b, int tolerance = 10);
 
  absl::StatusOr<bool> AssertRegionContainsColor(
      const ScreenRegion& region, uint8_t r, uint8_t g, uint8_t b,
      float min_coverage = 0.1f);  // At least 10% of pixels
 
  absl::StatusOr<bool> AssertRegionExcludesColor(const ScreenRegion& region,
                                                 uint8_t r, uint8_t g,
                                                 uint8_t b, int tolerance = 10);
 
  // --- Convenience Methods ---
 
  absl::StatusOr<Screenshot> CaptureScreen();
 
  static absl::Status SaveScreenshot(const Screenshot& screenshot,
                                     const std::string& path);
 
  static absl::StatusOr<Screenshot> LoadScreenshot(const std::string& path);
 
 private:
  ComparisonConfig config_;
  CaptureCallback capture_callback_;
  std::unordered_map<std::string, Screenshot> baselines_;
 
  // Comparison algorithms
  ComparisonResult ComparePixelExact(const Screenshot& actual,
                                     const Screenshot& expected,
                                     const ScreenRegion& region);
  ComparisonResult ComparePerceptualHash(const Screenshot& actual,
                                         const Screenshot& expected);
  ComparisonResult CompareStructural(const Screenshot& actual,
                                     const Screenshot& expected);
 
  // Helper methods
  bool ColorsMatch(uint8_t r1, uint8_t g1, uint8_t b1, uint8_t r2, uint8_t g2,
                   uint8_t b2, int threshold) const;
  std::vector<ScreenRegion> FindDifferingRegions(const Screenshot& actual,
                                                 const Screenshot& expected,
                                                 int threshold);
};
 
// --- Test Macros ---
 
#define YAZE_ASSERT_SCREENSHOT_MATCHES(assertion, reference_path)     \
  do {                                                                \
    auto result = (assertion).AssertMatchesReference(reference_path); \
    ASSERT_TRUE(result.ok()) << result.status().message();            \
    EXPECT_TRUE(result->passed)                                       \
        << "Screenshot mismatch: " << result->difference_percentage   \
        << "% different, expected <"                                  \
        << (1.0f - (assertion).GetConfig().tolerance) * 100           \
        << "%\nDiff image: " << result->diff_image_path;              \
  } while (0)
 
#define YAZE_ASSERT_SCREENSHOT_CHANGED(assertion, baseline_name) \
  do {                                                           \
    auto result = (assertion).AssertChanged(baseline_name);      \
    ASSERT_TRUE(result.ok()) << result.status().message();       \
    EXPECT_TRUE(result->passed)                                  \
        << "Expected screenshot to change but similarity was "   \
        << result->similarity * 100 << "%";                      \
  } while (0)
 
#define YAZE_ASSERT_SCREENSHOT_UNCHANGED(assertion, baseline_name) \
  do {                                                             \
    auto result = (assertion).AssertUnchanged(baseline_name);      \
    ASSERT_TRUE(result.ok()) << result.status().message();         \
    EXPECT_TRUE(result->passed)                                    \
        << "Expected screenshot unchanged but "                    \
        << result->difference_percentage << "% different\n"        \
        << "Diff image: " << result->diff_image_path;              \
  } while (0)
 
}  // namespace test
}  // namespace yaze
 
#endif  // YAZE_APP_TEST_SCREENSHOT_ASSERTION_H