Initialize project

.gitignore

@@ -0,0 +1,2 @@
+build
+stockfish

.gitlab-ci.yml

@@ -0,0 +1,8 @@
+archlinux:
+  image: "archlinux:latest"
+  before_script:
+    - pacman -Sy base-devel cmake wget --noconfirm --needed
+  script:
+    - mkdir build && cd build && cmake ../ && make && cd ../
+    - ./tests/stockfish.sh && ./tests/berserk.sh
+    - cd build && ctest

CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.10)
+project(uciadapter)
+
+# Configure Process
+add_definitions(-DUNIX)
+SET(process src/ProcessLinux.cpp)
+if(WIN32)
+    remove_definitions(-DUNIX)
+    message(FATAL_ERROR "uciadapter is not yet compatible with Windows")
+endif()
+add_library(uciadapter SHARED src/UCI.cpp ${process})
+
+# Includes
+set(UCIADAPTER_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/includes) # For conveniance
+set(UCIADAPTER_INCLUDE_DIR ${UCIADAPTER_INCLUDE_DIR} PARENT_SCOPE) # To be used by other projects with add_subdirectory()
+file(MAKE_DIRECTORY ${UCIADAPTER_INCLUDE_DIR})
+configure_file(src/UCI.hpp ${UCIADAPTER_INCLUDE_DIR} COPYONLY)
+configure_file(src/Process.hpp ${UCIADAPTER_INCLUDE_DIR} COPYONLY)
+configure_file(src/ProcessLinux.hpp ${UCIADAPTER_INCLUDE_DIR} COPYONLY)
+include_directories(${UCIADAPTER_INCLUDE_DIR})
+
+# Tests
+enable_testing()
+add_subdirectory("tests/")

README.md

