test: Add and update UCI engine output tests

- Update `TestInit` in `uci/engine_test.go` to use `out` instead of `in` for expected output source
- Add `TestPrint` test to validate output generation of a custom message ("Hello, World!")
- Add `TestCopyProtection` test to ensure `CopyProtection` method outputs "copyprotection ok"

[uci/engine_test.go]
- Replaced `in` with `out` in the `TestInit` function to align with the expected output source.
- Added a new `TestPrint` function to test output generation for a custom message ("Hello, World!").
- Added a new `TestCopyProtection` function to verify the output of the `CopyProtection` method, ensuring it produces "copyprotection ok".

.gitignore

@@ -1 +1,2 @@
 chess
+.vscode

board/move.go

@@ -163,6 +163,24 @@ func (board Game) CreateMoveAlgebra(algebra string) Move {
 	return board.createMoveFromTarget(piece, algebra[1:])
 }
 
+func (board Game) CreateMoveUCI(uci string) Move {
+	from := CreateCoordAlgebra(uci[:2])
+	to := CreateCoordAlgebra(uci[2:])
+
+	move := board.CreateMove(from, to)
+
+	if len(uci) == 5 {
+		piece, err := GetPiece(rune(uci[4]))
+		if err != nil {
+			panic(err)
+		}
+
+		move.promotionTo = piece
+	}
+
+	return move
+}
+
 func (board Game) createMoveFromTarget(piece Piece, algebra string) Move {
 	if len(algebra) == 3 {
 		target := CreateCoordAlgebra(algebra[1:])

main.go

@@ -1,46 +1,23 @@
 package main
 
 import (
-	"fmt"
+	"bufio"
 	"os"
-	"strconv"
-	"strings"
 
-	"github.com/msws/chess/board"
+	"github.com/msws/chess/uci"
 )
 
 func main() {
-	board, err := board.FromFEN("r3k2r/p1pPqpb1/1n3np1/1b2N3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R b KQkq - 0 2")
-	if err != nil {
-		panic(err)
-	}
+	reader := bufio.NewReader(os.Stdin)
+	engine := uci.NewEngine(reader, os.Stdout)
 
-	baseMoves := board.GetMoves()
+	for {
+		cmd, err := reader.ReadString('\n')
 
-	depth := 1
-	total := 0
-
-	println(strings.Join(os.Args, ","))
-
-	if len(os.Args) == 2 {
-		val, err := strconv.Atoi(os.Args[1])
 		if err != nil {
 			panic(err)
 		}
-		depth = val
+
+		go engine.Print(cmd)
 	}
-
-	// fmt.Printf("Depth: %d\n", depth)
-
-	for _, move := range baseMoves {
-		board.MakeMove(move)
-
-		perft := board.Perft(depth - 1)
-		total += perft
-		fmt.Printf("%v%v: %d\n", move.From.GetAlgebra(), move.To.GetAlgebra(), perft)
-
-		board.UndoMove()
-	}
-
-	fmt.Printf("Depth: %d, (%d)", depth, total)
 }

main_test.go

@@ -0,0 +1 @@
+package main

uci/engine.go

@@ -0,0 +1,67 @@
+package uci
+
+import (
+	"io"
+
+	"github.com/msws/chess/board"
+)
+
+type Engine interface {
+	Debug(bool bool)
+	Init()
+	CopyProtection()
+	SetOption(name string, id string, value string)
+	Print(message string)
+	Position(fen string, moves []string)
+}
+
+type MyEngine struct {
+	in    io.Reader
+	out   io.Writer
+	game  *board.Game
+	debug bool
+}
+
+// CopyProtection implements Engine.
+func (e *MyEngine) CopyProtection() {
+	e.Println("copyprotection ok")
+}
+
+func (e *MyEngine) Init() {
+	e.Println("id name GoChess2")
+	e.Println("id author MS")
+	e.Println("uciok")
+}
+
+func NewEngine(in io.Reader, out io.Writer) Engine {
+	return &MyEngine{
+		in:  in,
+		out: out,
+	}
+}
+
+func (e *MyEngine) Print(message string) {
+	e.out.Write([]byte(message))
+}
+
+func (e *MyEngine) Println(message string) {
+	e.Print(message + "\n")
+}
+
+func (e *MyEngine) Debug(bool bool) {
+	e.debug = bool
+}
+
+func (e *MyEngine) SetOption(name string, id string, value string) {
+}
+
+func (e *MyEngine) Position(fen string, moves []string) {
+	game, err := board.FromFEN(fen)
+	if err != nil {
+		if e.debug {
+			e.Print(err.Error())
+		}
+		return
+	}
+	e.game = game
+}

uci/engine_test.go

@@ -0,0 +1,61 @@
+package uci
+
+import (
+	"io"
+	"strings"
+	"testing"
+)
+
+func base() (Engine, io.Reader, io.Writer) {
+	in, out := io.Pipe()
+	e := NewEngine(in, out)
+
+	return e, in, out
+}
+
+func TestInit(t *testing.T) {
+	e, out, _ := base()
+
+	go e.Init()
+
+	expectLine(t, out, "id name GoChess2")
+	expectLine(t, out, "id author MS")
+	expectLine(t, out, "uciok")
+}
+
+func TestPrint(t *testing.T) {
+	e, out, _ := base()
+
+	go e.Print("Hello, World!")
+
+	expectLine(t, out, "Hello, World!")
+}
+
+func TestCopyProtection(t *testing.T) {
+	e, out, _ := base()
+
+	go e.CopyProtection()
+
+	expectLine(t, out, "copyprotection ok")
+}
+
+func expectLine(t *testing.T, in io.Reader, expected string) {
+	line, err := readLine(in)
+	if err != nil {
+		t.Fatalf("Error reading line: %v", err)
+	}
+
+	if line != expected {
+		t.Fatalf("Expected '%s', got '%s'", expected, line)
+	}
+}
+
+func readLine(in io.Reader) (string, error) {
+	buf := make([]byte, 1024)
+	n, err := in.Read(buf)
+	if err != nil {
+		return "", err
+	}
+
+	return strings.Trim(string(buf[:n]), "\n"), nil
+}