fixed linting and tests

Author: Hardcode3

include/bitbishop/bitboard.hpp

@@ -53,10 +53,10 @@ class Bitboard {
   [[nodiscard]] constexpr uint64_t value() const { return m_bb; }
 
   /** @brief Returns a Bitboard instance with all bits set to zero. */
-  static constexpr Bitboard Zeros() noexcept { return Bitboard(0ULL); }
+  static constexpr Bitboard Zeros() noexcept { return {0ULL}; }
 
   /** @brief Returns a Bitbaord instance with all bits set to one. */
-  static constexpr Bitboard Ones() noexcept { return Bitboard(1ULL); }
+  static constexpr Bitboard Ones() noexcept { return {~0ULL}; }
 
   /**
    * @brief Sets a bit (places a piece) on a given square.

include/bitbishop/board.hpp

@@ -63,7 +63,7 @@ class Board {
    */
   Board(const std::string& fen);
 
-  [[nodiscard]] static Board Empty() noexcept { return Board("8/8/8/8/8/8/8/8 w KQkq - 0 1"); }
+  [[nodiscard]] static Board Empty() noexcept { return {"8/8/8/8/8/8/8/8 w KQkq - 0 1"}; }
 
   /**
    * @brief Retrieves the piece on a given square.

include/bitbishop/lookups/between_squares.hpp

@@ -16,6 +16,7 @@ namespace Lookups {
  * - +-8  for vertical movement (same file)
  * - +-9  for NE–SW diagonal movement
  * - +-7  for NW–SE diagonal movement
+ * - 0    if source and destination square are identical
  *
  * This function assumes that the two squares are aligned. Its primary use
  * is internal traversal of rays when building geometric lookup tables such
@@ -26,10 +27,23 @@ namespace Lookups {
  * @return The signed step value to advance one square toward @p to.
  */
 constexpr int direction(Square from, Square to) {
-  if (from.same_rank(to)) return (to.value() > from.value()) ? +1 : -1;
-  if (from.same_file(to)) return (to.value() > from.value()) ? +8 : -8;
-  if (from.same_ne_sw_diag(to)) return (to.value() > from.value()) ? +9 : -9;
-  return (to.value() > from.value()) ? +7 : -7;
+  if (from == to) {
+    return 0;
+  }
+  if (from.same_rank(to)) {
+    return (to.file() > from.file()) ? +1 : -1;
+  }
+  if (from.same_file(to)) {
+    return (to.rank() > from.rank()) ? +Const::BOARD_WIDTH : -Const::BOARD_WIDTH;
+  }
+  if (from.same_ne_sw_diag(to)) {
+    return (to.rank() > from.rank()) ? +(Const::BOARD_WIDTH + 1) : -(Const::BOARD_WIDTH + 1);
+  }
+  if (from.same_nw_se_diag(to)) {
+    return (to.rank() > from.rank()) ? +(Const::BOARD_WIDTH - 1) : -(Const::BOARD_WIDTH - 1);
+  }
+
+  return 0;
 }
 
 /**
@@ -50,14 +64,20 @@ constexpr int direction(Square from, Square to) {
  * @return A bitboard of squares strictly between @p from and @p to.
  */
 constexpr Bitboard ray_between(Square from, Square to) {
-  if (from == to) return Bitboard::Zeros();
+  if (from == to) {
+    return Bitboard::Zeros();
+  }
 
-  if (!(from.same_file(to) || from.same_rank(to) || from.same_diag(to))) return Bitboard::Zeros();
+  if (!(from.same_file(to) || from.same_rank(to) || from.same_diag(to))) {
+    return Bitboard::Zeros();
+  }
 
   const int step = direction(from, to);
   Bitboard ray = Bitboard::Zeros();
 
-  for (std::uint8_t square = from.value() + step; square != to.value(); square += step) ray.set(square);
+  for (std::uint8_t square = from.value() + step; square != to.value(); square += step) {
+    ray.set(square);
+  }
 
   return ray;
 }

src/bitbishop/movegen/check_mask.cpp

@@ -16,8 +16,8 @@ Bitboard compute_check_mask(Square king_sq, const Bitboard& checkers, const Boar
       board.knights(Color::WHITE) | board.knights(Color::BLACK) | board.pawns(Color::WHITE) | board.pawns(Color::BLACK);
   const bool is_knight_or_pawn = knights_and_pawns.test(checker_sq);
   if (is_knight_or_pawn) {
-    return Bitboard(checker_sq.value());
+    return checkers;
   }
 
-  return Lookups::ray_between(checker_sq, king_sq) | Bitboard(checker_sq.value());
+  return Lookups::ray_between(checker_sq, king_sq) | checkers;
 }

tests/bitbishop/bitboard/test_bb_constructors.cpp

@@ -90,6 +90,6 @@ TEST(BitboardTest, ZerosStaticConstructor) {
 TEST(BitboardTest, OnesStaticConstructor) {
   constexpr Bitboard bb = Bitboard::Ones();
 
-  static_assert(bb.value() == 1ULL, "Bitboard::Ones() static constructor must be constexpr");
-  EXPECT_EQ(bb.value(), 1ULL);
+  static_assert(bb.value() == (~0ULL), "Bitboard::Ones() static constructor must be constexpr");
+  EXPECT_EQ(bb.value(), (~0ULL));
 }

tests/bitbishop/lookups/test_between_squares/test_between_lookup.cpp

@@ -0,0 +1,73 @@
+#include <gtest/gtest.h>
+
+#include <bitbishop/bitboard.hpp>
+#include <bitbishop/lookups/between_squares.hpp>
+#include <bitbishop/square.hpp>
+
+using namespace Squares;
+using namespace Lookups;
+
+/**
+ * @test BETWEEN table for same rank lookups.
+ * @brief Confirms BETWEEN[from][to] contains correct horizontal rays.
+ */
+TEST(BetweenLookupTest, BetweenTableSameRank) {
+  const Bitboard& ray = BETWEEN[A1.value()][E1.value()];
+  EXPECT_TRUE(ray.test(B1));
+  EXPECT_TRUE(ray.test(C1));
+  EXPECT_TRUE(ray.test(D1));
+  EXPECT_FALSE(ray.test(A1));
+  EXPECT_FALSE(ray.test(E1));
+}
+
+/**
+ * @test BETWEEN table for same file lookups.
+ * @brief Confirms BETWEEN[from][to] contains correct vertical rays.
+ */
+TEST(BetweenLookupTest, BetweenTableSameFile) {
+  const Bitboard& ray = BETWEEN[D1.value()][D5.value()];
+  EXPECT_TRUE(ray.test(D2));
+  EXPECT_TRUE(ray.test(D3));
+  EXPECT_TRUE(ray.test(D4));
+  EXPECT_FALSE(ray.test(D1));
+  EXPECT_FALSE(ray.test(D5));
+}
+
+/**
+ * @test BETWEEN table for diagonal lookups.
+ * @brief Confirms BETWEEN[from][to] contains correct diagonal rays.
+ */
+TEST(BetweenLookupTest, BetweenTableDiagonal) {
+  const Bitboard& ray = BETWEEN[A1.value()][D4.value()];
+  EXPECT_TRUE(ray.test(B2));
+  EXPECT_TRUE(ray.test(C3));
+  EXPECT_EQ(ray.count(), 2);
+}
+
+/**
+ * @test BETWEEN table for non-aligned squares.
+ * @brief Confirms BETWEEN[from][to] is empty for unaligned squares.
+ */
+TEST(BetweenLookupTest, BetweenTableNonAligned) {
+  EXPECT_EQ(BETWEEN[A1.value()][B3.value()], Bitboard::Zeros());
+  EXPECT_EQ(BETWEEN[E4.value()][F6.value()], Bitboard::Zeros());
+}
+
+/**
+ * @test BETWEEN table symmetry.
+ * @brief Confirms BETWEEN[a][b] == BETWEEN[b][a].
+ */
+TEST(BetweenLookupTest, BetweenTableSymmetry) {
+  EXPECT_EQ(BETWEEN[A1.value()][H1.value()], BETWEEN[H1.value()][A1.value()]);
+  EXPECT_EQ(BETWEEN[A1.value()][H8.value()], BETWEEN[H8.value()][A1.value()]);
+}
+
+/**
+ * @test BETWEEN table diagonal property.
+ * @brief Confirms BETWEEN[x][x] is empty for all squares.
+ */
+TEST(BetweenLookupTest, BetweenTableDiagonalSameSquare) {
+  for (int i = 0; i < 64; ++i) {
+    EXPECT_EQ(BETWEEN[i][i], Bitboard::Zeros());
+  }
+}

tests/bitbishop/lookups/test_between_squares/test_direction.cpp

@@ -0,0 +1,61 @@
+#include <gtest/gtest.h>
+
+#include <bitbishop/bitboard.hpp>
+#include <bitbishop/lookups/between_squares.hpp>
+#include <bitbishop/square.hpp>
+
+using namespace Squares;
+using namespace Lookups;
+
+/**
+ * @test Seeking for the direction using identical source and destination squares should return .
+ */
+TEST(DirectionTest, DirectionSameSquare) {
+  EXPECT_EQ(direction(E4, E4), 0);
+  EXPECT_EQ(direction(A1, A1), 0);
+  EXPECT_EQ(direction(H8, H8), 0);
+}
+
+/**
+ * @test Horizontal direction on same rank (step = +-1).
+ * @brief Confirms direction() returns +1 for rightward and -1 for leftward movement.
+ */
+TEST(LookupsTest, DirectionSameRank) {
+  EXPECT_EQ(direction(A1, H1), +1);
+  EXPECT_EQ(direction(H1, A1), -1);
+  EXPECT_EQ(direction(D4, G4), +1);
+  EXPECT_EQ(direction(E5, B5), -1);
+}
+
+/**
+ * @test Vertical direction on same file (step = +-8).
+ * @brief Confirms direction() returns +8 for upward and -8 for downward movement.
+ */
+TEST(LookupsTest, DirectionSameFile) {
+  EXPECT_EQ(direction(A1, A8), +8);
+  EXPECT_EQ(direction(A8, A1), -8);
+  EXPECT_EQ(direction(E2, E6), +8);
+  EXPECT_EQ(direction(H7, H3), -8);
+}
+
+/**
+ * @test NE-SW diagonal direction (step = +-9).
+ * @brief Confirms direction() returns +9 for NE and -9 for SW movement.
+ */
+TEST(LookupsTest, DirectionNESWDiagonal) {
+  EXPECT_EQ(direction(A1, H8), +9);
+  EXPECT_EQ(direction(H8, A1), -9);
+  EXPECT_EQ(direction(C3, E5), +9);
+  EXPECT_EQ(direction(F6, D4), -9);
+}
+
+/**
+ * @test NW-SE diagonal direction (step = +-7).
+ * @brief Confirms direction() returns +7 for NW and -7 for SE movement.
+ */
+TEST(LookupsTest, DirectionNWSEDiagonal) {
+  EXPECT_EQ(direction(A8, H1), -7);
+  EXPECT_EQ(direction(H1, A8), +7);
+  EXPECT_EQ(direction(B6, E3), -7);
+  EXPECT_EQ(direction(F4, C7), +7);
+}