@@ -0,0 +1,34 @@
+# uciadapter
+*uciadapter* is a C++ library that allows you to communicate with any chess
+engines that follows the [UCI Protocol](http://wbec-ridderkerk.nl/html/UCIProtocol.html).
+It aims to work on Linux and Windows (not yet on windows).
+
+# How to use it ?
+PGNP can be used as a shared library in your project.
+You only need to include `uciadapter.hpp` and linking the .so file to your
+executable.
+
+# Example
+Somewhere at the beginning of the file:
+
+    #include "uciadapter.hpp"
+
+Example (assuming not catching exceptions):
+
+    uciadapter::UCI u("/path/to/engine");
+    u.position("2k2r2/6R1/8/8/8/6Q1/4K3/8 w - - 0 1");
+    u.go(uciadapter::Go()); // Launch go with no arguments
+    u.SyncAfter(2); // Wait 2s and fetch data from engine
+    // Then:
+    // u.GetLines(); // To fetch best lines
+    // u.Command("<your command>") // Run custom commands
+    // u.GetName(); // Engine name
+    // u.GetAuthor(); // Fetch engine author
+
+Please look at `UCI.hpp` for more informations on the available API.
+
+# CMake Integration
+By using the `add_subdirectory()` directive on this repository, you will be able to use the following cmake calls in your project:
+
+    include_directories(${UCIADAPTER_INCLUDE_DIR})
+    target_link_libraries(<YOUR_TARGET> uciadapter)

main.cpp

@@ -0,0 +1,15 @@
+#include <iostream>
+#include <string>
+#include "UCI.hpp"
+
+using namespace uciadapter;
+using namespace std;
+
+int main() {
+
+  UCI u("/home/loic/Stockfish-sf_14.1/src/stockfish");
+
+  std::cout << u.GetBuffer() << std::endl;
+
+  return (0);
+}

src/Process.hpp

@@ -0,0 +1,28 @@
+#include <string>
+
+#define ENGINE_TIMEOUT 5 // In seconds
+#define BUFFER_SIZE 1024
+
+namespace uciadapter {
+
+class Process {
+
+public:
+  /// @brief Kill the engine
+  virtual void Kill() = 0;
+  /// @brief Start the engine from file path
+  virtual void Start(std::string) = 0;
+  /// @brief Read one line from the stdout of the engine (could raise a ReadTimeoutExpire)
+  virtual std::string ReadLine() = 0;
+  /// @brief Write to engine stdin
+  virtual void Write(std::string) = 0;
+};
+
+struct FailedToStartEngine : public std::exception {
+  const char *what() const throw() { return ("Could not start the engine"); }
+};
+struct ReadTimeoutExpire : public std::exception {
+  const char *what() const throw() { return ("Engine is not responding"); }
+};
+
+} // namespace uciadapter

src/ProcessLinux.cpp

@@ -0,0 +1,72 @@
+#include "ProcessLinux.hpp"
+
+namespace uciadapter {
+
+ProcessLinux::ProcessLinux() {
+
+  pipe(in_fd);
+  pipe(out_fd);
+}
+
+void ProcessLinux::Kill() { kill(pid, SIGTERM); }
+
+void ProcessLinux::Start(std::string path) {
+  pid = fork();
+  if (pid == 0) {
+    // Connect output of child process
+    close(out_fd[0]);
+    dup2(out_fd[1], STDOUT_FILENO);
+    close(out_fd[1]);
+    // Connect input of child process
+    close(in_fd[1]);
+    dup2(in_fd[0], STDIN_FILENO);
+    close(in_fd[0]);
+
+    const char *args[] = {path.c_str(), NULL};
+    execvp(args[0], const_cast<char *const *>(args));
+
+    _exit(1);
+  } else if (pid < 0) {
+    throw FailedToStartEngine();
+  }
+
+  // Parent do not read the in of the child
+  close(in_fd[0]);
+  // The parent do not write on the out of the child
+  close(out_fd[1]);
+  //  Set descriptor to non-blocking (for the read syscall)
+  int flags = fcntl(out_fd[0], F_GETFL, 0);
+  fcntl(out_fd[0], F_SETFL, flags | O_NONBLOCK);
+}
+
+std::string ProcessLinux::ReadLine() {
+  std::string line;
+  auto start = std::chrono::system_clock::now();
+  // Read char by char
+  while (true) {
+    char c;
+    int status = read(out_fd[0], &c, 1);
+    if (status > 0) {
+      line += c;
+      if (c == '\n')
+        break;
+    } else {
+      // Check for timeout
+      auto end = std::chrono::system_clock::now();
+      auto elapsed =
+          std::chrono::duration_cast<std::chrono::seconds>(end - start);
+      if (elapsed.count() > ENGINE_TIMEOUT) {
+        throw ReadTimeoutExpire();
+      }
+    }
+  }
+  return (std::string(line));
+}
+
+void ProcessLinux::Write(std::string data) {
+  for (unsigned int i = 0; i < data.size(); i++) {
+    buffer[i] = data[i];
+  }
+  write(in_fd[1], buffer, data.size());
+}
+} // namespace uciadapter

src/ProcessLinux.hpp

@@ -0,0 +1,26 @@
+#include "Process.hpp"
+#include <chrono>
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+namespace uciadapter {
+
+class ProcessLinux : public Process {
+  /// @brief Create pipe to engine stdin
+  int in_fd[2];
+  /// @brief Create pipe to the engine stdout
+  int out_fd[2];
+  /// @brief Writing buffer
+  char buffer[BUFFER_SIZE];
+  /// @brief Contains engine pid
+  pid_t pid;
+
+public:
+  ProcessLinux();
+  void Kill();
+  void Start(std::string);
+  std::string ReadLine();
+  void Write(std::string);
+};
+}; // namespace uciadapter

src/UCI.cpp

@@ -0,0 +1,281 @@
+#include "UCI.hpp"
+
+namespace uciadapter {
+
+Info::Info()
+    : depth(-1), seldepth(-1), multipv(-1), score_cp(-1), score_mate(-1),
+      score_lowerbound(-1), score_upperbound(-1), cp(-1), nodes(-1), nps(-1),
+      tbhits(-1), time(-1), hashfull(-1), cpuload(-1), currmovenumber(-1)
+
+{}
+
+Go::Go()
+    : wtime(-1), btime(-1), winc(-1), binc(-1), movestogo(-1), depth(-1),
+      nodes(-1), mate(-1), movetime(-1), infinite(false) {}
+
+UCI::UCI(std::string engine_path) {
+  INIT_PROCESS(p);
+  p->Start(engine_path);
+  // Init UCI
+  p->Write("uci\n");
+  uciok = false;
+  registration_required = false;
+  copyprotection_failed = false;
+  registered = false;
+  Sync();
+  if (!uciok) {
+    throw EngineError("failed to start engine in uci mode");
+  }
+  Sync(); // Check copy protection
+  if (copyprotection_failed) {
+    throw EngineError("Copy protection check failed");
+  }
+}
+
+UCI::~UCI() {
+  p->Kill();
+  delete p;
+}
+
+void UCI::Sync() {
+  p->Write("isready\n");
+  bool readyok = false;
+  std::string token;
+  while (!readyok) {
+    std::istringstream iss(p->ReadLine());
+    buffer += iss.str();
+    while (iss >> token) {
+      if (token == "readyok") {
+        readyok = true;
+      } else if (token == "uciok") {
+        uciok = true;
+      } else if (token == "id") {
+        ParseId(iss.str());
+      } else if (token == "option") {
+        ParseOption(iss.str());
+      } else if (token == "copyprotection") {
+        iss >> token;
+        if (token == "error") {
+          copyprotection_failed = true;
+        } else if (token == "ok") {
+          registered = true;
+        }
+      } else if (token == "registration") {
+        if (iss.str() == "registration error\n")
+          registration_required = true;
+      } else if (token == "bestmove") {
+        iss >> token;
+        bestmove = token;
+        iss >> token;
+        if (token == "ponder") {
+          iss >> token;
+          ponder = token;
+        }
+      } else if (token == "info") {
+        ParseInfo(iss.str());
+      }
+    }
+  }
+}
+
+void UCI::Command(std::string cmd) {
+  p->Write(cmd + "\n");
+  Sync();
+}
+
+bool UCI::IsRegistered() { return (registered); }
+
+void UCI::SyncAfter(int ms) {
+  if (ms <= 0) {
+    Sync();
+  } else {
+    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+    Sync();
+  }
+}
+
+void UCI::ParseInfo(std::string line) {
+  Info info;
+  std::istringstream iss(line);
+  std::string token;
+  while (iss >> token) {
+    if (token == "depth") {
+      iss >> info.depth;
+    } else if (token == "string") {
+      std::string line;
+      while (iss >> token) {
+        line += token + " ";
+      }
+      line = line.substr(0, line.size() - 1); // Remove trailing space
+      infostrings.push_back(line);
+      return;
+    } else if (token == "seldepth") {
+      iss >> info.seldepth;
+    } else if (token == "refutation") {
+      while (iss >> token) {
+        refutations.push_back(token);
+      }
+      return;
+    } else if (token == "nps") {
+      iss >> info.nps;
+    } else if (token == "multipv") {
+      iss >> info.multipv;
+    } else if (token == "nodes") {
+      iss >> info.nodes;
+    } else if (token == "time") {
+      iss >> info.time;
+    } else if (token == "tbhits") {
+      iss >> info.tbhits;
+    } else if (token == "hashfull") {
+      iss >> info.hashfull;
+    } else if (token == "cpuload") {
+      iss >> info.cpuload;
+    } else if (token == "currmove") {
+      iss >> info.currmove;
+    } else if (token == "currmovenumber") {
+      iss >> info.currmovenumber;
+    } else if (token == "score") {
+      iss >> token;
+      if (token == "cp") {
+        iss >> info.score_cp;
+      } else if (token == "mate") {
+        iss >> info.score_mate;
+      } else if (token == "lowerbound") {
+        iss >> info.score_lowerbound;
+      } else if (token == "upperbound") {
+        iss >> info.score_upperbound;
+      }
+    } else if (token == "pv") {
+      while (iss >> token) {
+        info.pv.push_back(token);
+      }
+    }
+  }
+
+  // Save line
+  if (info.pv.size() > 0) {
+    lines[info.multipv] = info;
+  }
+}
+
+std::vector<std::string> UCI::GetInfoStrings() { return (infostrings); }
+void UCI::ParseOption(std::string line) {
+  std::istringstream iss(line);
+  std::string token;
+  Option opt;
+  iss >> token; // option token
+  std::string *entry = NULL;
+  while (iss) {
+    if (token == "name") {
+      entry = &opt.name;
+    } else if (token == "type") {
+      entry = &opt.type;
+    } else if (token == "default") {
+      entry = &opt.default_value;
+    } else if (token == "min") {
+      entry = &opt.min;
+    } else if (token == "max") {
+      entry = &opt.max;
+    } else if (token == "var") {
+      entry = &opt.var;
+    } else {
+      iss >> token;
+    }
+    if (entry != NULL) {
+      iss >> token;
+      while (!IS_OPT_PARAM(token) && iss) {
+        (*entry) += token + " ";
+        iss >> token;
+      }
+      *entry = entry->substr(0, entry->size() - 1); // Remove trailing space
+      entry = NULL;
+    }
+  }
+  options.push_back(opt);
+}
+
+void UCI::ParseId(std::string line) {
+  std::istringstream iss(line);
+  std::string token;
+  iss >> token; // id
+  iss >> token; // name or author
+  if (token == "name") {
+    while (iss >> token) {
+      name += token + " ";
+    }
+    name = name.substr(0, name.size() - 1);
+  } else {
+    while (iss >> token) {
+      author += token + " ";
+    }
+    author = author.substr(0, author.size() - 1);
+  }
+}
+
+std::unordered_map<int, Info> UCI::GetLines() { return (lines); }
+std::vector<Option> UCI::GetOptions() { return (options); }
+std::string UCI::GetName() { return (name); }
+std::string UCI::GetAuthor() { return (author); }
+std::string UCI::GetBuffer() { return (buffer); }
+std::string UCI::GetBestMove() { return (bestmove); }
+
+bool UCI::IsRegistrationRequired() { return (registration_required); }
+
+void UCI::register_now(std::string name, std::string code) {
+  Command("register name " + name + " code " + code);
+}
+void UCI::register_later() { Command("register later"); }
+void UCI::stop() { Command("stop"); }
+void UCI::setoption(std::string name, std::string value) {
+  Command("setoption name " + name + " value " + value);
+}
+void UCI::debug(bool d) {
+  if (d) {
+    Command("debug on");
+  } else {
+    Command("debug off");
+  }
+}
+void UCI::ponderhit() { Command("ponderhit"); }
+void UCI::quit() { Command("quit"); }
+void UCI::ucinewgame() { Command("ucinewgame"); }
+void UCI::position(std::string fen, std::string moves) {
+  position(fen + " moves " + moves);
+}
+void UCI::position(std::string fen) { Command("position fen " + fen); }
+
+void UCI::go(Go go) {
+  // Flush data
+  bestmove = "";
+  ponder = "";
+  infostrings.clear();
+  lines.clear();
+  refutations.clear();
+
+  std::string cmd = "go";
+  if (go.searchmoves.size() > 0)
+    cmd += " searchmoves " + go.searchmoves;
+  if (go.ponder.size() > 0)
+    cmd += " ponder " + go.ponder;
+  if (go.wtime >= 0)
+    cmd += " wtime " + std::to_string(go.wtime);
+  if (go.btime >= 0)
+    cmd += " btime " + std::to_string(go.btime);
+  if (go.winc >= 0)
+    cmd += " winc " + std::to_string(go.winc);
+  if (go.binc >= 0)
+    cmd += " binc " + std::to_string(go.binc);
+  if (go.movestogo >= 0)
+    cmd += " movestogo " + std::to_string(go.movestogo);
+  if (go.depth >= 0)
+    cmd += " depth " + std::to_string(go.depth);
+  if (go.mate >= 0)
+    cmd += " mate " + std::to_string(go.mate);
+  if (go.movetime >= 0)
+    cmd += " movetime " + std::to_string(go.movetime);
+  if (go.infinite) {
+    cmd += " infinite";
+  }
+  Command(cmd);
+}
+} // namespace uciadapter

src/UCI.hpp

@@ -0,0 +1,125 @@
+#ifdef UNIX
+#include "ProcessLinux.hpp"
+#define INIT_PROCESS(p)                                                        \
+  { p = static_cast<Process *>(new ProcessLinux()); }
+#else
+#include "ProcessWindows.hpp"
+#endif
+#include <chrono>
+#include <sstream>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#define IS_OPT_PARAM(str)                                                      \
+  ((str) == "name" || (str) == "type" | (str) == "default" ||                  \
+   (str) == "min" || (str) == "max" || (str) == "var")
+
+namespace uciadapter {
+
+/// @brief Empty string and option if not specified
+typedef struct Option {
+  std::string name;
+  std::string type;
+  std::string default_value;
+  std::string min;
+  std::string max;
+  std::string var;
+} Option;
+
+/// @brief All long are initiated to -1 if not set
+class Info {
+public:
+  long depth;
+  long seldepth;
+  long multipv;
+  long score_cp;
+  long score_mate;
+  long score_lowerbound;
+  long score_upperbound;
+  long cp;
+  long nodes;
+  long nps;
+  long tbhits;
+  long time;
+  long hashfull;
+  long cpuload;
+  long currmovenumber;
+  std::vector<std::string> pv;
+  std::string currmove;
+  Info();
+};
+
+/// @brief Calling go(Go()) will perform a Command("go"). Just leave unused
+/// parameters untouched
+class Go {
+public:
+  std::string searchmoves;
+  std::string ponder;
+  int wtime, btime, winc, binc, movestogo, depth, nodes, mate, movetime;
+  bool infinite;
+  Go();
+};
+
+class UCI {
+  Process *p;
+  /// @brief Reset on each call to go()
+  std::string buffer;
+  /// @brief Reset on each call to go()
+  std::string bestmove, ponder;
+  /// @brief Setup on engine startup
+  std::string name, author;
+  /// @brief Setup on engine startup
+  std::vector<Option> options;
+  /// @brief Setup on engine startup
+  bool uciok;
+  bool registration_required;
+  bool copyprotection_failed;
+  bool registered;
+  void ParseId(std::string);
+  void ParseOption(std::string);
+  void ParseInfo(std::string);
+  /// @brief Reset on each call to go()
+  std::unordered_map<int, Info> lines;
+  /// @brief Reset on each call to go()
+  std::vector<std::string> infostrings;
+  /// @brief Reset on each call to go()
+  std::vector<std::string> refutations;
+  void Sync();
+
+public:
+  UCI(std::string);
+  ~UCI();
+  std::string GetBuffer();
+  std::string GetName();
+  std::string GetAuthor();
+  std::string GetBestMove();
+  std::vector<Option> GetOptions();
+  std::unordered_map<int, Info> GetLines();
+  std::vector<std::string> GetInfoStrings();
+  bool IsRegistrationRequired();
+  bool IsRegistered();
+  void Command(std::string);
+  void SyncAfter(int);
+
+  // UCI API (all in lower case)
+  void ucinewgame();
+  void stop();
+  void position(std::string, std::string);
+  void setoption(std::string, std::string);
+  void position(std::string);
+  void register_now(std::string, std::string);
+  void register_later();
+  void debug(bool);
+  void ponderhit();
+  void quit();
+  void go(Go);
+};
+
+struct EngineError : public std::exception {
+  std::string msg;
+  EngineError(std::string reason) { msg = "Engine error: " + reason; }
+  const char *what() const throw() { return msg.c_str(); }
+};
+
+} // namespace uciadapter

tests/CMakeLists.txt

@@ -0,0 +1,13 @@
+
+# Configure catch3
+include_directories(./catch3/)
+add_library(catch3 SHARED ./catch3/catch_amalgamated.cpp)
+
+# Add tests
+add_executable(stockfish stockfish.cpp)
+target_link_libraries(stockfish uciadapter catch3)
+add_test(Stockfish stockfish)
+
+add_executable(berserk berserk.cpp)
+target_link_libraries(berserk uciadapter catch3)
+add_test(Berserk berserk)

tests/berserk.cpp

@@ -0,0 +1,86 @@
+#include "UCI.hpp"
+#include <catch_amalgamated.hpp>
+
+#define LATENCY 4000
+
+using namespace uciadapter;
+
+TEST_CASE("Berserk Initialisation", "[berserk/init]") {
+  REQUIRE_NOTHROW([&]() { UCI("./berserk_engine"); }());
+
+  UCI u("./berserk_engine");
+  REQUIRE(u.GetName() == "Berserk 8.5.1 NN (6fb1a076a856)");
+  REQUIRE(u.GetAuthor() == "Jay Honnold");
+
+  std::vector<Option> opts = u.GetOptions();
+  REQUIRE(opts.size() == 9);
+
+  char i = 0;
+  for (Option &opt : opts) {
+    if (opt.name == "Hash") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "32");
+      CHECK(opt.min == "4");
+      CHECK(opt.max == "65536");
+    } else if (opt.name == "Threads") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "1");
+      CHECK(opt.min == "1");
+      CHECK(opt.max == "256");
+    } else if (opt.name == "NoobBookLimit") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "8");
+      CHECK(opt.min == "0");
+      CHECK(opt.max == "32");
+    } else if (opt.name == "NoobBook") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "false");
+    } else if (opt.name == "SyzygyPath") {
+      i++;
+      CHECK(opt.type == "string");
+      CHECK(opt.default_value == "<empty>");
+    } else if (opt.name == "MultiPV") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "1");
+      CHECK(opt.min == "1");
+      CHECK(opt.max == "256");
+    } else if (opt.name == "Ponder") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "false");
+    } else if (opt.name == "UCI_Chess960") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "false");
+    } else if (opt.name == "MoveOverhead") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "300");
+      CHECK(opt.min == "100");
+      CHECK(opt.max == "10000");
+    }
+  }
+  REQUIRE(i == 9);
+}
+
+TEST_CASE("Berserk MultiPV", "[berserk/MultiPV]") {
+  UCI u("./berserk_engine");
+  u.setoption("MultiPV", "5");
+  u.SyncAfter(LATENCY); // Wait 2s should be enough
+  CHECK(u.GetLines().size() == 0);
+}
+
+TEST_CASE("Berserk Position", "[berserk/Position]") {
+  UCI u("./berserk_engine");
+  u.position("2k2r2/6R1/8/8/8/6Q1/4K3/8 w - - 0 1");
+  u.go(Go());
+  u.SyncAfter(LATENCY); // Wait 2s should be enough
+  REQUIRE(u.GetLines().size() == 1);
+  CHECK(u.GetLines()[1].pv[0] == "g3c7");
+  CHECK(u.GetBestMove() == "g3c7");
+}

