int runOpeningLoadTest(){
initZobrist();
OpeningBook* book = OpeningBook_load(OPENING_TEST_BINARY);
OpeningBook_delete(book);
closeZobrist();
return 0;
}
int runOpeningLookupTest(){
initZobrist();
char pgnRecord[] = "1. f4 d5 2. Nf3 *";
PGNRecord* pgn = PGNRecord_newFromString(pgnRecord);
if(pgn==NULL){
printf("PGN Error in lookup test\n");
return 1;
}
MoveIterator* iterator = PGNRecord_getMoveIterator(pgn);
ChessBoard* board = ChessBoard_new(FEN_START);
while(MoveIterator_hasNext(iterator))
ChessBoard_makeMove(board, MoveIterator_getNext(iterator));
MoveIterator_delete(iterator);
int minGames = 2;
OpeningBook* book = OpeningBook_load(OPENING_TEST_BINARY);
assert(OpeningBook_hasLine(book, board, minGames));
move_t move = OpeningBook_randNextMove(book, board, minGames);
char out[10];
int outLen;
toAlgebraicNotation(move, board, out, &outLen);
OpeningBook_delete(book);
PGNRecord_delete(pgn);
ChessBoard_delete(board);
closeZobrist();
return 0;
}
int runPGNTest3(){
initZobrist();
char fileName[] = "data/master_games.pgn";
FILE* fp = fopen(fileName, "r");
int eofFlag = 0;
PGNRecord* pgn = PGNRecord_newFromFile(fp, &eofFlag);
int i;
for(i = 0; !eofFlag && i < 10; i++){
printf("%d\n", i);
PGNRecord_delete(pgn);
pgn = PGNRecord_newFromFile(fp, &eofFlag);
}
if(pgn==NULL){
printf("Error.\n");
return 1;
}
char* out = PGNRecord_toString(pgn);
printf("%s\n", out);
free(out);
MoveIterator* iterator = PGNRecord_getMoveIterator(pgn);
ChessBoard* board = ChessBoard_new(FEN_START);
while(MoveIterator_hasNext(iterator))
ChessBoard_makeMove(board, MoveIterator_getNext(iterator));
MoveIterator_delete(iterator);
ChessBoard_print(board);
PGNRecord_delete(pgn);
ChessBoard_delete(board);
closeZobrist();
fclose(fp);
return 0;
}
int runGenTest(char* start){
initZobrist();
ChessBoard* board = ChessBoard_new(start);
ChessMoveGenerator* gen = ChessMoveGenerator_new(board);
ChessMoveGenerator_generateMoves(gen, ChessBoard_testForCheck(board), NULL);
ChessBoard_print(board);
printf("###############\n");
char moveOut[10];
int moveOutSize;
int i;
for(i = 0; i < gen->nextCount; i++){
toAlgebraicNotation(gen->next[i], board, moveOut, &moveOutSize);
printf("%s\n", moveOut);
printf("%016llX\n", (long long unsigned int)board->hash);
ChessBoard_makeMove(board, gen->next[i]);
ChessBoard_print(board);
printf("\n");
ChessBoard_unmakeMove(board);
}
ChessBoard_delete(board);
ChessMoveGenerator_delete(gen);
closeZobrist();
return 0;
}
int runSearchTest(char* start, int depth){
initZobrist();
ChessBoard* board = ChessBoard_new(start);
TTable* table = TTable_new();
SearchThread* thread = SearchThread_new(board, table);
ChessBoard_print(board);
SearchThread_setTimeout(thread, 5);
SearchThread_start(thread);
SearchThread_join(thread);
move_t line[MAX_LINE_LENGTH];
int length;
int eval = SearchThread_getBestLine(thread, line, &length);
printf("Eval: %d\n", eval);
printf("Length: %d\n", length);
int i;
char moveOut[10];
int moveOutSize;
for(i = 0; i < length; i++){
toAlgebraicNotation(line[i], board, moveOut, &moveOutSize);
printf("%s\n", moveOut);
ChessBoard_makeMove(board, line[i]);
ChessBoard_print(board);
printf("%016llX\n", (long long unsigned int)board->hash);
}
SearchThread_delete(thread);
TTable_delete(table);
ChessBoard_delete(board);
closeZobrist();
return 0;
}
int runPerftTests(){
initZobrist();
int i;
int error = 0;
for(i = 0; i < 6; i++){
if(runPerftTest(PERFT_STARTS[i], PERFT3_VALUES[i])){
error = 1;
printf("Perft error for starting possition %d\n", i+1);
}
}
closeZobrist();
return error;
}
/* create the skip context tree */
SkipCTS::SkipCTS(history_t &history, int depth, int max_skips, size_t log2_slots) :
m_history(history),
m_depth(depth),
m_skips(max_skips),
m_log_skip_preds(MaxDepth),
m_nodes(new SkipNode[size_t(1) << log2_slots]),
m_mask((size_t(1) << log2_slots)-1)
{
initZobrist();
initContexts();
initAuxInfo();
initHashDeltas();
initLogTbl();
}
int runAlgebraicNotationTest(){
initZobrist();
ChessBoard* board = ChessBoard_new(FEN_START);
move_t move;
move = fromAlgebraicNotation("e4", board);
ChessBoard_makeMove(board, move);
move = fromAlgebraicNotation("d5", board);
ChessBoard_makeMove(board, move);
ChessBoard_print(board);
ChessBoard_delete(board);
closeZobrist();
return 0;
}
int runPGNTest2(){
initZobrist();
char pgnTest[] = "[tag] \n1. f3{comment}e5 2. g4 Qh4# 0-1";
PGNRecord* pgn = PGNRecord_newFromString(pgnTest);
if(pgn==NULL){
printf("Error.\n");
return 1;
}
char* out = PGNRecord_toString(pgn);
printf("%s\n", out);
free(out);
MoveIterator* iterator = PGNRecord_getMoveIterator(pgn);
ChessBoard* board = ChessBoard_new(FEN_START);
while(MoveIterator_hasNext(iterator))
ChessBoard_makeMove(board, MoveIterator_getNext(iterator));
MoveIterator_delete(iterator);
ChessBoard_print(board);
PGNRecord_delete(pgn);
ChessBoard_delete(board);
closeZobrist();
return 0;
}
int runPGNTest(){
initZobrist();
ChessBoard* board = ChessBoard_new(FEN_START);
ChessBoard_makeMove(board, fromAlgebraicNotation("f3", board));
ChessBoard_makeMove(board, fromAlgebraicNotation("e5", board));
ChessBoard_makeMove(board, fromAlgebraicNotation("g4", board));
ChessBoard_makeMove(board, fromAlgebraicNotation("Qh4#", board));
ChessBoard_print(board);
PGNRecord* pgn = PGNRecord_newFromBoard(board, 1);
char* out = PGNRecord_toString(pgn);
printf("%s", out);
free(out);
FILE* fp = fopen("data/test_out.pgn", "w");
PGNRecord_writeToFile(pgn, fp);
PGNRecord_writeToFile(pgn, fp);
fclose(fp);
PGNRecord_delete(pgn);
ChessBoard_delete(board);
closeZobrist();
return 0;
}
int runHeuristicsTests(){
initZobrist();
ChessBoard* board = ChessBoard_new(POS_2);
ChessHEngine* engine = ChessHEngine_new(board);
ChessBoard_print(board);
ChessHNode* root = ChessHNode_new(NULL, engine);
ChessHNode_expand(root, engine);
ChessBoard_makeMove(board, root->children[47]->move);
printf("\n");
ChessBoard_print(board);
ChessHNode_expand(root->children[47], engine);
int i;
int minEval = 10000, minI;
ChessHNode* child;
for(i = 0; i < root->children[47]->childrenCount; i++){
child = root->children[47]->children[i];
if(child->evaluation < minEval){
minEval = child->evaluation;
minI = i;
}
}
ChessBoard_makeMove(board, root->children[47]->children[minI]->move);
printf("\n");
ChessBoard_print(board);
ChessHNode_delete(root);
ChessHEngine_delete(engine);
ChessBoard_delete(board);
closeZobrist();
return 0;
}
// Should delete compatibility for performance.
MSAZobrist(D &d, int abst = 1) :
d(d), structure(abst) {
initZobrist(structure);
// dump_table();
}
int runOpeningGenTest(){
initZobrist();
OpeningBook_generate(OPENING_TEST_SOURCE, OPENING_TEST_BINARY, 10);
closeZobrist();
return 0;
}