tests/berserk.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/bash
+
+wai=$(dirname $(readlink -f "$0")) # Current script directory
+cd ${wai}/../build/tests/
+wget -O  berserk_src.tar.gz https://github.com/jhonnold/berserk/archive/refs/tags/8.5.1.tar.gz
+mkdir -p berserk_src && tar -xf berserk_src.tar.gz -C berserk_src --strip-components 1
+cd berserk_src/src && make && mv berserk ./../../berserk_engine
+

tests/stockfish.cpp

@@ -0,0 +1,145 @@
+#include "UCI.hpp"
+#include <catch_amalgamated.hpp>
+
+#define LATENCY 2000
+
+using namespace uciadapter;
+
+TEST_CASE("Stockfish Initialisation", "[stockfish/init]") {
+  // Using bad engine path shoud raise an exception
+  REQUIRE_THROWS([&]() { UCI("./random_path_zlkdejdlk"); }());
+  REQUIRE_NOTHROW([&]() { UCI("./stockfish_engine"); }());
+
+  UCI u("./stockfish_engine");
+  REQUIRE(u.GetName() == "Stockfish 14.1");
+  REQUIRE(u.GetAuthor() == "the Stockfish developers (see AUTHORS file)");
+
+  std::vector<Option> opts = u.GetOptions();
+  REQUIRE(opts.size() == 21);
+
+  char i = 0;
+  for (Option &opt : opts) {
+    if (opt.name == "Debug Log File") {
+      i++;
+      CHECK(opt.type == "string");
+      CHECK(opt.default_value.size() == 0);
+    } else if (opt.name == "Threads") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "1");
+      CHECK(opt.min == "1");
+      CHECK(opt.max == "512");
+    } else if (opt.name == "Hash") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "16");
+      CHECK(opt.min == "1");
+      CHECK(opt.max == "33554432");
+    } else if (opt.name == "Clear Hash") {
+      i++;
+      CHECK(opt.type == "button");
+    } else if (opt.name == "Ponder") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "false");
+    } else if (opt.name == "MultiPV") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "1");
+      CHECK(opt.min == "1");
+      CHECK(opt.max == "500");
+    } else if (opt.name == "Skill Level") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "20");
+      CHECK(opt.min == "0");
+      CHECK(opt.max == "20");
+    } else if (opt.name == "Move Overhead") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "10");
+      CHECK(opt.min == "0");
+      CHECK(opt.max == "5000");
+    } else if (opt.name == "Slow Mover") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "100");
+      CHECK(opt.min == "10");
+      CHECK(opt.max == "1000");
+    } else if (opt.name == "nodestime") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "0");
+      CHECK(opt.min == "0");
+      CHECK(opt.max == "10000");
+    } else if (opt.name == "UCI_Chess960") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "false");
+    } else if (opt.name == "UCI_AnalyseMode") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "false");
+    } else if (opt.name == "UCI_LimitStrength") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "false");
+    } else if (opt.name == "UCI_Elo") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "1350");
+      CHECK(opt.min == "1350");
+      CHECK(opt.max == "2850");
+    } else if (opt.name == "UCI_ShowWDL") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "false");
+    } else if (opt.name == "SyzygyPath") {
+      i++;
+      CHECK(opt.type == "string");
+      CHECK(opt.default_value == "<empty>");
+    } else if (opt.name == "SyzygyProbeDepth") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "1");
+      CHECK(opt.min == "1");
+      CHECK(opt.max == "100");
+    } else if (opt.name == "Syzygy50MoveRule") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "true");
+    } else if (opt.name == "SyzygyProbeLimit") {
+      i++;
+      CHECK(opt.type == "spin");
+      CHECK(opt.default_value == "7");
+      CHECK(opt.min == "0");
+      CHECK(opt.max == "7");
+    } else if (opt.name == "Use NNUE") {
+      i++;
+      CHECK(opt.type == "check");
+      CHECK(opt.default_value == "true");
+    } else if (opt.name == "EvalFile") {
+      i++;
+      CHECK(opt.type == "string");
+      CHECK(opt.default_value == "nn-13406b1dcbe0.nnue");
+    }
+  }
+  REQUIRE(i == 21);
+}
+
+TEST_CASE("Stockfish MultiPV", "[stockfish/MultiPV]") {
+  UCI u("./stockfish_engine");
+  u.setoption("MultiPV", "5");
+  u.SyncAfter(LATENCY); // Wait 2s should be enough
+  CHECK(u.GetLines().size() == 0);
+}
+
+TEST_CASE("Stockfish Position", "[stockfish/Position]") {
+  UCI u("./stockfish_engine");
+  u.position("2k2r2/6R1/8/8/8/6Q1/4K3/8 w - - 0 1");
+  u.go(Go());
+  u.SyncAfter(LATENCY); // Wait 2s should be enough
+  REQUIRE(u.GetLines().size() == 1);
+  CHECK(u.GetLines()[1].pv[0] == "g3c7");
+  CHECK(u.GetBestMove() == "g3c7");
+}

tests/stockfish.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/bash
+
+wai=$(dirname $(readlink -f "$0")) # Current script directory
+cd ${wai}/../build/tests/
+wget -O  sf.tar.gz https://github.com/official-stockfish/Stockfish/archive/refs/tags/sf_14.1.tar.gz
+mkdir -p sf_src && tar -xf sf.tar.gz -C sf_src --strip-components 1
+cd sf_src/src && make build ARCH=x86-64-modern && mv stockfish ./../../stockfish_engine