[iagno] Perfs tests generator.
- From: Arnaud B. <arnaudb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [iagno] Perfs tests generator.
- Date: Fri, 25 Oct 2019 14:45:58 +0000 (UTC)
commit 78fa01f3a08cacebdfb8fa8f7d7d5e0988983442
Author: Arnaud Bonatti <arnaud bonatti gmail com>
Date: Mon Oct 14 15:09:14 2019 +0200
Perfs tests generator.
cd $builddir
ninja update-perfs-tests
cd $gitdir
git diff
// files src/perfs-tests-revers*.vala
// have been edited if AI has changed
cd $builddir
ninja test // usual tests (.desktop file validation…); instantaneous
meson configure -Dperfs_tests=true
ninja test // all tests including generated ones; take ~10s on an i3
meson configure -Dperfs_tests=false
cd $gitdir
src/meson.build | 57 +-
src/perfs-tests-generator.vala | 165 +
src/perfs-tests-iagno.vala | 62 +
src/perfs-tests-reverse.vala | 39251 +++++++++++++++++++++++++++++++++++++++
src/perfs-tests-reversi.vala | 38162 +++++++++++++++++++++++++++++++++++++
src/test-iagno.vala | 349 +-
6 files changed, 77709 insertions(+), 337 deletions(-)
---
diff --git a/src/meson.build b/src/meson.build
index 119cb45..578f4c1 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -1,5 +1,51 @@
-# Tests
-iagno_tests = executable('iagno_tests',
+# Tests generation
+run_target('update-perfs-tests', command: executable ('iagno-perfs-tests-generator',
+ [
+ 'vapi/config.vapi',
+ 'perfs-tests-generator.vala',
+ 'computer-player.vala',
+ 'computer-reversi.vala',
+ 'game.vala',
+ 'player.vala'
+ ],
+ c_args: [
+ '-include', 'config.h'
+ ],
+ vala_args: [
+ '--enable-experimental-non-null'
+ ],
+ dependencies : [
+ gio_dependency
+ ]
+ )
+)
+
+# Generated tests
+if get_option('perfs_tests')
+ iagno_generated_tests = executable('iagno-generated-tests',
+ [
+ 'perfs-tests-iagno.vala',
+ 'perfs-tests-reverse.vala',
+ 'perfs-tests-reversi.vala',
+ 'computer-player.vala',
+ 'computer-reversi.vala',
+ 'game.vala',
+ 'player.vala'
+ ],
+ vala_args: [
+ '--enable-experimental-non-null'
+ ],
+ dependencies : [
+ gio_dependency
+ ]
+ )
+
+ test('iagno-perfs-tests-reversi', iagno_generated_tests, args : ['-m', 'perf', '-p',
'/Reversi/reversi'], timeout : 5)
+ test('iagno-perfs-tests-reverse', iagno_generated_tests, args : ['-m', 'perf', '-p',
'/Reversi/reverse'], timeout : 20)
+endif
+
+# Static tests
+iagno_tests = executable('iagno-tests',
[
'test-iagno.vala',
'computer-player.vala',
@@ -7,15 +53,16 @@ iagno_tests = executable('iagno_tests',
'game.vala',
'player.vala'
],
+ vala_args: [
+ '--enable-experimental-non-null'
+ ],
dependencies : [
gio_dependency
]
)
test('iagno-short-tests', iagno_tests, timeout : 1)
-if get_option('perfs_tests')
- test('iagno-perfs-tests', iagno_tests, args : ['-m', 'perf'], timeout : 120)
-endif
+# Game
executable(meson.project_name(),
[
'vapi/config.vapi',
diff --git a/src/perfs-tests-generator.vala b/src/perfs-tests-generator.vala
new file mode 100644
index 0000000..eceec6a
--- /dev/null
+++ b/src/perfs-tests-generator.vala
@@ -0,0 +1,165 @@
+/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+
+ This file is part of GNOME Reversi, also known as Iagno.
+
+ Copyright 2019 — Arnaud Bonatti
+
+ GNOME Reversi is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ GNOME Reversi is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNOME Reversi. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+private class PerfsTestsGenerator : Application
+{
+ private static int main (string [] args)
+ {
+ Environment.set_application_name ("perfs-tests-generator");
+
+ return new PerfsTestsGenerator ().run (args);
+ }
+
+ private PerfsTestsGenerator ()
+ {
+ Object (application_id: "org.gnome.Reversi.PerfsTestsGenerator", flags: ApplicationFlags.FLAGS_NONE);
+ }
+
+ protected override int handle_local_options (GLib.VariantDict options)
+ {
+ string [] environ = Environ.@get ();
+ string? source_root = Environ.get_variable (environ, "MESON_SOURCE_ROOT");
+ if (source_root == null)
+ assert_not_reached ();
+
+ generate_file ((!) source_root, /* reverse */ false);
+ generate_file ((!) source_root, /* reverse */ true);
+
+ return Posix.EXIT_SUCCESS;
+ }
+
+ private void generate_file (string source_root, bool reverse)
+ {
+ string file_name = reverse ? "perfs-tests-reverse.vala" : "perfs-tests-reversi.vala";
+ FileStream? stream = FileStream.open (Path.build_filename (source_root, "src", file_name), "w");
+ if (stream == null)
+ assert_not_reached ();
+
+ uint16 rounds = reverse ? 512 : 494;
+ string e_or_i = reverse ? "e" : "i";
+
+ ((!) stream).printf ("/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4
-*-\n");
+ ((!) stream).printf ("\n");
+ ((!) stream).printf (" This file is part of GNOME Reversi, also known as Iagno.\n");
+ ((!) stream).printf ("\n");
+ ((!) stream).printf (" Copyright 2019 — Arnaud Bonatti\n");
+ ((!) stream).printf (" File updated by `ninja update-perfs-tests`\n");
+ ((!) stream).printf ("\n");
+ ((!) stream).printf (" GNOME Reversi is free software: you can redistribute it and/or modify\n");
+ ((!) stream).printf (" it under the terms of the GNU General Public License as published by\n");
+ ((!) stream).printf (" the Free Software Foundation, either version 3 of the License, or\n");
+ ((!) stream).printf (" (at your option) any later version.\n");
+ ((!) stream).printf ("\n");
+ ((!) stream).printf (" GNOME Reversi is distributed in the hope that it will be useful,\n");
+ ((!) stream).printf (" but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
+ ((!) stream).printf (" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n");
+ ((!) stream).printf (" GNU General Public License for more details.\n");
+ ((!) stream).printf ("\n");
+ ((!) stream).printf (" You should have received a copy of the GNU General Public License\n");
+ ((!) stream).printf (" along with GNOME Reversi. If not, see <https://www.gnu.org/licenses/>.\n");
+ ((!) stream).printf ("*/\n");
+ ((!) stream).printf ("\n");
+ ((!) stream).printf ("namespace GeneratedTests\n");
+ ((!) stream).printf ("{\n");
+
+ ((!) stream).printf (@" private static void perfs_tests_revers$e_or_i ()\n");
+ ((!) stream).printf ( " {\n");
+ ((!) stream).printf ( " /* crossing start position */\n");
+ for (uint16 i = 0; i <= rounds; i++)
+ {
+ if ((!reverse && i == 232) || (reverse && i == 236))
+ ((!) stream).printf (" /* parallel start position */\n");
+ ((!) stream).printf (@" Test.add_func (\"/Reversi/revers$e_or_i/Complete game $(i +
1)\",\n");
+ ((!) stream).printf (@" test_complete_revers$(e_or_i)_game_$(i +
1));\n");
+ if (i != rounds) ((!) stream).printf ("\n");
+ }
+ ((!) stream).printf (" }\n\n /*\\\n * * perfs tests\n \\*/\n");
+
+ uint8 [] game_init = { 0, 0, 0, 0 };
+ uint8 [] game_init_max = { 0, 0, 0, 0 };
+ for (uint16 i = 0; i <= rounds; i++)
+ {
+ /* ai1 starts */
+ Opening opening = ((!reverse && i < 232) || (reverse && i < 236)) ? Opening.REVERSI :
Opening.ALTER_TOP;
+ Game game = new Game (reverse, opening, /* size */ 8);
+ uint8 depth = reverse ? 2 : 1;
+
+ if ((!reverse && i == 232) || (reverse && i == 236))
+ game_init = { 0, 0, 0, 0 };
+ for (uint8 j = 0; j <= 3; j++)
+ {
+ SList<PossibleMove?> moves;
+ game.get_possible_moves (out moves);
+ game_init_max [j] = (uint8) moves.length ();
+
+ PossibleMove? move = moves.nth_data (game_init [j]);
+ if (move == null)
+ assert_not_reached ();
+ assert_true (game.place_tile (((!) move).x, ((!) move).y));
+ }
+ // for next game
+ for (uint8 j = 3; j >= 0; j--)
+ {
+ game_init [j]++;
+ if (game_init [j] < game_init_max [j])
+ break;
+ game_init [j] = 0;
+ }
+ string [] initial_game = game.to_string ().split ("\n");
+ initial_game = initial_game [1 : initial_game.length - 1];
+ ComputerReversi ai;
+ if (reverse)
+ ai = new ComputerReverseHard (game, depth, /* fixed heuristic */ true);
+ else
+ ai = new ComputerReversiHard (game, depth, /* fixed heuristic */ true);
+
+ ((!) stream).printf (@"\n private static inline void test_complete_revers$(e_or_i)_game_$(i +
1) ()\n");
+ ((!) stream).printf ( " {\n");
+ ((!) stream).printf ( " /* 0 1 2 3 4 5 6 7 */\n");
+ ((!) stream).printf (@" string [] board = {/* 0 */ \"$(initial_game [0])\",\n");
+ for (uint8 n = 1; n < 7; n++)
+ ((!) stream).printf (@" /* $n */ \"$(initial_game [n])\",\n");
+ ((!) stream).printf (@" /* 7 */ \"$(initial_game [7])\"};\n\n");
+
+ ((!) stream).printf (@" Game game = new Game.from_strings (board, Player.DARK, /* reverse
*/ $reverse);\n");
+ ((!) stream).printf (@" ComputerPlayer ai = new ComputerRevers$(e_or_i)Hard (game, /*
depth */ $depth, /* fixed heuristic */ true);\n\n");
+
+ uint8 x;
+ uint8 y;
+ do
+ {
+ if (game.current_player_can_move)
+ {
+ ai.move_sync (out x, out y);
+ ((!) stream).printf (@" assert_true (ai_move (ai, $x, $y));\n");
+ }
+ else if (!game.is_complete)
+ {
+ game.pass ();
+ ((!) stream).printf (@" assert_true (game.pass ());\n");
+ }
+ }
+ while (!game.is_complete);
+
+ ((!) stream).printf (" }\n");
+ }
+ ((!) stream).printf ("}\n");
+ }
+}
diff --git a/src/perfs-tests-iagno.vala b/src/perfs-tests-iagno.vala
new file mode 100644
index 0000000..1c4706c
--- /dev/null
+++ b/src/perfs-tests-iagno.vala
@@ -0,0 +1,62 @@
+/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+
+ This file is part of GNOME Reversi, also known as Iagno.
+
+ Copyright 2019 — Arnaud Bonatti
+
+ GNOME Reversi is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ GNOME Reversi is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNOME Reversi. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+namespace GeneratedTests
+{
+ private static int main (string [] args)
+ {
+ Test.init (ref args);
+
+ Test.add_func ("/Reversi/test tests",
+ test_tests);
+
+ if (Test.perf ())
+ {
+ perfs_tests_reverse ();
+ perfs_tests_reversi ();
+ }
+
+ return Test.run ();
+ }
+
+ private static void test_tests ()
+ {
+ assert_true (1 + 1 == 2);
+ }
+
+ /*\
+ * * utilities
+ \*/
+
+ private static bool ai_move (ComputerPlayer ai, uint8 force_x, uint8 force_y)
+ {
+ uint8 x;
+ uint8 y;
+ ai.move_sync (out x, out y);
+
+ bool success = (x == force_x)
+ && (y == force_y);
+
+ if (!success)
+ print (@"\nwanted: ($force_x, $force_y), result: ($x, $y)");
+
+ return success;
+ }
+}
diff --git a/src/perfs-tests-reverse.vala b/src/perfs-tests-reverse.vala
new file mode 100644
index 0000000..558b512
--- /dev/null
+++ b/src/perfs-tests-reverse.vala
@@ -0,0 +1,39251 @@
+/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+
+ This file is part of GNOME Reversi, also known as Iagno.
+
+ Copyright 2019 — Arnaud Bonatti
+ File updated by `ninja update-perfs-tests`
+
+ GNOME Reversi is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ GNOME Reversi is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNOME Reversi. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+namespace GeneratedTests
+{
+ private static void perfs_tests_reverse ()
+ {
+ /* crossing start position */
+ Test.add_func ("/Reversi/reverse/Complete game 1",
+ test_complete_reverse_game_1);
+
+ Test.add_func ("/Reversi/reverse/Complete game 2",
+ test_complete_reverse_game_2);
+
+ Test.add_func ("/Reversi/reverse/Complete game 3",
+ test_complete_reverse_game_3);
+
+ Test.add_func ("/Reversi/reverse/Complete game 4",
+ test_complete_reverse_game_4);
+
+ Test.add_func ("/Reversi/reverse/Complete game 5",
+ test_complete_reverse_game_5);
+
+ Test.add_func ("/Reversi/reverse/Complete game 6",
+ test_complete_reverse_game_6);
+
+ Test.add_func ("/Reversi/reverse/Complete game 7",
+ test_complete_reverse_game_7);
+
+ Test.add_func ("/Reversi/reverse/Complete game 8",
+ test_complete_reverse_game_8);
+
+ Test.add_func ("/Reversi/reverse/Complete game 9",
+ test_complete_reverse_game_9);
+
+ Test.add_func ("/Reversi/reverse/Complete game 10",
+ test_complete_reverse_game_10);
+
+ Test.add_func ("/Reversi/reverse/Complete game 11",
+ test_complete_reverse_game_11);
+
+ Test.add_func ("/Reversi/reverse/Complete game 12",
+ test_complete_reverse_game_12);
+
+ Test.add_func ("/Reversi/reverse/Complete game 13",
+ test_complete_reverse_game_13);
+
+ Test.add_func ("/Reversi/reverse/Complete game 14",
+ test_complete_reverse_game_14);
+
+ Test.add_func ("/Reversi/reverse/Complete game 15",
+ test_complete_reverse_game_15);
+
+ Test.add_func ("/Reversi/reverse/Complete game 16",
+ test_complete_reverse_game_16);
+
+ Test.add_func ("/Reversi/reverse/Complete game 17",
+ test_complete_reverse_game_17);
+
+ Test.add_func ("/Reversi/reverse/Complete game 18",
+ test_complete_reverse_game_18);
+
+ Test.add_func ("/Reversi/reverse/Complete game 19",
+ test_complete_reverse_game_19);
+
+ Test.add_func ("/Reversi/reverse/Complete game 20",
+ test_complete_reverse_game_20);
+
+ Test.add_func ("/Reversi/reverse/Complete game 21",
+ test_complete_reverse_game_21);
+
+ Test.add_func ("/Reversi/reverse/Complete game 22",
+ test_complete_reverse_game_22);
+
+ Test.add_func ("/Reversi/reverse/Complete game 23",
+ test_complete_reverse_game_23);
+
+ Test.add_func ("/Reversi/reverse/Complete game 24",
+ test_complete_reverse_game_24);
+
+ Test.add_func ("/Reversi/reverse/Complete game 25",
+ test_complete_reverse_game_25);
+
+ Test.add_func ("/Reversi/reverse/Complete game 26",
+ test_complete_reverse_game_26);
+
+ Test.add_func ("/Reversi/reverse/Complete game 27",
+ test_complete_reverse_game_27);
+
+ Test.add_func ("/Reversi/reverse/Complete game 28",
+ test_complete_reverse_game_28);
+
+ Test.add_func ("/Reversi/reverse/Complete game 29",
+ test_complete_reverse_game_29);
+
+ Test.add_func ("/Reversi/reverse/Complete game 30",
+ test_complete_reverse_game_30);
+
+ Test.add_func ("/Reversi/reverse/Complete game 31",
+ test_complete_reverse_game_31);
+
+ Test.add_func ("/Reversi/reverse/Complete game 32",
+ test_complete_reverse_game_32);
+
+ Test.add_func ("/Reversi/reverse/Complete game 33",
+ test_complete_reverse_game_33);
+
+ Test.add_func ("/Reversi/reverse/Complete game 34",
+ test_complete_reverse_game_34);
+
+ Test.add_func ("/Reversi/reverse/Complete game 35",
+ test_complete_reverse_game_35);
+
+ Test.add_func ("/Reversi/reverse/Complete game 36",
+ test_complete_reverse_game_36);
+
+ Test.add_func ("/Reversi/reverse/Complete game 37",
+ test_complete_reverse_game_37);
+
+ Test.add_func ("/Reversi/reverse/Complete game 38",
+ test_complete_reverse_game_38);
+
+ Test.add_func ("/Reversi/reverse/Complete game 39",
+ test_complete_reverse_game_39);
+
+ Test.add_func ("/Reversi/reverse/Complete game 40",
+ test_complete_reverse_game_40);
+
+ Test.add_func ("/Reversi/reverse/Complete game 41",
+ test_complete_reverse_game_41);
+
+ Test.add_func ("/Reversi/reverse/Complete game 42",
+ test_complete_reverse_game_42);
+
+ Test.add_func ("/Reversi/reverse/Complete game 43",
+ test_complete_reverse_game_43);
+
+ Test.add_func ("/Reversi/reverse/Complete game 44",
+ test_complete_reverse_game_44);
+
+ Test.add_func ("/Reversi/reverse/Complete game 45",
+ test_complete_reverse_game_45);
+
+ Test.add_func ("/Reversi/reverse/Complete game 46",
+ test_complete_reverse_game_46);
+
+ Test.add_func ("/Reversi/reverse/Complete game 47",
+ test_complete_reverse_game_47);
+
+ Test.add_func ("/Reversi/reverse/Complete game 48",
+ test_complete_reverse_game_48);
+
+ Test.add_func ("/Reversi/reverse/Complete game 49",
+ test_complete_reverse_game_49);
+
+ Test.add_func ("/Reversi/reverse/Complete game 50",
+ test_complete_reverse_game_50);
+
+ Test.add_func ("/Reversi/reverse/Complete game 51",
+ test_complete_reverse_game_51);
+
+ Test.add_func ("/Reversi/reverse/Complete game 52",
+ test_complete_reverse_game_52);
+
+ Test.add_func ("/Reversi/reverse/Complete game 53",
+ test_complete_reverse_game_53);
+
+ Test.add_func ("/Reversi/reverse/Complete game 54",
+ test_complete_reverse_game_54);
+
+ Test.add_func ("/Reversi/reverse/Complete game 55",
+ test_complete_reverse_game_55);
+
+ Test.add_func ("/Reversi/reverse/Complete game 56",
+ test_complete_reverse_game_56);
+
+ Test.add_func ("/Reversi/reverse/Complete game 57",
+ test_complete_reverse_game_57);
+
+ Test.add_func ("/Reversi/reverse/Complete game 58",
+ test_complete_reverse_game_58);
+
+ Test.add_func ("/Reversi/reverse/Complete game 59",
+ test_complete_reverse_game_59);
+
+ Test.add_func ("/Reversi/reverse/Complete game 60",
+ test_complete_reverse_game_60);
+
+ Test.add_func ("/Reversi/reverse/Complete game 61",
+ test_complete_reverse_game_61);
+
+ Test.add_func ("/Reversi/reverse/Complete game 62",
+ test_complete_reverse_game_62);
+
+ Test.add_func ("/Reversi/reverse/Complete game 63",
+ test_complete_reverse_game_63);
+
+ Test.add_func ("/Reversi/reverse/Complete game 64",
+ test_complete_reverse_game_64);
+
+ Test.add_func ("/Reversi/reverse/Complete game 65",
+ test_complete_reverse_game_65);
+
+ Test.add_func ("/Reversi/reverse/Complete game 66",
+ test_complete_reverse_game_66);
+
+ Test.add_func ("/Reversi/reverse/Complete game 67",
+ test_complete_reverse_game_67);
+
+ Test.add_func ("/Reversi/reverse/Complete game 68",
+ test_complete_reverse_game_68);
+
+ Test.add_func ("/Reversi/reverse/Complete game 69",
+ test_complete_reverse_game_69);
+
+ Test.add_func ("/Reversi/reverse/Complete game 70",
+ test_complete_reverse_game_70);
+
+ Test.add_func ("/Reversi/reverse/Complete game 71",
+ test_complete_reverse_game_71);
+
+ Test.add_func ("/Reversi/reverse/Complete game 72",
+ test_complete_reverse_game_72);
+
+ Test.add_func ("/Reversi/reverse/Complete game 73",
+ test_complete_reverse_game_73);
+
+ Test.add_func ("/Reversi/reverse/Complete game 74",
+ test_complete_reverse_game_74);
+
+ Test.add_func ("/Reversi/reverse/Complete game 75",
+ test_complete_reverse_game_75);
+
+ Test.add_func ("/Reversi/reverse/Complete game 76",
+ test_complete_reverse_game_76);
+
+ Test.add_func ("/Reversi/reverse/Complete game 77",
+ test_complete_reverse_game_77);
+
+ Test.add_func ("/Reversi/reverse/Complete game 78",
+ test_complete_reverse_game_78);
+
+ Test.add_func ("/Reversi/reverse/Complete game 79",
+ test_complete_reverse_game_79);
+
+ Test.add_func ("/Reversi/reverse/Complete game 80",
+ test_complete_reverse_game_80);
+
+ Test.add_func ("/Reversi/reverse/Complete game 81",
+ test_complete_reverse_game_81);
+
+ Test.add_func ("/Reversi/reverse/Complete game 82",
+ test_complete_reverse_game_82);
+
+ Test.add_func ("/Reversi/reverse/Complete game 83",
+ test_complete_reverse_game_83);
+
+ Test.add_func ("/Reversi/reverse/Complete game 84",
+ test_complete_reverse_game_84);
+
+ Test.add_func ("/Reversi/reverse/Complete game 85",
+ test_complete_reverse_game_85);
+
+ Test.add_func ("/Reversi/reverse/Complete game 86",
+ test_complete_reverse_game_86);
+
+ Test.add_func ("/Reversi/reverse/Complete game 87",
+ test_complete_reverse_game_87);
+
+ Test.add_func ("/Reversi/reverse/Complete game 88",
+ test_complete_reverse_game_88);
+
+ Test.add_func ("/Reversi/reverse/Complete game 89",
+ test_complete_reverse_game_89);
+
+ Test.add_func ("/Reversi/reverse/Complete game 90",
+ test_complete_reverse_game_90);
+
+ Test.add_func ("/Reversi/reverse/Complete game 91",
+ test_complete_reverse_game_91);
+
+ Test.add_func ("/Reversi/reverse/Complete game 92",
+ test_complete_reverse_game_92);
+
+ Test.add_func ("/Reversi/reverse/Complete game 93",
+ test_complete_reverse_game_93);
+
+ Test.add_func ("/Reversi/reverse/Complete game 94",
+ test_complete_reverse_game_94);
+
+ Test.add_func ("/Reversi/reverse/Complete game 95",
+ test_complete_reverse_game_95);
+
+ Test.add_func ("/Reversi/reverse/Complete game 96",
+ test_complete_reverse_game_96);
+
+ Test.add_func ("/Reversi/reverse/Complete game 97",
+ test_complete_reverse_game_97);
+
+ Test.add_func ("/Reversi/reverse/Complete game 98",
+ test_complete_reverse_game_98);
+
+ Test.add_func ("/Reversi/reverse/Complete game 99",
+ test_complete_reverse_game_99);
+
+ Test.add_func ("/Reversi/reverse/Complete game 100",
+ test_complete_reverse_game_100);
+
+ Test.add_func ("/Reversi/reverse/Complete game 101",
+ test_complete_reverse_game_101);
+
+ Test.add_func ("/Reversi/reverse/Complete game 102",
+ test_complete_reverse_game_102);
+
+ Test.add_func ("/Reversi/reverse/Complete game 103",
+ test_complete_reverse_game_103);
+
+ Test.add_func ("/Reversi/reverse/Complete game 104",
+ test_complete_reverse_game_104);
+
+ Test.add_func ("/Reversi/reverse/Complete game 105",
+ test_complete_reverse_game_105);
+
+ Test.add_func ("/Reversi/reverse/Complete game 106",
+ test_complete_reverse_game_106);
+
+ Test.add_func ("/Reversi/reverse/Complete game 107",
+ test_complete_reverse_game_107);
+
+ Test.add_func ("/Reversi/reverse/Complete game 108",
+ test_complete_reverse_game_108);
+
+ Test.add_func ("/Reversi/reverse/Complete game 109",
+ test_complete_reverse_game_109);
+
+ Test.add_func ("/Reversi/reverse/Complete game 110",
+ test_complete_reverse_game_110);
+
+ Test.add_func ("/Reversi/reverse/Complete game 111",
+ test_complete_reverse_game_111);
+
+ Test.add_func ("/Reversi/reverse/Complete game 112",
+ test_complete_reverse_game_112);
+
+ Test.add_func ("/Reversi/reverse/Complete game 113",
+ test_complete_reverse_game_113);
+
+ Test.add_func ("/Reversi/reverse/Complete game 114",
+ test_complete_reverse_game_114);
+
+ Test.add_func ("/Reversi/reverse/Complete game 115",
+ test_complete_reverse_game_115);
+
+ Test.add_func ("/Reversi/reverse/Complete game 116",
+ test_complete_reverse_game_116);
+
+ Test.add_func ("/Reversi/reverse/Complete game 117",
+ test_complete_reverse_game_117);
+
+ Test.add_func ("/Reversi/reverse/Complete game 118",
+ test_complete_reverse_game_118);
+
+ Test.add_func ("/Reversi/reverse/Complete game 119",
+ test_complete_reverse_game_119);
+
+ Test.add_func ("/Reversi/reverse/Complete game 120",
+ test_complete_reverse_game_120);
+
+ Test.add_func ("/Reversi/reverse/Complete game 121",
+ test_complete_reverse_game_121);
+
+ Test.add_func ("/Reversi/reverse/Complete game 122",
+ test_complete_reverse_game_122);
+
+ Test.add_func ("/Reversi/reverse/Complete game 123",
+ test_complete_reverse_game_123);
+
+ Test.add_func ("/Reversi/reverse/Complete game 124",
+ test_complete_reverse_game_124);
+
+ Test.add_func ("/Reversi/reverse/Complete game 125",
+ test_complete_reverse_game_125);
+
+ Test.add_func ("/Reversi/reverse/Complete game 126",
+ test_complete_reverse_game_126);
+
+ Test.add_func ("/Reversi/reverse/Complete game 127",
+ test_complete_reverse_game_127);
+
+ Test.add_func ("/Reversi/reverse/Complete game 128",
+ test_complete_reverse_game_128);
+
+ Test.add_func ("/Reversi/reverse/Complete game 129",
+ test_complete_reverse_game_129);
+
+ Test.add_func ("/Reversi/reverse/Complete game 130",
+ test_complete_reverse_game_130);
+
+ Test.add_func ("/Reversi/reverse/Complete game 131",
+ test_complete_reverse_game_131);
+
+ Test.add_func ("/Reversi/reverse/Complete game 132",
+ test_complete_reverse_game_132);
+
+ Test.add_func ("/Reversi/reverse/Complete game 133",
+ test_complete_reverse_game_133);
+
+ Test.add_func ("/Reversi/reverse/Complete game 134",
+ test_complete_reverse_game_134);
+
+ Test.add_func ("/Reversi/reverse/Complete game 135",
+ test_complete_reverse_game_135);
+
+ Test.add_func ("/Reversi/reverse/Complete game 136",
+ test_complete_reverse_game_136);
+
+ Test.add_func ("/Reversi/reverse/Complete game 137",
+ test_complete_reverse_game_137);
+
+ Test.add_func ("/Reversi/reverse/Complete game 138",
+ test_complete_reverse_game_138);
+
+ Test.add_func ("/Reversi/reverse/Complete game 139",
+ test_complete_reverse_game_139);
+
+ Test.add_func ("/Reversi/reverse/Complete game 140",
+ test_complete_reverse_game_140);
+
+ Test.add_func ("/Reversi/reverse/Complete game 141",
+ test_complete_reverse_game_141);
+
+ Test.add_func ("/Reversi/reverse/Complete game 142",
+ test_complete_reverse_game_142);
+
+ Test.add_func ("/Reversi/reverse/Complete game 143",
+ test_complete_reverse_game_143);
+
+ Test.add_func ("/Reversi/reverse/Complete game 144",
+ test_complete_reverse_game_144);
+
+ Test.add_func ("/Reversi/reverse/Complete game 145",
+ test_complete_reverse_game_145);
+
+ Test.add_func ("/Reversi/reverse/Complete game 146",
+ test_complete_reverse_game_146);
+
+ Test.add_func ("/Reversi/reverse/Complete game 147",
+ test_complete_reverse_game_147);
+
+ Test.add_func ("/Reversi/reverse/Complete game 148",
+ test_complete_reverse_game_148);
+
+ Test.add_func ("/Reversi/reverse/Complete game 149",
+ test_complete_reverse_game_149);
+
+ Test.add_func ("/Reversi/reverse/Complete game 150",
+ test_complete_reverse_game_150);
+
+ Test.add_func ("/Reversi/reverse/Complete game 151",
+ test_complete_reverse_game_151);
+
+ Test.add_func ("/Reversi/reverse/Complete game 152",
+ test_complete_reverse_game_152);
+
+ Test.add_func ("/Reversi/reverse/Complete game 153",
+ test_complete_reverse_game_153);
+
+ Test.add_func ("/Reversi/reverse/Complete game 154",
+ test_complete_reverse_game_154);
+
+ Test.add_func ("/Reversi/reverse/Complete game 155",
+ test_complete_reverse_game_155);
+
+ Test.add_func ("/Reversi/reverse/Complete game 156",
+ test_complete_reverse_game_156);
+
+ Test.add_func ("/Reversi/reverse/Complete game 157",
+ test_complete_reverse_game_157);
+
+ Test.add_func ("/Reversi/reverse/Complete game 158",
+ test_complete_reverse_game_158);
+
+ Test.add_func ("/Reversi/reverse/Complete game 159",
+ test_complete_reverse_game_159);
+
+ Test.add_func ("/Reversi/reverse/Complete game 160",
+ test_complete_reverse_game_160);
+
+ Test.add_func ("/Reversi/reverse/Complete game 161",
+ test_complete_reverse_game_161);
+
+ Test.add_func ("/Reversi/reverse/Complete game 162",
+ test_complete_reverse_game_162);
+
+ Test.add_func ("/Reversi/reverse/Complete game 163",
+ test_complete_reverse_game_163);
+
+ Test.add_func ("/Reversi/reverse/Complete game 164",
+ test_complete_reverse_game_164);
+
+ Test.add_func ("/Reversi/reverse/Complete game 165",
+ test_complete_reverse_game_165);
+
+ Test.add_func ("/Reversi/reverse/Complete game 166",
+ test_complete_reverse_game_166);
+
+ Test.add_func ("/Reversi/reverse/Complete game 167",
+ test_complete_reverse_game_167);
+
+ Test.add_func ("/Reversi/reverse/Complete game 168",
+ test_complete_reverse_game_168);
+
+ Test.add_func ("/Reversi/reverse/Complete game 169",
+ test_complete_reverse_game_169);
+
+ Test.add_func ("/Reversi/reverse/Complete game 170",
+ test_complete_reverse_game_170);
+
+ Test.add_func ("/Reversi/reverse/Complete game 171",
+ test_complete_reverse_game_171);
+
+ Test.add_func ("/Reversi/reverse/Complete game 172",
+ test_complete_reverse_game_172);
+
+ Test.add_func ("/Reversi/reverse/Complete game 173",
+ test_complete_reverse_game_173);
+
+ Test.add_func ("/Reversi/reverse/Complete game 174",
+ test_complete_reverse_game_174);
+
+ Test.add_func ("/Reversi/reverse/Complete game 175",
+ test_complete_reverse_game_175);
+
+ Test.add_func ("/Reversi/reverse/Complete game 176",
+ test_complete_reverse_game_176);
+
+ Test.add_func ("/Reversi/reverse/Complete game 177",
+ test_complete_reverse_game_177);
+
+ Test.add_func ("/Reversi/reverse/Complete game 178",
+ test_complete_reverse_game_178);
+
+ Test.add_func ("/Reversi/reverse/Complete game 179",
+ test_complete_reverse_game_179);
+
+ Test.add_func ("/Reversi/reverse/Complete game 180",
+ test_complete_reverse_game_180);
+
+ Test.add_func ("/Reversi/reverse/Complete game 181",
+ test_complete_reverse_game_181);
+
+ Test.add_func ("/Reversi/reverse/Complete game 182",
+ test_complete_reverse_game_182);
+
+ Test.add_func ("/Reversi/reverse/Complete game 183",
+ test_complete_reverse_game_183);
+
+ Test.add_func ("/Reversi/reverse/Complete game 184",
+ test_complete_reverse_game_184);
+
+ Test.add_func ("/Reversi/reverse/Complete game 185",
+ test_complete_reverse_game_185);
+
+ Test.add_func ("/Reversi/reverse/Complete game 186",
+ test_complete_reverse_game_186);
+
+ Test.add_func ("/Reversi/reverse/Complete game 187",
+ test_complete_reverse_game_187);
+
+ Test.add_func ("/Reversi/reverse/Complete game 188",
+ test_complete_reverse_game_188);
+
+ Test.add_func ("/Reversi/reverse/Complete game 189",
+ test_complete_reverse_game_189);
+
+ Test.add_func ("/Reversi/reverse/Complete game 190",
+ test_complete_reverse_game_190);
+
+ Test.add_func ("/Reversi/reverse/Complete game 191",
+ test_complete_reverse_game_191);
+
+ Test.add_func ("/Reversi/reverse/Complete game 192",
+ test_complete_reverse_game_192);
+
+ Test.add_func ("/Reversi/reverse/Complete game 193",
+ test_complete_reverse_game_193);
+
+ Test.add_func ("/Reversi/reverse/Complete game 194",
+ test_complete_reverse_game_194);
+
+ Test.add_func ("/Reversi/reverse/Complete game 195",
+ test_complete_reverse_game_195);
+
+ Test.add_func ("/Reversi/reverse/Complete game 196",
+ test_complete_reverse_game_196);
+
+ Test.add_func ("/Reversi/reverse/Complete game 197",
+ test_complete_reverse_game_197);
+
+ Test.add_func ("/Reversi/reverse/Complete game 198",
+ test_complete_reverse_game_198);
+
+ Test.add_func ("/Reversi/reverse/Complete game 199",
+ test_complete_reverse_game_199);
+
+ Test.add_func ("/Reversi/reverse/Complete game 200",
+ test_complete_reverse_game_200);
+
+ Test.add_func ("/Reversi/reverse/Complete game 201",
+ test_complete_reverse_game_201);
+
+ Test.add_func ("/Reversi/reverse/Complete game 202",
+ test_complete_reverse_game_202);
+
+ Test.add_func ("/Reversi/reverse/Complete game 203",
+ test_complete_reverse_game_203);
+
+ Test.add_func ("/Reversi/reverse/Complete game 204",
+ test_complete_reverse_game_204);
+
+ Test.add_func ("/Reversi/reverse/Complete game 205",
+ test_complete_reverse_game_205);
+
+ Test.add_func ("/Reversi/reverse/Complete game 206",
+ test_complete_reverse_game_206);
+
+ Test.add_func ("/Reversi/reverse/Complete game 207",
+ test_complete_reverse_game_207);
+
+ Test.add_func ("/Reversi/reverse/Complete game 208",
+ test_complete_reverse_game_208);
+
+ Test.add_func ("/Reversi/reverse/Complete game 209",
+ test_complete_reverse_game_209);
+
+ Test.add_func ("/Reversi/reverse/Complete game 210",
+ test_complete_reverse_game_210);
+
+ Test.add_func ("/Reversi/reverse/Complete game 211",
+ test_complete_reverse_game_211);
+
+ Test.add_func ("/Reversi/reverse/Complete game 212",
+ test_complete_reverse_game_212);
+
+ Test.add_func ("/Reversi/reverse/Complete game 213",
+ test_complete_reverse_game_213);
+
+ Test.add_func ("/Reversi/reverse/Complete game 214",
+ test_complete_reverse_game_214);
+
+ Test.add_func ("/Reversi/reverse/Complete game 215",
+ test_complete_reverse_game_215);
+
+ Test.add_func ("/Reversi/reverse/Complete game 216",
+ test_complete_reverse_game_216);
+
+ Test.add_func ("/Reversi/reverse/Complete game 217",
+ test_complete_reverse_game_217);
+
+ Test.add_func ("/Reversi/reverse/Complete game 218",
+ test_complete_reverse_game_218);
+
+ Test.add_func ("/Reversi/reverse/Complete game 219",
+ test_complete_reverse_game_219);
+
+ Test.add_func ("/Reversi/reverse/Complete game 220",
+ test_complete_reverse_game_220);
+
+ Test.add_func ("/Reversi/reverse/Complete game 221",
+ test_complete_reverse_game_221);
+
+ Test.add_func ("/Reversi/reverse/Complete game 222",
+ test_complete_reverse_game_222);
+
+ Test.add_func ("/Reversi/reverse/Complete game 223",
+ test_complete_reverse_game_223);
+
+ Test.add_func ("/Reversi/reverse/Complete game 224",
+ test_complete_reverse_game_224);
+
+ Test.add_func ("/Reversi/reverse/Complete game 225",
+ test_complete_reverse_game_225);
+
+ Test.add_func ("/Reversi/reverse/Complete game 226",
+ test_complete_reverse_game_226);
+
+ Test.add_func ("/Reversi/reverse/Complete game 227",
+ test_complete_reverse_game_227);
+
+ Test.add_func ("/Reversi/reverse/Complete game 228",
+ test_complete_reverse_game_228);
+
+ Test.add_func ("/Reversi/reverse/Complete game 229",
+ test_complete_reverse_game_229);
+
+ Test.add_func ("/Reversi/reverse/Complete game 230",
+ test_complete_reverse_game_230);
+
+ Test.add_func ("/Reversi/reverse/Complete game 231",
+ test_complete_reverse_game_231);
+
+ Test.add_func ("/Reversi/reverse/Complete game 232",
+ test_complete_reverse_game_232);
+
+ Test.add_func ("/Reversi/reverse/Complete game 233",
+ test_complete_reverse_game_233);
+
+ Test.add_func ("/Reversi/reverse/Complete game 234",
+ test_complete_reverse_game_234);
+
+ Test.add_func ("/Reversi/reverse/Complete game 235",
+ test_complete_reverse_game_235);
+
+ Test.add_func ("/Reversi/reverse/Complete game 236",
+ test_complete_reverse_game_236);
+
+ /* parallel start position */
+ Test.add_func ("/Reversi/reverse/Complete game 237",
+ test_complete_reverse_game_237);
+
+ Test.add_func ("/Reversi/reverse/Complete game 238",
+ test_complete_reverse_game_238);
+
+ Test.add_func ("/Reversi/reverse/Complete game 239",
+ test_complete_reverse_game_239);
+
+ Test.add_func ("/Reversi/reverse/Complete game 240",
+ test_complete_reverse_game_240);
+
+ Test.add_func ("/Reversi/reverse/Complete game 241",
+ test_complete_reverse_game_241);
+
+ Test.add_func ("/Reversi/reverse/Complete game 242",
+ test_complete_reverse_game_242);
+
+ Test.add_func ("/Reversi/reverse/Complete game 243",
+ test_complete_reverse_game_243);
+
+ Test.add_func ("/Reversi/reverse/Complete game 244",
+ test_complete_reverse_game_244);
+
+ Test.add_func ("/Reversi/reverse/Complete game 245",
+ test_complete_reverse_game_245);
+
+ Test.add_func ("/Reversi/reverse/Complete game 246",
+ test_complete_reverse_game_246);
+
+ Test.add_func ("/Reversi/reverse/Complete game 247",
+ test_complete_reverse_game_247);
+
+ Test.add_func ("/Reversi/reverse/Complete game 248",
+ test_complete_reverse_game_248);
+
+ Test.add_func ("/Reversi/reverse/Complete game 249",
+ test_complete_reverse_game_249);
+
+ Test.add_func ("/Reversi/reverse/Complete game 250",
+ test_complete_reverse_game_250);
+
+ Test.add_func ("/Reversi/reverse/Complete game 251",
+ test_complete_reverse_game_251);
+
+ Test.add_func ("/Reversi/reverse/Complete game 252",
+ test_complete_reverse_game_252);
+
+ Test.add_func ("/Reversi/reverse/Complete game 253",
+ test_complete_reverse_game_253);
+
+ Test.add_func ("/Reversi/reverse/Complete game 254",
+ test_complete_reverse_game_254);
+
+ Test.add_func ("/Reversi/reverse/Complete game 255",
+ test_complete_reverse_game_255);
+
+ Test.add_func ("/Reversi/reverse/Complete game 256",
+ test_complete_reverse_game_256);
+
+ Test.add_func ("/Reversi/reverse/Complete game 257",
+ test_complete_reverse_game_257);
+
+ Test.add_func ("/Reversi/reverse/Complete game 258",
+ test_complete_reverse_game_258);
+
+ Test.add_func ("/Reversi/reverse/Complete game 259",
+ test_complete_reverse_game_259);
+
+ Test.add_func ("/Reversi/reverse/Complete game 260",
+ test_complete_reverse_game_260);
+
+ Test.add_func ("/Reversi/reverse/Complete game 261",
+ test_complete_reverse_game_261);
+
+ Test.add_func ("/Reversi/reverse/Complete game 262",
+ test_complete_reverse_game_262);
+
+ Test.add_func ("/Reversi/reverse/Complete game 263",
+ test_complete_reverse_game_263);
+
+ Test.add_func ("/Reversi/reverse/Complete game 264",
+ test_complete_reverse_game_264);
+
+ Test.add_func ("/Reversi/reverse/Complete game 265",
+ test_complete_reverse_game_265);
+
+ Test.add_func ("/Reversi/reverse/Complete game 266",
+ test_complete_reverse_game_266);
+
+ Test.add_func ("/Reversi/reverse/Complete game 267",
+ test_complete_reverse_game_267);
+
+ Test.add_func ("/Reversi/reverse/Complete game 268",
+ test_complete_reverse_game_268);
+
+ Test.add_func ("/Reversi/reverse/Complete game 269",
+ test_complete_reverse_game_269);
+
+ Test.add_func ("/Reversi/reverse/Complete game 270",
+ test_complete_reverse_game_270);
+
+ Test.add_func ("/Reversi/reverse/Complete game 271",
+ test_complete_reverse_game_271);
+
+ Test.add_func ("/Reversi/reverse/Complete game 272",
+ test_complete_reverse_game_272);
+
+ Test.add_func ("/Reversi/reverse/Complete game 273",
+ test_complete_reverse_game_273);
+
+ Test.add_func ("/Reversi/reverse/Complete game 274",
+ test_complete_reverse_game_274);
+
+ Test.add_func ("/Reversi/reverse/Complete game 275",
+ test_complete_reverse_game_275);
+
+ Test.add_func ("/Reversi/reverse/Complete game 276",
+ test_complete_reverse_game_276);
+
+ Test.add_func ("/Reversi/reverse/Complete game 277",
+ test_complete_reverse_game_277);
+
+ Test.add_func ("/Reversi/reverse/Complete game 278",
+ test_complete_reverse_game_278);
+
+ Test.add_func ("/Reversi/reverse/Complete game 279",
+ test_complete_reverse_game_279);
+
+ Test.add_func ("/Reversi/reverse/Complete game 280",
+ test_complete_reverse_game_280);
+
+ Test.add_func ("/Reversi/reverse/Complete game 281",
+ test_complete_reverse_game_281);
+
+ Test.add_func ("/Reversi/reverse/Complete game 282",
+ test_complete_reverse_game_282);
+
+ Test.add_func ("/Reversi/reverse/Complete game 283",
+ test_complete_reverse_game_283);
+
+ Test.add_func ("/Reversi/reverse/Complete game 284",
+ test_complete_reverse_game_284);
+
+ Test.add_func ("/Reversi/reverse/Complete game 285",
+ test_complete_reverse_game_285);
+
+ Test.add_func ("/Reversi/reverse/Complete game 286",
+ test_complete_reverse_game_286);
+
+ Test.add_func ("/Reversi/reverse/Complete game 287",
+ test_complete_reverse_game_287);
+
+ Test.add_func ("/Reversi/reverse/Complete game 288",
+ test_complete_reverse_game_288);
+
+ Test.add_func ("/Reversi/reverse/Complete game 289",
+ test_complete_reverse_game_289);
+
+ Test.add_func ("/Reversi/reverse/Complete game 290",
+ test_complete_reverse_game_290);
+
+ Test.add_func ("/Reversi/reverse/Complete game 291",
+ test_complete_reverse_game_291);
+
+ Test.add_func ("/Reversi/reverse/Complete game 292",
+ test_complete_reverse_game_292);
+
+ Test.add_func ("/Reversi/reverse/Complete game 293",
+ test_complete_reverse_game_293);
+
+ Test.add_func ("/Reversi/reverse/Complete game 294",
+ test_complete_reverse_game_294);
+
+ Test.add_func ("/Reversi/reverse/Complete game 295",
+ test_complete_reverse_game_295);
+
+ Test.add_func ("/Reversi/reverse/Complete game 296",
+ test_complete_reverse_game_296);
+
+ Test.add_func ("/Reversi/reverse/Complete game 297",
+ test_complete_reverse_game_297);
+
+ Test.add_func ("/Reversi/reverse/Complete game 298",
+ test_complete_reverse_game_298);
+
+ Test.add_func ("/Reversi/reverse/Complete game 299",
+ test_complete_reverse_game_299);
+
+ Test.add_func ("/Reversi/reverse/Complete game 300",
+ test_complete_reverse_game_300);
+
+ Test.add_func ("/Reversi/reverse/Complete game 301",
+ test_complete_reverse_game_301);
+
+ Test.add_func ("/Reversi/reverse/Complete game 302",
+ test_complete_reverse_game_302);
+
+ Test.add_func ("/Reversi/reverse/Complete game 303",
+ test_complete_reverse_game_303);
+
+ Test.add_func ("/Reversi/reverse/Complete game 304",
+ test_complete_reverse_game_304);
+
+ Test.add_func ("/Reversi/reverse/Complete game 305",
+ test_complete_reverse_game_305);
+
+ Test.add_func ("/Reversi/reverse/Complete game 306",
+ test_complete_reverse_game_306);
+
+ Test.add_func ("/Reversi/reverse/Complete game 307",
+ test_complete_reverse_game_307);
+
+ Test.add_func ("/Reversi/reverse/Complete game 308",
+ test_complete_reverse_game_308);
+
+ Test.add_func ("/Reversi/reverse/Complete game 309",
+ test_complete_reverse_game_309);
+
+ Test.add_func ("/Reversi/reverse/Complete game 310",
+ test_complete_reverse_game_310);
+
+ Test.add_func ("/Reversi/reverse/Complete game 311",
+ test_complete_reverse_game_311);
+
+ Test.add_func ("/Reversi/reverse/Complete game 312",
+ test_complete_reverse_game_312);
+
+ Test.add_func ("/Reversi/reverse/Complete game 313",
+ test_complete_reverse_game_313);
+
+ Test.add_func ("/Reversi/reverse/Complete game 314",
+ test_complete_reverse_game_314);
+
+ Test.add_func ("/Reversi/reverse/Complete game 315",
+ test_complete_reverse_game_315);
+
+ Test.add_func ("/Reversi/reverse/Complete game 316",
+ test_complete_reverse_game_316);
+
+ Test.add_func ("/Reversi/reverse/Complete game 317",
+ test_complete_reverse_game_317);
+
+ Test.add_func ("/Reversi/reverse/Complete game 318",
+ test_complete_reverse_game_318);
+
+ Test.add_func ("/Reversi/reverse/Complete game 319",
+ test_complete_reverse_game_319);
+
+ Test.add_func ("/Reversi/reverse/Complete game 320",
+ test_complete_reverse_game_320);
+
+ Test.add_func ("/Reversi/reverse/Complete game 321",
+ test_complete_reverse_game_321);
+
+ Test.add_func ("/Reversi/reverse/Complete game 322",
+ test_complete_reverse_game_322);
+
+ Test.add_func ("/Reversi/reverse/Complete game 323",
+ test_complete_reverse_game_323);
+
+ Test.add_func ("/Reversi/reverse/Complete game 324",
+ test_complete_reverse_game_324);
+
+ Test.add_func ("/Reversi/reverse/Complete game 325",
+ test_complete_reverse_game_325);
+
+ Test.add_func ("/Reversi/reverse/Complete game 326",
+ test_complete_reverse_game_326);
+
+ Test.add_func ("/Reversi/reverse/Complete game 327",
+ test_complete_reverse_game_327);
+
+ Test.add_func ("/Reversi/reverse/Complete game 328",
+ test_complete_reverse_game_328);
+
+ Test.add_func ("/Reversi/reverse/Complete game 329",
+ test_complete_reverse_game_329);
+
+ Test.add_func ("/Reversi/reverse/Complete game 330",
+ test_complete_reverse_game_330);
+
+ Test.add_func ("/Reversi/reverse/Complete game 331",
+ test_complete_reverse_game_331);
+
+ Test.add_func ("/Reversi/reverse/Complete game 332",
+ test_complete_reverse_game_332);
+
+ Test.add_func ("/Reversi/reverse/Complete game 333",
+ test_complete_reverse_game_333);
+
+ Test.add_func ("/Reversi/reverse/Complete game 334",
+ test_complete_reverse_game_334);
+
+ Test.add_func ("/Reversi/reverse/Complete game 335",
+ test_complete_reverse_game_335);
+
+ Test.add_func ("/Reversi/reverse/Complete game 336",
+ test_complete_reverse_game_336);
+
+ Test.add_func ("/Reversi/reverse/Complete game 337",
+ test_complete_reverse_game_337);
+
+ Test.add_func ("/Reversi/reverse/Complete game 338",
+ test_complete_reverse_game_338);
+
+ Test.add_func ("/Reversi/reverse/Complete game 339",
+ test_complete_reverse_game_339);
+
+ Test.add_func ("/Reversi/reverse/Complete game 340",
+ test_complete_reverse_game_340);
+
+ Test.add_func ("/Reversi/reverse/Complete game 341",
+ test_complete_reverse_game_341);
+
+ Test.add_func ("/Reversi/reverse/Complete game 342",
+ test_complete_reverse_game_342);
+
+ Test.add_func ("/Reversi/reverse/Complete game 343",
+ test_complete_reverse_game_343);
+
+ Test.add_func ("/Reversi/reverse/Complete game 344",
+ test_complete_reverse_game_344);
+
+ Test.add_func ("/Reversi/reverse/Complete game 345",
+ test_complete_reverse_game_345);
+
+ Test.add_func ("/Reversi/reverse/Complete game 346",
+ test_complete_reverse_game_346);
+
+ Test.add_func ("/Reversi/reverse/Complete game 347",
+ test_complete_reverse_game_347);
+
+ Test.add_func ("/Reversi/reverse/Complete game 348",
+ test_complete_reverse_game_348);
+
+ Test.add_func ("/Reversi/reverse/Complete game 349",
+ test_complete_reverse_game_349);
+
+ Test.add_func ("/Reversi/reverse/Complete game 350",
+ test_complete_reverse_game_350);
+
+ Test.add_func ("/Reversi/reverse/Complete game 351",
+ test_complete_reverse_game_351);
+
+ Test.add_func ("/Reversi/reverse/Complete game 352",
+ test_complete_reverse_game_352);
+
+ Test.add_func ("/Reversi/reverse/Complete game 353",
+ test_complete_reverse_game_353);
+
+ Test.add_func ("/Reversi/reverse/Complete game 354",
+ test_complete_reverse_game_354);
+
+ Test.add_func ("/Reversi/reverse/Complete game 355",
+ test_complete_reverse_game_355);
+
+ Test.add_func ("/Reversi/reverse/Complete game 356",
+ test_complete_reverse_game_356);
+
+ Test.add_func ("/Reversi/reverse/Complete game 357",
+ test_complete_reverse_game_357);
+
+ Test.add_func ("/Reversi/reverse/Complete game 358",
+ test_complete_reverse_game_358);
+
+ Test.add_func ("/Reversi/reverse/Complete game 359",
+ test_complete_reverse_game_359);
+
+ Test.add_func ("/Reversi/reverse/Complete game 360",
+ test_complete_reverse_game_360);
+
+ Test.add_func ("/Reversi/reverse/Complete game 361",
+ test_complete_reverse_game_361);
+
+ Test.add_func ("/Reversi/reverse/Complete game 362",
+ test_complete_reverse_game_362);
+
+ Test.add_func ("/Reversi/reverse/Complete game 363",
+ test_complete_reverse_game_363);
+
+ Test.add_func ("/Reversi/reverse/Complete game 364",
+ test_complete_reverse_game_364);
+
+ Test.add_func ("/Reversi/reverse/Complete game 365",
+ test_complete_reverse_game_365);
+
+ Test.add_func ("/Reversi/reverse/Complete game 366",
+ test_complete_reverse_game_366);
+
+ Test.add_func ("/Reversi/reverse/Complete game 367",
+ test_complete_reverse_game_367);
+
+ Test.add_func ("/Reversi/reverse/Complete game 368",
+ test_complete_reverse_game_368);
+
+ Test.add_func ("/Reversi/reverse/Complete game 369",
+ test_complete_reverse_game_369);
+
+ Test.add_func ("/Reversi/reverse/Complete game 370",
+ test_complete_reverse_game_370);
+
+ Test.add_func ("/Reversi/reverse/Complete game 371",
+ test_complete_reverse_game_371);
+
+ Test.add_func ("/Reversi/reverse/Complete game 372",
+ test_complete_reverse_game_372);
+
+ Test.add_func ("/Reversi/reverse/Complete game 373",
+ test_complete_reverse_game_373);
+
+ Test.add_func ("/Reversi/reverse/Complete game 374",
+ test_complete_reverse_game_374);
+
+ Test.add_func ("/Reversi/reverse/Complete game 375",
+ test_complete_reverse_game_375);
+
+ Test.add_func ("/Reversi/reverse/Complete game 376",
+ test_complete_reverse_game_376);
+
+ Test.add_func ("/Reversi/reverse/Complete game 377",
+ test_complete_reverse_game_377);
+
+ Test.add_func ("/Reversi/reverse/Complete game 378",
+ test_complete_reverse_game_378);
+
+ Test.add_func ("/Reversi/reverse/Complete game 379",
+ test_complete_reverse_game_379);
+
+ Test.add_func ("/Reversi/reverse/Complete game 380",
+ test_complete_reverse_game_380);
+
+ Test.add_func ("/Reversi/reverse/Complete game 381",
+ test_complete_reverse_game_381);
+
+ Test.add_func ("/Reversi/reverse/Complete game 382",
+ test_complete_reverse_game_382);
+
+ Test.add_func ("/Reversi/reverse/Complete game 383",
+ test_complete_reverse_game_383);
+
+ Test.add_func ("/Reversi/reverse/Complete game 384",
+ test_complete_reverse_game_384);
+
+ Test.add_func ("/Reversi/reverse/Complete game 385",
+ test_complete_reverse_game_385);
+
+ Test.add_func ("/Reversi/reverse/Complete game 386",
+ test_complete_reverse_game_386);
+
+ Test.add_func ("/Reversi/reverse/Complete game 387",
+ test_complete_reverse_game_387);
+
+ Test.add_func ("/Reversi/reverse/Complete game 388",
+ test_complete_reverse_game_388);
+
+ Test.add_func ("/Reversi/reverse/Complete game 389",
+ test_complete_reverse_game_389);
+
+ Test.add_func ("/Reversi/reverse/Complete game 390",
+ test_complete_reverse_game_390);
+
+ Test.add_func ("/Reversi/reverse/Complete game 391",
+ test_complete_reverse_game_391);
+
+ Test.add_func ("/Reversi/reverse/Complete game 392",
+ test_complete_reverse_game_392);
+
+ Test.add_func ("/Reversi/reverse/Complete game 393",
+ test_complete_reverse_game_393);
+
+ Test.add_func ("/Reversi/reverse/Complete game 394",
+ test_complete_reverse_game_394);
+
+ Test.add_func ("/Reversi/reverse/Complete game 395",
+ test_complete_reverse_game_395);
+
+ Test.add_func ("/Reversi/reverse/Complete game 396",
+ test_complete_reverse_game_396);
+
+ Test.add_func ("/Reversi/reverse/Complete game 397",
+ test_complete_reverse_game_397);
+
+ Test.add_func ("/Reversi/reverse/Complete game 398",
+ test_complete_reverse_game_398);
+
+ Test.add_func ("/Reversi/reverse/Complete game 399",
+ test_complete_reverse_game_399);
+
+ Test.add_func ("/Reversi/reverse/Complete game 400",
+ test_complete_reverse_game_400);
+
+ Test.add_func ("/Reversi/reverse/Complete game 401",
+ test_complete_reverse_game_401);
+
+ Test.add_func ("/Reversi/reverse/Complete game 402",
+ test_complete_reverse_game_402);
+
+ Test.add_func ("/Reversi/reverse/Complete game 403",
+ test_complete_reverse_game_403);
+
+ Test.add_func ("/Reversi/reverse/Complete game 404",
+ test_complete_reverse_game_404);
+
+ Test.add_func ("/Reversi/reverse/Complete game 405",
+ test_complete_reverse_game_405);
+
+ Test.add_func ("/Reversi/reverse/Complete game 406",
+ test_complete_reverse_game_406);
+
+ Test.add_func ("/Reversi/reverse/Complete game 407",
+ test_complete_reverse_game_407);
+
+ Test.add_func ("/Reversi/reverse/Complete game 408",
+ test_complete_reverse_game_408);
+
+ Test.add_func ("/Reversi/reverse/Complete game 409",
+ test_complete_reverse_game_409);
+
+ Test.add_func ("/Reversi/reverse/Complete game 410",
+ test_complete_reverse_game_410);
+
+ Test.add_func ("/Reversi/reverse/Complete game 411",
+ test_complete_reverse_game_411);
+
+ Test.add_func ("/Reversi/reverse/Complete game 412",
+ test_complete_reverse_game_412);
+
+ Test.add_func ("/Reversi/reverse/Complete game 413",
+ test_complete_reverse_game_413);
+
+ Test.add_func ("/Reversi/reverse/Complete game 414",
+ test_complete_reverse_game_414);
+
+ Test.add_func ("/Reversi/reverse/Complete game 415",
+ test_complete_reverse_game_415);
+
+ Test.add_func ("/Reversi/reverse/Complete game 416",
+ test_complete_reverse_game_416);
+
+ Test.add_func ("/Reversi/reverse/Complete game 417",
+ test_complete_reverse_game_417);
+
+ Test.add_func ("/Reversi/reverse/Complete game 418",
+ test_complete_reverse_game_418);
+
+ Test.add_func ("/Reversi/reverse/Complete game 419",
+ test_complete_reverse_game_419);
+
+ Test.add_func ("/Reversi/reverse/Complete game 420",
+ test_complete_reverse_game_420);
+
+ Test.add_func ("/Reversi/reverse/Complete game 421",
+ test_complete_reverse_game_421);
+
+ Test.add_func ("/Reversi/reverse/Complete game 422",
+ test_complete_reverse_game_422);
+
+ Test.add_func ("/Reversi/reverse/Complete game 423",
+ test_complete_reverse_game_423);
+
+ Test.add_func ("/Reversi/reverse/Complete game 424",
+ test_complete_reverse_game_424);
+
+ Test.add_func ("/Reversi/reverse/Complete game 425",
+ test_complete_reverse_game_425);
+
+ Test.add_func ("/Reversi/reverse/Complete game 426",
+ test_complete_reverse_game_426);
+
+ Test.add_func ("/Reversi/reverse/Complete game 427",
+ test_complete_reverse_game_427);
+
+ Test.add_func ("/Reversi/reverse/Complete game 428",
+ test_complete_reverse_game_428);
+
+ Test.add_func ("/Reversi/reverse/Complete game 429",
+ test_complete_reverse_game_429);
+
+ Test.add_func ("/Reversi/reverse/Complete game 430",
+ test_complete_reverse_game_430);
+
+ Test.add_func ("/Reversi/reverse/Complete game 431",
+ test_complete_reverse_game_431);
+
+ Test.add_func ("/Reversi/reverse/Complete game 432",
+ test_complete_reverse_game_432);
+
+ Test.add_func ("/Reversi/reverse/Complete game 433",
+ test_complete_reverse_game_433);
+
+ Test.add_func ("/Reversi/reverse/Complete game 434",
+ test_complete_reverse_game_434);
+
+ Test.add_func ("/Reversi/reverse/Complete game 435",
+ test_complete_reverse_game_435);
+
+ Test.add_func ("/Reversi/reverse/Complete game 436",
+ test_complete_reverse_game_436);
+
+ Test.add_func ("/Reversi/reverse/Complete game 437",
+ test_complete_reverse_game_437);
+
+ Test.add_func ("/Reversi/reverse/Complete game 438",
+ test_complete_reverse_game_438);
+
+ Test.add_func ("/Reversi/reverse/Complete game 439",
+ test_complete_reverse_game_439);
+
+ Test.add_func ("/Reversi/reverse/Complete game 440",
+ test_complete_reverse_game_440);
+
+ Test.add_func ("/Reversi/reverse/Complete game 441",
+ test_complete_reverse_game_441);
+
+ Test.add_func ("/Reversi/reverse/Complete game 442",
+ test_complete_reverse_game_442);
+
+ Test.add_func ("/Reversi/reverse/Complete game 443",
+ test_complete_reverse_game_443);
+
+ Test.add_func ("/Reversi/reverse/Complete game 444",
+ test_complete_reverse_game_444);
+
+ Test.add_func ("/Reversi/reverse/Complete game 445",
+ test_complete_reverse_game_445);
+
+ Test.add_func ("/Reversi/reverse/Complete game 446",
+ test_complete_reverse_game_446);
+
+ Test.add_func ("/Reversi/reverse/Complete game 447",
+ test_complete_reverse_game_447);
+
+ Test.add_func ("/Reversi/reverse/Complete game 448",
+ test_complete_reverse_game_448);
+
+ Test.add_func ("/Reversi/reverse/Complete game 449",
+ test_complete_reverse_game_449);
+
+ Test.add_func ("/Reversi/reverse/Complete game 450",
+ test_complete_reverse_game_450);
+
+ Test.add_func ("/Reversi/reverse/Complete game 451",
+ test_complete_reverse_game_451);
+
+ Test.add_func ("/Reversi/reverse/Complete game 452",
+ test_complete_reverse_game_452);
+
+ Test.add_func ("/Reversi/reverse/Complete game 453",
+ test_complete_reverse_game_453);
+
+ Test.add_func ("/Reversi/reverse/Complete game 454",
+ test_complete_reverse_game_454);
+
+ Test.add_func ("/Reversi/reverse/Complete game 455",
+ test_complete_reverse_game_455);
+
+ Test.add_func ("/Reversi/reverse/Complete game 456",
+ test_complete_reverse_game_456);
+
+ Test.add_func ("/Reversi/reverse/Complete game 457",
+ test_complete_reverse_game_457);
+
+ Test.add_func ("/Reversi/reverse/Complete game 458",
+ test_complete_reverse_game_458);
+
+ Test.add_func ("/Reversi/reverse/Complete game 459",
+ test_complete_reverse_game_459);
+
+ Test.add_func ("/Reversi/reverse/Complete game 460",
+ test_complete_reverse_game_460);
+
+ Test.add_func ("/Reversi/reverse/Complete game 461",
+ test_complete_reverse_game_461);
+
+ Test.add_func ("/Reversi/reverse/Complete game 462",
+ test_complete_reverse_game_462);
+
+ Test.add_func ("/Reversi/reverse/Complete game 463",
+ test_complete_reverse_game_463);
+
+ Test.add_func ("/Reversi/reverse/Complete game 464",
+ test_complete_reverse_game_464);
+
+ Test.add_func ("/Reversi/reverse/Complete game 465",
+ test_complete_reverse_game_465);
+
+ Test.add_func ("/Reversi/reverse/Complete game 466",
+ test_complete_reverse_game_466);
+
+ Test.add_func ("/Reversi/reverse/Complete game 467",
+ test_complete_reverse_game_467);
+
+ Test.add_func ("/Reversi/reverse/Complete game 468",
+ test_complete_reverse_game_468);
+
+ Test.add_func ("/Reversi/reverse/Complete game 469",
+ test_complete_reverse_game_469);
+
+ Test.add_func ("/Reversi/reverse/Complete game 470",
+ test_complete_reverse_game_470);
+
+ Test.add_func ("/Reversi/reverse/Complete game 471",
+ test_complete_reverse_game_471);
+
+ Test.add_func ("/Reversi/reverse/Complete game 472",
+ test_complete_reverse_game_472);
+
+ Test.add_func ("/Reversi/reverse/Complete game 473",
+ test_complete_reverse_game_473);
+
+ Test.add_func ("/Reversi/reverse/Complete game 474",
+ test_complete_reverse_game_474);
+
+ Test.add_func ("/Reversi/reverse/Complete game 475",
+ test_complete_reverse_game_475);
+
+ Test.add_func ("/Reversi/reverse/Complete game 476",
+ test_complete_reverse_game_476);
+
+ Test.add_func ("/Reversi/reverse/Complete game 477",
+ test_complete_reverse_game_477);
+
+ Test.add_func ("/Reversi/reverse/Complete game 478",
+ test_complete_reverse_game_478);
+
+ Test.add_func ("/Reversi/reverse/Complete game 479",
+ test_complete_reverse_game_479);
+
+ Test.add_func ("/Reversi/reverse/Complete game 480",
+ test_complete_reverse_game_480);
+
+ Test.add_func ("/Reversi/reverse/Complete game 481",
+ test_complete_reverse_game_481);
+
+ Test.add_func ("/Reversi/reverse/Complete game 482",
+ test_complete_reverse_game_482);
+
+ Test.add_func ("/Reversi/reverse/Complete game 483",
+ test_complete_reverse_game_483);
+
+ Test.add_func ("/Reversi/reverse/Complete game 484",
+ test_complete_reverse_game_484);
+
+ Test.add_func ("/Reversi/reverse/Complete game 485",
+ test_complete_reverse_game_485);
+
+ Test.add_func ("/Reversi/reverse/Complete game 486",
+ test_complete_reverse_game_486);
+
+ Test.add_func ("/Reversi/reverse/Complete game 487",
+ test_complete_reverse_game_487);
+
+ Test.add_func ("/Reversi/reverse/Complete game 488",
+ test_complete_reverse_game_488);
+
+ Test.add_func ("/Reversi/reverse/Complete game 489",
+ test_complete_reverse_game_489);
+
+ Test.add_func ("/Reversi/reverse/Complete game 490",
+ test_complete_reverse_game_490);
+
+ Test.add_func ("/Reversi/reverse/Complete game 491",
+ test_complete_reverse_game_491);
+
+ Test.add_func ("/Reversi/reverse/Complete game 492",
+ test_complete_reverse_game_492);
+
+ Test.add_func ("/Reversi/reverse/Complete game 493",
+ test_complete_reverse_game_493);
+
+ Test.add_func ("/Reversi/reverse/Complete game 494",
+ test_complete_reverse_game_494);
+
+ Test.add_func ("/Reversi/reverse/Complete game 495",
+ test_complete_reverse_game_495);
+
+ Test.add_func ("/Reversi/reverse/Complete game 496",
+ test_complete_reverse_game_496);
+
+ Test.add_func ("/Reversi/reverse/Complete game 497",
+ test_complete_reverse_game_497);
+
+ Test.add_func ("/Reversi/reverse/Complete game 498",
+ test_complete_reverse_game_498);
+
+ Test.add_func ("/Reversi/reverse/Complete game 499",
+ test_complete_reverse_game_499);
+
+ Test.add_func ("/Reversi/reverse/Complete game 500",
+ test_complete_reverse_game_500);
+
+ Test.add_func ("/Reversi/reverse/Complete game 501",
+ test_complete_reverse_game_501);
+
+ Test.add_func ("/Reversi/reverse/Complete game 502",
+ test_complete_reverse_game_502);
+
+ Test.add_func ("/Reversi/reverse/Complete game 503",
+ test_complete_reverse_game_503);
+
+ Test.add_func ("/Reversi/reverse/Complete game 504",
+ test_complete_reverse_game_504);
+
+ Test.add_func ("/Reversi/reverse/Complete game 505",
+ test_complete_reverse_game_505);
+
+ Test.add_func ("/Reversi/reverse/Complete game 506",
+ test_complete_reverse_game_506);
+
+ Test.add_func ("/Reversi/reverse/Complete game 507",
+ test_complete_reverse_game_507);
+
+ Test.add_func ("/Reversi/reverse/Complete game 508",
+ test_complete_reverse_game_508);
+
+ Test.add_func ("/Reversi/reverse/Complete game 509",
+ test_complete_reverse_game_509);
+
+ Test.add_func ("/Reversi/reverse/Complete game 510",
+ test_complete_reverse_game_510);
+
+ Test.add_func ("/Reversi/reverse/Complete game 511",
+ test_complete_reverse_game_511);
+
+ Test.add_func ("/Reversi/reverse/Complete game 512",
+ test_complete_reverse_game_512);
+
+ Test.add_func ("/Reversi/reverse/Complete game 513",
+ test_complete_reverse_game_513);
+ }
+
+ /*\
+ * * perfs tests
+ \*/
+
+ private static inline void test_complete_reverse_game_1 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . D L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_2 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L L .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_3 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_4 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_5 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_6 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ }
+
+ private static inline void test_complete_reverse_game_7 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_8 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_9 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L L .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_10 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_11 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_12 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_13 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_14 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L L L .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_15 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_16 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_17 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ }
+
+ private static inline void test_complete_reverse_game_18 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_19 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_20 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L L L .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_21 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_22 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_23 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_24 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_25 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L L L L .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_26 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_27 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_28 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_29 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . L . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_30 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_31 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_32 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_33 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_34 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . L L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ }
+
+ private static inline void test_complete_reverse_game_35 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_36 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_37 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reverse_game_38 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_39 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_40 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . L L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_41 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 2));
+ }
+
+ private static inline void test_complete_reverse_game_42 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_43 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_44 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 2));
+ }
+
+ private static inline void test_complete_reverse_game_45 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . D L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_46 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . D L . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_47 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . D L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_48 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . L L L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_49 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D D L D . .",
+ /* 5 */ " . . . L . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_50 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . D D L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_51 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . L . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_52 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . L . L D . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_53 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ }
+
+ private static inline void test_complete_reverse_game_54 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_55 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_56 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ }
+
+ private static inline void test_complete_reverse_game_57 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_58 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_59 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_60 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_61 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_62 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L D .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_63 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_64 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L D D .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_65 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_66 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L D D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_67 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . D D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_68 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_69 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_70 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L L . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_71 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ }
+
+ private static inline void test_complete_reverse_game_72 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_73 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_74 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_75 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L L . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_76 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_77 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_78 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_79 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_80 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L L L .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_81 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_82 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 1));
+ }
+
+ private static inline void test_complete_reverse_game_83 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_84 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 1));
+ }
+
+ private static inline void test_complete_reverse_game_85 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_86 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . L . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_87 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_88 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_89 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . L . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_90 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_91 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_92 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ }
+
+ private static inline void test_complete_reverse_game_93 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_94 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_95 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . L L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ }
+
+ private static inline void test_complete_reverse_game_96 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . L . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_97 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_98 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_99 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_100 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . L L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_101 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . D . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_102 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . D D L . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_103 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_104 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_105 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_106 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . D L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ }
+
+ private static inline void test_complete_reverse_game_107 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D D D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_108 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . D D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_109 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . D L D . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_110 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_111 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ }
+
+ private static inline void test_complete_reverse_game_112 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . L . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_113 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . L . L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_114 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_115 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_116 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 0));
+ }
+
+ private static inline void test_complete_reverse_game_117 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_118 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_119 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reverse_game_120 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_121 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_122 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_123 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_124 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ }
+
+ private static inline void test_complete_reverse_game_125 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_126 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_127 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reverse_game_128 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . L . . . . .",
+ /* 2 */ " . . . L L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 2));
+ }
+
+ private static inline void test_complete_reverse_game_129 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reverse_game_130 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_131 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_132 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . L .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ }
+
+ private static inline void test_complete_reverse_game_133 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . L .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_134 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ }
+
+ private static inline void test_complete_reverse_game_135 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_136 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L . . .",
+ /* 2 */ " . . . D L D . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_137 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D D D . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_138 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D D D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_139 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L D . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_140 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . D D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_141 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . D D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_142 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . D D . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 1));
+ }
+
+ private static inline void test_complete_reverse_game_143 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . L D D . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 1));
+ }
+
+ private static inline void test_complete_reverse_game_144 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . L . . D . .",
+ /* 2 */ " . . . L D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_145 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_146 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_147 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_148 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_149 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_150 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ }
+
+ private static inline void test_complete_reverse_game_151 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_152 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ }
+
+ private static inline void test_complete_reverse_game_153 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ }
+
+ private static inline void test_complete_reverse_game_154 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_155 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_156 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_157 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_158 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_159 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_160 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_161 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_162 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_163 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_164 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_165 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_166 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_167 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_168 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_169 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_170 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . L L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_171 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_172 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_173 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_174 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ }
+
+ private static inline void test_complete_reverse_game_175 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . L L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_176 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_177 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_178 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . D D D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_179 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . D D D L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_180 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . D D D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_181 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . D D L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_182 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . D D D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_183 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . L . . . . . .",
+ /* 2 */ " . D L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_184 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_185 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_186 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L L . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_187 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . L L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_188 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_189 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ }
+
+ private static inline void test_complete_reverse_game_190 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_191 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L L . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_192 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . L L L L . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ }
+
+ private static inline void test_complete_reverse_game_193 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . D L . L .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_194 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . L .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_195 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L D D . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_196 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L . . .",
+ /* 3 */ " . . D L D D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_197 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L L L .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_198 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L D . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_199 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L D . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_200 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L D . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_201 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_202 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_203 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . L . D . . .",
+ /* 3 */ " . . D L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_204 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . L L L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_205 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_206 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_207 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_208 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_209 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reverse_game_210 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_211 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 3));
+ }
+
+ private static inline void test_complete_reverse_game_212 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_213 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_214 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_215 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ }
+
+ private static inline void test_complete_reverse_game_216 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_217 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_218 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_219 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_220 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_221 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_222 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_223 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 4));
+ }
+
+ private static inline void test_complete_reverse_game_224 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 4));
+ }
+
+ private static inline void test_complete_reverse_game_225 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_226 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_227 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_228 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ }
+
+ private static inline void test_complete_reverse_game_229 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_230 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L L D . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_231 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . L L L D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_232 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_233 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_234 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_235 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_236 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . L L L D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_237 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . L D .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_238 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_239 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_240 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_241 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_242 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_243 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ }
+
+ private static inline void test_complete_reverse_game_244 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_245 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . L .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_246 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 1));
+ }
+
+ private static inline void test_complete_reverse_game_247 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 1));
+ }
+
+ private static inline void test_complete_reverse_game_248 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_249 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_250 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . L L . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_251 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . D D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_252 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_253 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . D D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_254 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_255 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_256 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_257 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_258 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_259 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_260 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_261 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_262 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . L . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_263 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_264 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_265 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_266 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ }
+
+ private static inline void test_complete_reverse_game_267 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_268 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . L . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_269 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D L . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_270 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L L L . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_271 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_272 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_273 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_274 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_275 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_276 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . D D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ }
+
+ private static inline void test_complete_reverse_game_277 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ }
+
+ private static inline void test_complete_reverse_game_278 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 6));
+ }
+
+ private static inline void test_complete_reverse_game_279 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_280 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . D L . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_281 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_282 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . D D D L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_283 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . D D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_284 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_285 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . L . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_286 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_287 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_288 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . L . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_289 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . L . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_290 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_291 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_292 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L L L . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_293 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_294 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ }
+
+ private static inline void test_complete_reverse_game_295 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_296 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_297 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reverse_game_298 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . D L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_299 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . D L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_300 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . L L L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_301 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . D L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ }
+
+ private static inline void test_complete_reverse_game_302 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_303 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . L L L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_304 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_305 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_306 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_307 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_308 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_309 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_310 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . L . D .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_311 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_312 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . L . D .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_313 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_314 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reverse_game_315 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_316 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . D .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_317 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_318 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_319 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_320 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ }
+
+ private static inline void test_complete_reverse_game_321 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_322 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_323 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . L L . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_324 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . D D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_325 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_326 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . D D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_327 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_328 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_329 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_330 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_331 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ }
+
+ private static inline void test_complete_reverse_game_332 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_333 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_334 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_335 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_336 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_337 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_338 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_339 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_340 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_341 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_342 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_343 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_344 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 3));
+ }
+
+ private static inline void test_complete_reverse_game_345 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_346 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ }
+
+ private static inline void test_complete_reverse_game_347 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ }
+
+ private static inline void test_complete_reverse_game_348 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . L . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ }
+
+ private static inline void test_complete_reverse_game_349 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D L . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_350 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D L . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_351 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L L L . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_352 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_353 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_354 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_355 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_356 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_357 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . D D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_358 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_359 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_360 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . L L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ }
+
+ private static inline void test_complete_reverse_game_361 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_362 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_363 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_364 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . D L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ }
+
+ private static inline void test_complete_reverse_game_365 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_366 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . D D D L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 3));
+ }
+
+ private static inline void test_complete_reverse_game_367 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . D D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 6));
+ }
+
+ private static inline void test_complete_reverse_game_368 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 4));
+ }
+
+ private static inline void test_complete_reverse_game_369 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . L . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_370 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_371 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 0));
+ }
+
+ private static inline void test_complete_reverse_game_372 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . L . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 4));
+ }
+
+ private static inline void test_complete_reverse_game_373 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_374 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_375 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ }
+
+ private static inline void test_complete_reverse_game_376 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L L L . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_377 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_378 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_379 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_380 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_381 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ }
+
+ private static inline void test_complete_reverse_game_382 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_383 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ }
+
+ private static inline void test_complete_reverse_game_384 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_385 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_386 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_387 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . D . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_388 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_389 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_390 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ }
+
+ private static inline void test_complete_reverse_game_391 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ }
+
+ private static inline void test_complete_reverse_game_392 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D D . L .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 4));
+ }
+
+ private static inline void test_complete_reverse_game_393 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_394 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_395 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L L L .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_396 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L D . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_397 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_398 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 1));
+ }
+
+ private static inline void test_complete_reverse_game_399 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L D . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_400 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_401 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . L D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_402 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_403 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_404 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . L . D . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ }
+
+ private static inline void test_complete_reverse_game_405 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_406 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_407 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ }
+
+ private static inline void test_complete_reverse_game_408 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_409 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_410 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ }
+
+ private static inline void test_complete_reverse_game_411 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ }
+
+ private static inline void test_complete_reverse_game_412 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . L L L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_413 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . L D . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ }
+
+ private static inline void test_complete_reverse_game_414 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . L D . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_415 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . L D . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_416 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_417 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_418 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_419 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_420 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_421 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reverse_game_422 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_423 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_424 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_425 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_426 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_427 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_428 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ }
+
+ private static inline void test_complete_reverse_game_429 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_430 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_431 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reverse_game_432 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_433 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_434 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_435 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_436 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_437 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . L L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_438 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_439 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reverse_game_440 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_441 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_442 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 0));
+ }
+
+ private static inline void test_complete_reverse_game_443 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ }
+
+ private static inline void test_complete_reverse_game_444 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_445 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_446 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . D . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_447 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . D . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 6));
+ }
+
+ private static inline void test_complete_reverse_game_448 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . D . D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_449 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . D . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ }
+
+ private static inline void test_complete_reverse_game_450 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . D . D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_451 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . D . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_452 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . D . D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_453 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_454 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_455 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 0));
+ }
+
+ private static inline void test_complete_reverse_game_456 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L L L L .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_457 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_458 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ }
+
+ private static inline void test_complete_reverse_game_459 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_460 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_461 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_462 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_463 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 0));
+ }
+
+ private static inline void test_complete_reverse_game_464 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_465 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 1));
+ }
+
+ private static inline void test_complete_reverse_game_466 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_467 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_468 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_469 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 6));
+ }
+
+ private static inline void test_complete_reverse_game_470 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_471 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_472 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . D . . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reverse_game_473 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_474 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_475 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reverse_game_476 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reverse_game_477 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . L .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_478 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . L .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_479 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 6));
+ }
+
+ private static inline void test_complete_reverse_game_480 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reverse_game_481 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L L L .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_482 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reverse_game_483 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_484 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L D . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reverse_game_485 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reverse_game_486 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_487 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . L . D . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_488 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ }
+
+ private static inline void test_complete_reverse_game_489 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_490 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ }
+
+ private static inline void test_complete_reverse_game_491 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_492 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_493 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reverse_game_494 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_495 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reverse_game_496 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reverse_game_497 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_498 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_499 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reverse_game_500 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reverse_game_501 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reverse_game_502 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reverse_game_503 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_504 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . L L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reverse_game_505 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reverse_game_506 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_507 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reverse_game_508 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 1));
+ }
+
+ private static inline void test_complete_reverse_game_509 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 1));
+ }
+
+ private static inline void test_complete_reverse_game_510 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ }
+
+ private static inline void test_complete_reverse_game_511 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_512 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reverse_game_513 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ true);
+ ComputerPlayer ai = new ComputerReverseHard (game, /* depth */ 2, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ }
+}
diff --git a/src/perfs-tests-reversi.vala b/src/perfs-tests-reversi.vala
new file mode 100644
index 0000000..30267ff
--- /dev/null
+++ b/src/perfs-tests-reversi.vala
@@ -0,0 +1,38162 @@
+/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+
+ This file is part of GNOME Reversi, also known as Iagno.
+
+ Copyright 2019 — Arnaud Bonatti
+ File updated by `ninja update-perfs-tests`
+
+ GNOME Reversi is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ GNOME Reversi is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNOME Reversi. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+namespace GeneratedTests
+{
+ private static void perfs_tests_reversi ()
+ {
+ /* crossing start position */
+ Test.add_func ("/Reversi/reversi/Complete game 1",
+ test_complete_reversi_game_1);
+
+ Test.add_func ("/Reversi/reversi/Complete game 2",
+ test_complete_reversi_game_2);
+
+ Test.add_func ("/Reversi/reversi/Complete game 3",
+ test_complete_reversi_game_3);
+
+ Test.add_func ("/Reversi/reversi/Complete game 4",
+ test_complete_reversi_game_4);
+
+ Test.add_func ("/Reversi/reversi/Complete game 5",
+ test_complete_reversi_game_5);
+
+ Test.add_func ("/Reversi/reversi/Complete game 6",
+ test_complete_reversi_game_6);
+
+ Test.add_func ("/Reversi/reversi/Complete game 7",
+ test_complete_reversi_game_7);
+
+ Test.add_func ("/Reversi/reversi/Complete game 8",
+ test_complete_reversi_game_8);
+
+ Test.add_func ("/Reversi/reversi/Complete game 9",
+ test_complete_reversi_game_9);
+
+ Test.add_func ("/Reversi/reversi/Complete game 10",
+ test_complete_reversi_game_10);
+
+ Test.add_func ("/Reversi/reversi/Complete game 11",
+ test_complete_reversi_game_11);
+
+ Test.add_func ("/Reversi/reversi/Complete game 12",
+ test_complete_reversi_game_12);
+
+ Test.add_func ("/Reversi/reversi/Complete game 13",
+ test_complete_reversi_game_13);
+
+ Test.add_func ("/Reversi/reversi/Complete game 14",
+ test_complete_reversi_game_14);
+
+ Test.add_func ("/Reversi/reversi/Complete game 15",
+ test_complete_reversi_game_15);
+
+ Test.add_func ("/Reversi/reversi/Complete game 16",
+ test_complete_reversi_game_16);
+
+ Test.add_func ("/Reversi/reversi/Complete game 17",
+ test_complete_reversi_game_17);
+
+ Test.add_func ("/Reversi/reversi/Complete game 18",
+ test_complete_reversi_game_18);
+
+ Test.add_func ("/Reversi/reversi/Complete game 19",
+ test_complete_reversi_game_19);
+
+ Test.add_func ("/Reversi/reversi/Complete game 20",
+ test_complete_reversi_game_20);
+
+ Test.add_func ("/Reversi/reversi/Complete game 21",
+ test_complete_reversi_game_21);
+
+ Test.add_func ("/Reversi/reversi/Complete game 22",
+ test_complete_reversi_game_22);
+
+ Test.add_func ("/Reversi/reversi/Complete game 23",
+ test_complete_reversi_game_23);
+
+ Test.add_func ("/Reversi/reversi/Complete game 24",
+ test_complete_reversi_game_24);
+
+ Test.add_func ("/Reversi/reversi/Complete game 25",
+ test_complete_reversi_game_25);
+
+ Test.add_func ("/Reversi/reversi/Complete game 26",
+ test_complete_reversi_game_26);
+
+ Test.add_func ("/Reversi/reversi/Complete game 27",
+ test_complete_reversi_game_27);
+
+ Test.add_func ("/Reversi/reversi/Complete game 28",
+ test_complete_reversi_game_28);
+
+ Test.add_func ("/Reversi/reversi/Complete game 29",
+ test_complete_reversi_game_29);
+
+ Test.add_func ("/Reversi/reversi/Complete game 30",
+ test_complete_reversi_game_30);
+
+ Test.add_func ("/Reversi/reversi/Complete game 31",
+ test_complete_reversi_game_31);
+
+ Test.add_func ("/Reversi/reversi/Complete game 32",
+ test_complete_reversi_game_32);
+
+ Test.add_func ("/Reversi/reversi/Complete game 33",
+ test_complete_reversi_game_33);
+
+ Test.add_func ("/Reversi/reversi/Complete game 34",
+ test_complete_reversi_game_34);
+
+ Test.add_func ("/Reversi/reversi/Complete game 35",
+ test_complete_reversi_game_35);
+
+ Test.add_func ("/Reversi/reversi/Complete game 36",
+ test_complete_reversi_game_36);
+
+ Test.add_func ("/Reversi/reversi/Complete game 37",
+ test_complete_reversi_game_37);
+
+ Test.add_func ("/Reversi/reversi/Complete game 38",
+ test_complete_reversi_game_38);
+
+ Test.add_func ("/Reversi/reversi/Complete game 39",
+ test_complete_reversi_game_39);
+
+ Test.add_func ("/Reversi/reversi/Complete game 40",
+ test_complete_reversi_game_40);
+
+ Test.add_func ("/Reversi/reversi/Complete game 41",
+ test_complete_reversi_game_41);
+
+ Test.add_func ("/Reversi/reversi/Complete game 42",
+ test_complete_reversi_game_42);
+
+ Test.add_func ("/Reversi/reversi/Complete game 43",
+ test_complete_reversi_game_43);
+
+ Test.add_func ("/Reversi/reversi/Complete game 44",
+ test_complete_reversi_game_44);
+
+ Test.add_func ("/Reversi/reversi/Complete game 45",
+ test_complete_reversi_game_45);
+
+ Test.add_func ("/Reversi/reversi/Complete game 46",
+ test_complete_reversi_game_46);
+
+ Test.add_func ("/Reversi/reversi/Complete game 47",
+ test_complete_reversi_game_47);
+
+ Test.add_func ("/Reversi/reversi/Complete game 48",
+ test_complete_reversi_game_48);
+
+ Test.add_func ("/Reversi/reversi/Complete game 49",
+ test_complete_reversi_game_49);
+
+ Test.add_func ("/Reversi/reversi/Complete game 50",
+ test_complete_reversi_game_50);
+
+ Test.add_func ("/Reversi/reversi/Complete game 51",
+ test_complete_reversi_game_51);
+
+ Test.add_func ("/Reversi/reversi/Complete game 52",
+ test_complete_reversi_game_52);
+
+ Test.add_func ("/Reversi/reversi/Complete game 53",
+ test_complete_reversi_game_53);
+
+ Test.add_func ("/Reversi/reversi/Complete game 54",
+ test_complete_reversi_game_54);
+
+ Test.add_func ("/Reversi/reversi/Complete game 55",
+ test_complete_reversi_game_55);
+
+ Test.add_func ("/Reversi/reversi/Complete game 56",
+ test_complete_reversi_game_56);
+
+ Test.add_func ("/Reversi/reversi/Complete game 57",
+ test_complete_reversi_game_57);
+
+ Test.add_func ("/Reversi/reversi/Complete game 58",
+ test_complete_reversi_game_58);
+
+ Test.add_func ("/Reversi/reversi/Complete game 59",
+ test_complete_reversi_game_59);
+
+ Test.add_func ("/Reversi/reversi/Complete game 60",
+ test_complete_reversi_game_60);
+
+ Test.add_func ("/Reversi/reversi/Complete game 61",
+ test_complete_reversi_game_61);
+
+ Test.add_func ("/Reversi/reversi/Complete game 62",
+ test_complete_reversi_game_62);
+
+ Test.add_func ("/Reversi/reversi/Complete game 63",
+ test_complete_reversi_game_63);
+
+ Test.add_func ("/Reversi/reversi/Complete game 64",
+ test_complete_reversi_game_64);
+
+ Test.add_func ("/Reversi/reversi/Complete game 65",
+ test_complete_reversi_game_65);
+
+ Test.add_func ("/Reversi/reversi/Complete game 66",
+ test_complete_reversi_game_66);
+
+ Test.add_func ("/Reversi/reversi/Complete game 67",
+ test_complete_reversi_game_67);
+
+ Test.add_func ("/Reversi/reversi/Complete game 68",
+ test_complete_reversi_game_68);
+
+ Test.add_func ("/Reversi/reversi/Complete game 69",
+ test_complete_reversi_game_69);
+
+ Test.add_func ("/Reversi/reversi/Complete game 70",
+ test_complete_reversi_game_70);
+
+ Test.add_func ("/Reversi/reversi/Complete game 71",
+ test_complete_reversi_game_71);
+
+ Test.add_func ("/Reversi/reversi/Complete game 72",
+ test_complete_reversi_game_72);
+
+ Test.add_func ("/Reversi/reversi/Complete game 73",
+ test_complete_reversi_game_73);
+
+ Test.add_func ("/Reversi/reversi/Complete game 74",
+ test_complete_reversi_game_74);
+
+ Test.add_func ("/Reversi/reversi/Complete game 75",
+ test_complete_reversi_game_75);
+
+ Test.add_func ("/Reversi/reversi/Complete game 76",
+ test_complete_reversi_game_76);
+
+ Test.add_func ("/Reversi/reversi/Complete game 77",
+ test_complete_reversi_game_77);
+
+ Test.add_func ("/Reversi/reversi/Complete game 78",
+ test_complete_reversi_game_78);
+
+ Test.add_func ("/Reversi/reversi/Complete game 79",
+ test_complete_reversi_game_79);
+
+ Test.add_func ("/Reversi/reversi/Complete game 80",
+ test_complete_reversi_game_80);
+
+ Test.add_func ("/Reversi/reversi/Complete game 81",
+ test_complete_reversi_game_81);
+
+ Test.add_func ("/Reversi/reversi/Complete game 82",
+ test_complete_reversi_game_82);
+
+ Test.add_func ("/Reversi/reversi/Complete game 83",
+ test_complete_reversi_game_83);
+
+ Test.add_func ("/Reversi/reversi/Complete game 84",
+ test_complete_reversi_game_84);
+
+ Test.add_func ("/Reversi/reversi/Complete game 85",
+ test_complete_reversi_game_85);
+
+ Test.add_func ("/Reversi/reversi/Complete game 86",
+ test_complete_reversi_game_86);
+
+ Test.add_func ("/Reversi/reversi/Complete game 87",
+ test_complete_reversi_game_87);
+
+ Test.add_func ("/Reversi/reversi/Complete game 88",
+ test_complete_reversi_game_88);
+
+ Test.add_func ("/Reversi/reversi/Complete game 89",
+ test_complete_reversi_game_89);
+
+ Test.add_func ("/Reversi/reversi/Complete game 90",
+ test_complete_reversi_game_90);
+
+ Test.add_func ("/Reversi/reversi/Complete game 91",
+ test_complete_reversi_game_91);
+
+ Test.add_func ("/Reversi/reversi/Complete game 92",
+ test_complete_reversi_game_92);
+
+ Test.add_func ("/Reversi/reversi/Complete game 93",
+ test_complete_reversi_game_93);
+
+ Test.add_func ("/Reversi/reversi/Complete game 94",
+ test_complete_reversi_game_94);
+
+ Test.add_func ("/Reversi/reversi/Complete game 95",
+ test_complete_reversi_game_95);
+
+ Test.add_func ("/Reversi/reversi/Complete game 96",
+ test_complete_reversi_game_96);
+
+ Test.add_func ("/Reversi/reversi/Complete game 97",
+ test_complete_reversi_game_97);
+
+ Test.add_func ("/Reversi/reversi/Complete game 98",
+ test_complete_reversi_game_98);
+
+ Test.add_func ("/Reversi/reversi/Complete game 99",
+ test_complete_reversi_game_99);
+
+ Test.add_func ("/Reversi/reversi/Complete game 100",
+ test_complete_reversi_game_100);
+
+ Test.add_func ("/Reversi/reversi/Complete game 101",
+ test_complete_reversi_game_101);
+
+ Test.add_func ("/Reversi/reversi/Complete game 102",
+ test_complete_reversi_game_102);
+
+ Test.add_func ("/Reversi/reversi/Complete game 103",
+ test_complete_reversi_game_103);
+
+ Test.add_func ("/Reversi/reversi/Complete game 104",
+ test_complete_reversi_game_104);
+
+ Test.add_func ("/Reversi/reversi/Complete game 105",
+ test_complete_reversi_game_105);
+
+ Test.add_func ("/Reversi/reversi/Complete game 106",
+ test_complete_reversi_game_106);
+
+ Test.add_func ("/Reversi/reversi/Complete game 107",
+ test_complete_reversi_game_107);
+
+ Test.add_func ("/Reversi/reversi/Complete game 108",
+ test_complete_reversi_game_108);
+
+ Test.add_func ("/Reversi/reversi/Complete game 109",
+ test_complete_reversi_game_109);
+
+ Test.add_func ("/Reversi/reversi/Complete game 110",
+ test_complete_reversi_game_110);
+
+ Test.add_func ("/Reversi/reversi/Complete game 111",
+ test_complete_reversi_game_111);
+
+ Test.add_func ("/Reversi/reversi/Complete game 112",
+ test_complete_reversi_game_112);
+
+ Test.add_func ("/Reversi/reversi/Complete game 113",
+ test_complete_reversi_game_113);
+
+ Test.add_func ("/Reversi/reversi/Complete game 114",
+ test_complete_reversi_game_114);
+
+ Test.add_func ("/Reversi/reversi/Complete game 115",
+ test_complete_reversi_game_115);
+
+ Test.add_func ("/Reversi/reversi/Complete game 116",
+ test_complete_reversi_game_116);
+
+ Test.add_func ("/Reversi/reversi/Complete game 117",
+ test_complete_reversi_game_117);
+
+ Test.add_func ("/Reversi/reversi/Complete game 118",
+ test_complete_reversi_game_118);
+
+ Test.add_func ("/Reversi/reversi/Complete game 119",
+ test_complete_reversi_game_119);
+
+ Test.add_func ("/Reversi/reversi/Complete game 120",
+ test_complete_reversi_game_120);
+
+ Test.add_func ("/Reversi/reversi/Complete game 121",
+ test_complete_reversi_game_121);
+
+ Test.add_func ("/Reversi/reversi/Complete game 122",
+ test_complete_reversi_game_122);
+
+ Test.add_func ("/Reversi/reversi/Complete game 123",
+ test_complete_reversi_game_123);
+
+ Test.add_func ("/Reversi/reversi/Complete game 124",
+ test_complete_reversi_game_124);
+
+ Test.add_func ("/Reversi/reversi/Complete game 125",
+ test_complete_reversi_game_125);
+
+ Test.add_func ("/Reversi/reversi/Complete game 126",
+ test_complete_reversi_game_126);
+
+ Test.add_func ("/Reversi/reversi/Complete game 127",
+ test_complete_reversi_game_127);
+
+ Test.add_func ("/Reversi/reversi/Complete game 128",
+ test_complete_reversi_game_128);
+
+ Test.add_func ("/Reversi/reversi/Complete game 129",
+ test_complete_reversi_game_129);
+
+ Test.add_func ("/Reversi/reversi/Complete game 130",
+ test_complete_reversi_game_130);
+
+ Test.add_func ("/Reversi/reversi/Complete game 131",
+ test_complete_reversi_game_131);
+
+ Test.add_func ("/Reversi/reversi/Complete game 132",
+ test_complete_reversi_game_132);
+
+ Test.add_func ("/Reversi/reversi/Complete game 133",
+ test_complete_reversi_game_133);
+
+ Test.add_func ("/Reversi/reversi/Complete game 134",
+ test_complete_reversi_game_134);
+
+ Test.add_func ("/Reversi/reversi/Complete game 135",
+ test_complete_reversi_game_135);
+
+ Test.add_func ("/Reversi/reversi/Complete game 136",
+ test_complete_reversi_game_136);
+
+ Test.add_func ("/Reversi/reversi/Complete game 137",
+ test_complete_reversi_game_137);
+
+ Test.add_func ("/Reversi/reversi/Complete game 138",
+ test_complete_reversi_game_138);
+
+ Test.add_func ("/Reversi/reversi/Complete game 139",
+ test_complete_reversi_game_139);
+
+ Test.add_func ("/Reversi/reversi/Complete game 140",
+ test_complete_reversi_game_140);
+
+ Test.add_func ("/Reversi/reversi/Complete game 141",
+ test_complete_reversi_game_141);
+
+ Test.add_func ("/Reversi/reversi/Complete game 142",
+ test_complete_reversi_game_142);
+
+ Test.add_func ("/Reversi/reversi/Complete game 143",
+ test_complete_reversi_game_143);
+
+ Test.add_func ("/Reversi/reversi/Complete game 144",
+ test_complete_reversi_game_144);
+
+ Test.add_func ("/Reversi/reversi/Complete game 145",
+ test_complete_reversi_game_145);
+
+ Test.add_func ("/Reversi/reversi/Complete game 146",
+ test_complete_reversi_game_146);
+
+ Test.add_func ("/Reversi/reversi/Complete game 147",
+ test_complete_reversi_game_147);
+
+ Test.add_func ("/Reversi/reversi/Complete game 148",
+ test_complete_reversi_game_148);
+
+ Test.add_func ("/Reversi/reversi/Complete game 149",
+ test_complete_reversi_game_149);
+
+ Test.add_func ("/Reversi/reversi/Complete game 150",
+ test_complete_reversi_game_150);
+
+ Test.add_func ("/Reversi/reversi/Complete game 151",
+ test_complete_reversi_game_151);
+
+ Test.add_func ("/Reversi/reversi/Complete game 152",
+ test_complete_reversi_game_152);
+
+ Test.add_func ("/Reversi/reversi/Complete game 153",
+ test_complete_reversi_game_153);
+
+ Test.add_func ("/Reversi/reversi/Complete game 154",
+ test_complete_reversi_game_154);
+
+ Test.add_func ("/Reversi/reversi/Complete game 155",
+ test_complete_reversi_game_155);
+
+ Test.add_func ("/Reversi/reversi/Complete game 156",
+ test_complete_reversi_game_156);
+
+ Test.add_func ("/Reversi/reversi/Complete game 157",
+ test_complete_reversi_game_157);
+
+ Test.add_func ("/Reversi/reversi/Complete game 158",
+ test_complete_reversi_game_158);
+
+ Test.add_func ("/Reversi/reversi/Complete game 159",
+ test_complete_reversi_game_159);
+
+ Test.add_func ("/Reversi/reversi/Complete game 160",
+ test_complete_reversi_game_160);
+
+ Test.add_func ("/Reversi/reversi/Complete game 161",
+ test_complete_reversi_game_161);
+
+ Test.add_func ("/Reversi/reversi/Complete game 162",
+ test_complete_reversi_game_162);
+
+ Test.add_func ("/Reversi/reversi/Complete game 163",
+ test_complete_reversi_game_163);
+
+ Test.add_func ("/Reversi/reversi/Complete game 164",
+ test_complete_reversi_game_164);
+
+ Test.add_func ("/Reversi/reversi/Complete game 165",
+ test_complete_reversi_game_165);
+
+ Test.add_func ("/Reversi/reversi/Complete game 166",
+ test_complete_reversi_game_166);
+
+ Test.add_func ("/Reversi/reversi/Complete game 167",
+ test_complete_reversi_game_167);
+
+ Test.add_func ("/Reversi/reversi/Complete game 168",
+ test_complete_reversi_game_168);
+
+ Test.add_func ("/Reversi/reversi/Complete game 169",
+ test_complete_reversi_game_169);
+
+ Test.add_func ("/Reversi/reversi/Complete game 170",
+ test_complete_reversi_game_170);
+
+ Test.add_func ("/Reversi/reversi/Complete game 171",
+ test_complete_reversi_game_171);
+
+ Test.add_func ("/Reversi/reversi/Complete game 172",
+ test_complete_reversi_game_172);
+
+ Test.add_func ("/Reversi/reversi/Complete game 173",
+ test_complete_reversi_game_173);
+
+ Test.add_func ("/Reversi/reversi/Complete game 174",
+ test_complete_reversi_game_174);
+
+ Test.add_func ("/Reversi/reversi/Complete game 175",
+ test_complete_reversi_game_175);
+
+ Test.add_func ("/Reversi/reversi/Complete game 176",
+ test_complete_reversi_game_176);
+
+ Test.add_func ("/Reversi/reversi/Complete game 177",
+ test_complete_reversi_game_177);
+
+ Test.add_func ("/Reversi/reversi/Complete game 178",
+ test_complete_reversi_game_178);
+
+ Test.add_func ("/Reversi/reversi/Complete game 179",
+ test_complete_reversi_game_179);
+
+ Test.add_func ("/Reversi/reversi/Complete game 180",
+ test_complete_reversi_game_180);
+
+ Test.add_func ("/Reversi/reversi/Complete game 181",
+ test_complete_reversi_game_181);
+
+ Test.add_func ("/Reversi/reversi/Complete game 182",
+ test_complete_reversi_game_182);
+
+ Test.add_func ("/Reversi/reversi/Complete game 183",
+ test_complete_reversi_game_183);
+
+ Test.add_func ("/Reversi/reversi/Complete game 184",
+ test_complete_reversi_game_184);
+
+ Test.add_func ("/Reversi/reversi/Complete game 185",
+ test_complete_reversi_game_185);
+
+ Test.add_func ("/Reversi/reversi/Complete game 186",
+ test_complete_reversi_game_186);
+
+ Test.add_func ("/Reversi/reversi/Complete game 187",
+ test_complete_reversi_game_187);
+
+ Test.add_func ("/Reversi/reversi/Complete game 188",
+ test_complete_reversi_game_188);
+
+ Test.add_func ("/Reversi/reversi/Complete game 189",
+ test_complete_reversi_game_189);
+
+ Test.add_func ("/Reversi/reversi/Complete game 190",
+ test_complete_reversi_game_190);
+
+ Test.add_func ("/Reversi/reversi/Complete game 191",
+ test_complete_reversi_game_191);
+
+ Test.add_func ("/Reversi/reversi/Complete game 192",
+ test_complete_reversi_game_192);
+
+ Test.add_func ("/Reversi/reversi/Complete game 193",
+ test_complete_reversi_game_193);
+
+ Test.add_func ("/Reversi/reversi/Complete game 194",
+ test_complete_reversi_game_194);
+
+ Test.add_func ("/Reversi/reversi/Complete game 195",
+ test_complete_reversi_game_195);
+
+ Test.add_func ("/Reversi/reversi/Complete game 196",
+ test_complete_reversi_game_196);
+
+ Test.add_func ("/Reversi/reversi/Complete game 197",
+ test_complete_reversi_game_197);
+
+ Test.add_func ("/Reversi/reversi/Complete game 198",
+ test_complete_reversi_game_198);
+
+ Test.add_func ("/Reversi/reversi/Complete game 199",
+ test_complete_reversi_game_199);
+
+ Test.add_func ("/Reversi/reversi/Complete game 200",
+ test_complete_reversi_game_200);
+
+ Test.add_func ("/Reversi/reversi/Complete game 201",
+ test_complete_reversi_game_201);
+
+ Test.add_func ("/Reversi/reversi/Complete game 202",
+ test_complete_reversi_game_202);
+
+ Test.add_func ("/Reversi/reversi/Complete game 203",
+ test_complete_reversi_game_203);
+
+ Test.add_func ("/Reversi/reversi/Complete game 204",
+ test_complete_reversi_game_204);
+
+ Test.add_func ("/Reversi/reversi/Complete game 205",
+ test_complete_reversi_game_205);
+
+ Test.add_func ("/Reversi/reversi/Complete game 206",
+ test_complete_reversi_game_206);
+
+ Test.add_func ("/Reversi/reversi/Complete game 207",
+ test_complete_reversi_game_207);
+
+ Test.add_func ("/Reversi/reversi/Complete game 208",
+ test_complete_reversi_game_208);
+
+ Test.add_func ("/Reversi/reversi/Complete game 209",
+ test_complete_reversi_game_209);
+
+ Test.add_func ("/Reversi/reversi/Complete game 210",
+ test_complete_reversi_game_210);
+
+ Test.add_func ("/Reversi/reversi/Complete game 211",
+ test_complete_reversi_game_211);
+
+ Test.add_func ("/Reversi/reversi/Complete game 212",
+ test_complete_reversi_game_212);
+
+ Test.add_func ("/Reversi/reversi/Complete game 213",
+ test_complete_reversi_game_213);
+
+ Test.add_func ("/Reversi/reversi/Complete game 214",
+ test_complete_reversi_game_214);
+
+ Test.add_func ("/Reversi/reversi/Complete game 215",
+ test_complete_reversi_game_215);
+
+ Test.add_func ("/Reversi/reversi/Complete game 216",
+ test_complete_reversi_game_216);
+
+ Test.add_func ("/Reversi/reversi/Complete game 217",
+ test_complete_reversi_game_217);
+
+ Test.add_func ("/Reversi/reversi/Complete game 218",
+ test_complete_reversi_game_218);
+
+ Test.add_func ("/Reversi/reversi/Complete game 219",
+ test_complete_reversi_game_219);
+
+ Test.add_func ("/Reversi/reversi/Complete game 220",
+ test_complete_reversi_game_220);
+
+ Test.add_func ("/Reversi/reversi/Complete game 221",
+ test_complete_reversi_game_221);
+
+ Test.add_func ("/Reversi/reversi/Complete game 222",
+ test_complete_reversi_game_222);
+
+ Test.add_func ("/Reversi/reversi/Complete game 223",
+ test_complete_reversi_game_223);
+
+ Test.add_func ("/Reversi/reversi/Complete game 224",
+ test_complete_reversi_game_224);
+
+ Test.add_func ("/Reversi/reversi/Complete game 225",
+ test_complete_reversi_game_225);
+
+ Test.add_func ("/Reversi/reversi/Complete game 226",
+ test_complete_reversi_game_226);
+
+ Test.add_func ("/Reversi/reversi/Complete game 227",
+ test_complete_reversi_game_227);
+
+ Test.add_func ("/Reversi/reversi/Complete game 228",
+ test_complete_reversi_game_228);
+
+ Test.add_func ("/Reversi/reversi/Complete game 229",
+ test_complete_reversi_game_229);
+
+ Test.add_func ("/Reversi/reversi/Complete game 230",
+ test_complete_reversi_game_230);
+
+ Test.add_func ("/Reversi/reversi/Complete game 231",
+ test_complete_reversi_game_231);
+
+ Test.add_func ("/Reversi/reversi/Complete game 232",
+ test_complete_reversi_game_232);
+
+ /* parallel start position */
+ Test.add_func ("/Reversi/reversi/Complete game 233",
+ test_complete_reversi_game_233);
+
+ Test.add_func ("/Reversi/reversi/Complete game 234",
+ test_complete_reversi_game_234);
+
+ Test.add_func ("/Reversi/reversi/Complete game 235",
+ test_complete_reversi_game_235);
+
+ Test.add_func ("/Reversi/reversi/Complete game 236",
+ test_complete_reversi_game_236);
+
+ Test.add_func ("/Reversi/reversi/Complete game 237",
+ test_complete_reversi_game_237);
+
+ Test.add_func ("/Reversi/reversi/Complete game 238",
+ test_complete_reversi_game_238);
+
+ Test.add_func ("/Reversi/reversi/Complete game 239",
+ test_complete_reversi_game_239);
+
+ Test.add_func ("/Reversi/reversi/Complete game 240",
+ test_complete_reversi_game_240);
+
+ Test.add_func ("/Reversi/reversi/Complete game 241",
+ test_complete_reversi_game_241);
+
+ Test.add_func ("/Reversi/reversi/Complete game 242",
+ test_complete_reversi_game_242);
+
+ Test.add_func ("/Reversi/reversi/Complete game 243",
+ test_complete_reversi_game_243);
+
+ Test.add_func ("/Reversi/reversi/Complete game 244",
+ test_complete_reversi_game_244);
+
+ Test.add_func ("/Reversi/reversi/Complete game 245",
+ test_complete_reversi_game_245);
+
+ Test.add_func ("/Reversi/reversi/Complete game 246",
+ test_complete_reversi_game_246);
+
+ Test.add_func ("/Reversi/reversi/Complete game 247",
+ test_complete_reversi_game_247);
+
+ Test.add_func ("/Reversi/reversi/Complete game 248",
+ test_complete_reversi_game_248);
+
+ Test.add_func ("/Reversi/reversi/Complete game 249",
+ test_complete_reversi_game_249);
+
+ Test.add_func ("/Reversi/reversi/Complete game 250",
+ test_complete_reversi_game_250);
+
+ Test.add_func ("/Reversi/reversi/Complete game 251",
+ test_complete_reversi_game_251);
+
+ Test.add_func ("/Reversi/reversi/Complete game 252",
+ test_complete_reversi_game_252);
+
+ Test.add_func ("/Reversi/reversi/Complete game 253",
+ test_complete_reversi_game_253);
+
+ Test.add_func ("/Reversi/reversi/Complete game 254",
+ test_complete_reversi_game_254);
+
+ Test.add_func ("/Reversi/reversi/Complete game 255",
+ test_complete_reversi_game_255);
+
+ Test.add_func ("/Reversi/reversi/Complete game 256",
+ test_complete_reversi_game_256);
+
+ Test.add_func ("/Reversi/reversi/Complete game 257",
+ test_complete_reversi_game_257);
+
+ Test.add_func ("/Reversi/reversi/Complete game 258",
+ test_complete_reversi_game_258);
+
+ Test.add_func ("/Reversi/reversi/Complete game 259",
+ test_complete_reversi_game_259);
+
+ Test.add_func ("/Reversi/reversi/Complete game 260",
+ test_complete_reversi_game_260);
+
+ Test.add_func ("/Reversi/reversi/Complete game 261",
+ test_complete_reversi_game_261);
+
+ Test.add_func ("/Reversi/reversi/Complete game 262",
+ test_complete_reversi_game_262);
+
+ Test.add_func ("/Reversi/reversi/Complete game 263",
+ test_complete_reversi_game_263);
+
+ Test.add_func ("/Reversi/reversi/Complete game 264",
+ test_complete_reversi_game_264);
+
+ Test.add_func ("/Reversi/reversi/Complete game 265",
+ test_complete_reversi_game_265);
+
+ Test.add_func ("/Reversi/reversi/Complete game 266",
+ test_complete_reversi_game_266);
+
+ Test.add_func ("/Reversi/reversi/Complete game 267",
+ test_complete_reversi_game_267);
+
+ Test.add_func ("/Reversi/reversi/Complete game 268",
+ test_complete_reversi_game_268);
+
+ Test.add_func ("/Reversi/reversi/Complete game 269",
+ test_complete_reversi_game_269);
+
+ Test.add_func ("/Reversi/reversi/Complete game 270",
+ test_complete_reversi_game_270);
+
+ Test.add_func ("/Reversi/reversi/Complete game 271",
+ test_complete_reversi_game_271);
+
+ Test.add_func ("/Reversi/reversi/Complete game 272",
+ test_complete_reversi_game_272);
+
+ Test.add_func ("/Reversi/reversi/Complete game 273",
+ test_complete_reversi_game_273);
+
+ Test.add_func ("/Reversi/reversi/Complete game 274",
+ test_complete_reversi_game_274);
+
+ Test.add_func ("/Reversi/reversi/Complete game 275",
+ test_complete_reversi_game_275);
+
+ Test.add_func ("/Reversi/reversi/Complete game 276",
+ test_complete_reversi_game_276);
+
+ Test.add_func ("/Reversi/reversi/Complete game 277",
+ test_complete_reversi_game_277);
+
+ Test.add_func ("/Reversi/reversi/Complete game 278",
+ test_complete_reversi_game_278);
+
+ Test.add_func ("/Reversi/reversi/Complete game 279",
+ test_complete_reversi_game_279);
+
+ Test.add_func ("/Reversi/reversi/Complete game 280",
+ test_complete_reversi_game_280);
+
+ Test.add_func ("/Reversi/reversi/Complete game 281",
+ test_complete_reversi_game_281);
+
+ Test.add_func ("/Reversi/reversi/Complete game 282",
+ test_complete_reversi_game_282);
+
+ Test.add_func ("/Reversi/reversi/Complete game 283",
+ test_complete_reversi_game_283);
+
+ Test.add_func ("/Reversi/reversi/Complete game 284",
+ test_complete_reversi_game_284);
+
+ Test.add_func ("/Reversi/reversi/Complete game 285",
+ test_complete_reversi_game_285);
+
+ Test.add_func ("/Reversi/reversi/Complete game 286",
+ test_complete_reversi_game_286);
+
+ Test.add_func ("/Reversi/reversi/Complete game 287",
+ test_complete_reversi_game_287);
+
+ Test.add_func ("/Reversi/reversi/Complete game 288",
+ test_complete_reversi_game_288);
+
+ Test.add_func ("/Reversi/reversi/Complete game 289",
+ test_complete_reversi_game_289);
+
+ Test.add_func ("/Reversi/reversi/Complete game 290",
+ test_complete_reversi_game_290);
+
+ Test.add_func ("/Reversi/reversi/Complete game 291",
+ test_complete_reversi_game_291);
+
+ Test.add_func ("/Reversi/reversi/Complete game 292",
+ test_complete_reversi_game_292);
+
+ Test.add_func ("/Reversi/reversi/Complete game 293",
+ test_complete_reversi_game_293);
+
+ Test.add_func ("/Reversi/reversi/Complete game 294",
+ test_complete_reversi_game_294);
+
+ Test.add_func ("/Reversi/reversi/Complete game 295",
+ test_complete_reversi_game_295);
+
+ Test.add_func ("/Reversi/reversi/Complete game 296",
+ test_complete_reversi_game_296);
+
+ Test.add_func ("/Reversi/reversi/Complete game 297",
+ test_complete_reversi_game_297);
+
+ Test.add_func ("/Reversi/reversi/Complete game 298",
+ test_complete_reversi_game_298);
+
+ Test.add_func ("/Reversi/reversi/Complete game 299",
+ test_complete_reversi_game_299);
+
+ Test.add_func ("/Reversi/reversi/Complete game 300",
+ test_complete_reversi_game_300);
+
+ Test.add_func ("/Reversi/reversi/Complete game 301",
+ test_complete_reversi_game_301);
+
+ Test.add_func ("/Reversi/reversi/Complete game 302",
+ test_complete_reversi_game_302);
+
+ Test.add_func ("/Reversi/reversi/Complete game 303",
+ test_complete_reversi_game_303);
+
+ Test.add_func ("/Reversi/reversi/Complete game 304",
+ test_complete_reversi_game_304);
+
+ Test.add_func ("/Reversi/reversi/Complete game 305",
+ test_complete_reversi_game_305);
+
+ Test.add_func ("/Reversi/reversi/Complete game 306",
+ test_complete_reversi_game_306);
+
+ Test.add_func ("/Reversi/reversi/Complete game 307",
+ test_complete_reversi_game_307);
+
+ Test.add_func ("/Reversi/reversi/Complete game 308",
+ test_complete_reversi_game_308);
+
+ Test.add_func ("/Reversi/reversi/Complete game 309",
+ test_complete_reversi_game_309);
+
+ Test.add_func ("/Reversi/reversi/Complete game 310",
+ test_complete_reversi_game_310);
+
+ Test.add_func ("/Reversi/reversi/Complete game 311",
+ test_complete_reversi_game_311);
+
+ Test.add_func ("/Reversi/reversi/Complete game 312",
+ test_complete_reversi_game_312);
+
+ Test.add_func ("/Reversi/reversi/Complete game 313",
+ test_complete_reversi_game_313);
+
+ Test.add_func ("/Reversi/reversi/Complete game 314",
+ test_complete_reversi_game_314);
+
+ Test.add_func ("/Reversi/reversi/Complete game 315",
+ test_complete_reversi_game_315);
+
+ Test.add_func ("/Reversi/reversi/Complete game 316",
+ test_complete_reversi_game_316);
+
+ Test.add_func ("/Reversi/reversi/Complete game 317",
+ test_complete_reversi_game_317);
+
+ Test.add_func ("/Reversi/reversi/Complete game 318",
+ test_complete_reversi_game_318);
+
+ Test.add_func ("/Reversi/reversi/Complete game 319",
+ test_complete_reversi_game_319);
+
+ Test.add_func ("/Reversi/reversi/Complete game 320",
+ test_complete_reversi_game_320);
+
+ Test.add_func ("/Reversi/reversi/Complete game 321",
+ test_complete_reversi_game_321);
+
+ Test.add_func ("/Reversi/reversi/Complete game 322",
+ test_complete_reversi_game_322);
+
+ Test.add_func ("/Reversi/reversi/Complete game 323",
+ test_complete_reversi_game_323);
+
+ Test.add_func ("/Reversi/reversi/Complete game 324",
+ test_complete_reversi_game_324);
+
+ Test.add_func ("/Reversi/reversi/Complete game 325",
+ test_complete_reversi_game_325);
+
+ Test.add_func ("/Reversi/reversi/Complete game 326",
+ test_complete_reversi_game_326);
+
+ Test.add_func ("/Reversi/reversi/Complete game 327",
+ test_complete_reversi_game_327);
+
+ Test.add_func ("/Reversi/reversi/Complete game 328",
+ test_complete_reversi_game_328);
+
+ Test.add_func ("/Reversi/reversi/Complete game 329",
+ test_complete_reversi_game_329);
+
+ Test.add_func ("/Reversi/reversi/Complete game 330",
+ test_complete_reversi_game_330);
+
+ Test.add_func ("/Reversi/reversi/Complete game 331",
+ test_complete_reversi_game_331);
+
+ Test.add_func ("/Reversi/reversi/Complete game 332",
+ test_complete_reversi_game_332);
+
+ Test.add_func ("/Reversi/reversi/Complete game 333",
+ test_complete_reversi_game_333);
+
+ Test.add_func ("/Reversi/reversi/Complete game 334",
+ test_complete_reversi_game_334);
+
+ Test.add_func ("/Reversi/reversi/Complete game 335",
+ test_complete_reversi_game_335);
+
+ Test.add_func ("/Reversi/reversi/Complete game 336",
+ test_complete_reversi_game_336);
+
+ Test.add_func ("/Reversi/reversi/Complete game 337",
+ test_complete_reversi_game_337);
+
+ Test.add_func ("/Reversi/reversi/Complete game 338",
+ test_complete_reversi_game_338);
+
+ Test.add_func ("/Reversi/reversi/Complete game 339",
+ test_complete_reversi_game_339);
+
+ Test.add_func ("/Reversi/reversi/Complete game 340",
+ test_complete_reversi_game_340);
+
+ Test.add_func ("/Reversi/reversi/Complete game 341",
+ test_complete_reversi_game_341);
+
+ Test.add_func ("/Reversi/reversi/Complete game 342",
+ test_complete_reversi_game_342);
+
+ Test.add_func ("/Reversi/reversi/Complete game 343",
+ test_complete_reversi_game_343);
+
+ Test.add_func ("/Reversi/reversi/Complete game 344",
+ test_complete_reversi_game_344);
+
+ Test.add_func ("/Reversi/reversi/Complete game 345",
+ test_complete_reversi_game_345);
+
+ Test.add_func ("/Reversi/reversi/Complete game 346",
+ test_complete_reversi_game_346);
+
+ Test.add_func ("/Reversi/reversi/Complete game 347",
+ test_complete_reversi_game_347);
+
+ Test.add_func ("/Reversi/reversi/Complete game 348",
+ test_complete_reversi_game_348);
+
+ Test.add_func ("/Reversi/reversi/Complete game 349",
+ test_complete_reversi_game_349);
+
+ Test.add_func ("/Reversi/reversi/Complete game 350",
+ test_complete_reversi_game_350);
+
+ Test.add_func ("/Reversi/reversi/Complete game 351",
+ test_complete_reversi_game_351);
+
+ Test.add_func ("/Reversi/reversi/Complete game 352",
+ test_complete_reversi_game_352);
+
+ Test.add_func ("/Reversi/reversi/Complete game 353",
+ test_complete_reversi_game_353);
+
+ Test.add_func ("/Reversi/reversi/Complete game 354",
+ test_complete_reversi_game_354);
+
+ Test.add_func ("/Reversi/reversi/Complete game 355",
+ test_complete_reversi_game_355);
+
+ Test.add_func ("/Reversi/reversi/Complete game 356",
+ test_complete_reversi_game_356);
+
+ Test.add_func ("/Reversi/reversi/Complete game 357",
+ test_complete_reversi_game_357);
+
+ Test.add_func ("/Reversi/reversi/Complete game 358",
+ test_complete_reversi_game_358);
+
+ Test.add_func ("/Reversi/reversi/Complete game 359",
+ test_complete_reversi_game_359);
+
+ Test.add_func ("/Reversi/reversi/Complete game 360",
+ test_complete_reversi_game_360);
+
+ Test.add_func ("/Reversi/reversi/Complete game 361",
+ test_complete_reversi_game_361);
+
+ Test.add_func ("/Reversi/reversi/Complete game 362",
+ test_complete_reversi_game_362);
+
+ Test.add_func ("/Reversi/reversi/Complete game 363",
+ test_complete_reversi_game_363);
+
+ Test.add_func ("/Reversi/reversi/Complete game 364",
+ test_complete_reversi_game_364);
+
+ Test.add_func ("/Reversi/reversi/Complete game 365",
+ test_complete_reversi_game_365);
+
+ Test.add_func ("/Reversi/reversi/Complete game 366",
+ test_complete_reversi_game_366);
+
+ Test.add_func ("/Reversi/reversi/Complete game 367",
+ test_complete_reversi_game_367);
+
+ Test.add_func ("/Reversi/reversi/Complete game 368",
+ test_complete_reversi_game_368);
+
+ Test.add_func ("/Reversi/reversi/Complete game 369",
+ test_complete_reversi_game_369);
+
+ Test.add_func ("/Reversi/reversi/Complete game 370",
+ test_complete_reversi_game_370);
+
+ Test.add_func ("/Reversi/reversi/Complete game 371",
+ test_complete_reversi_game_371);
+
+ Test.add_func ("/Reversi/reversi/Complete game 372",
+ test_complete_reversi_game_372);
+
+ Test.add_func ("/Reversi/reversi/Complete game 373",
+ test_complete_reversi_game_373);
+
+ Test.add_func ("/Reversi/reversi/Complete game 374",
+ test_complete_reversi_game_374);
+
+ Test.add_func ("/Reversi/reversi/Complete game 375",
+ test_complete_reversi_game_375);
+
+ Test.add_func ("/Reversi/reversi/Complete game 376",
+ test_complete_reversi_game_376);
+
+ Test.add_func ("/Reversi/reversi/Complete game 377",
+ test_complete_reversi_game_377);
+
+ Test.add_func ("/Reversi/reversi/Complete game 378",
+ test_complete_reversi_game_378);
+
+ Test.add_func ("/Reversi/reversi/Complete game 379",
+ test_complete_reversi_game_379);
+
+ Test.add_func ("/Reversi/reversi/Complete game 380",
+ test_complete_reversi_game_380);
+
+ Test.add_func ("/Reversi/reversi/Complete game 381",
+ test_complete_reversi_game_381);
+
+ Test.add_func ("/Reversi/reversi/Complete game 382",
+ test_complete_reversi_game_382);
+
+ Test.add_func ("/Reversi/reversi/Complete game 383",
+ test_complete_reversi_game_383);
+
+ Test.add_func ("/Reversi/reversi/Complete game 384",
+ test_complete_reversi_game_384);
+
+ Test.add_func ("/Reversi/reversi/Complete game 385",
+ test_complete_reversi_game_385);
+
+ Test.add_func ("/Reversi/reversi/Complete game 386",
+ test_complete_reversi_game_386);
+
+ Test.add_func ("/Reversi/reversi/Complete game 387",
+ test_complete_reversi_game_387);
+
+ Test.add_func ("/Reversi/reversi/Complete game 388",
+ test_complete_reversi_game_388);
+
+ Test.add_func ("/Reversi/reversi/Complete game 389",
+ test_complete_reversi_game_389);
+
+ Test.add_func ("/Reversi/reversi/Complete game 390",
+ test_complete_reversi_game_390);
+
+ Test.add_func ("/Reversi/reversi/Complete game 391",
+ test_complete_reversi_game_391);
+
+ Test.add_func ("/Reversi/reversi/Complete game 392",
+ test_complete_reversi_game_392);
+
+ Test.add_func ("/Reversi/reversi/Complete game 393",
+ test_complete_reversi_game_393);
+
+ Test.add_func ("/Reversi/reversi/Complete game 394",
+ test_complete_reversi_game_394);
+
+ Test.add_func ("/Reversi/reversi/Complete game 395",
+ test_complete_reversi_game_395);
+
+ Test.add_func ("/Reversi/reversi/Complete game 396",
+ test_complete_reversi_game_396);
+
+ Test.add_func ("/Reversi/reversi/Complete game 397",
+ test_complete_reversi_game_397);
+
+ Test.add_func ("/Reversi/reversi/Complete game 398",
+ test_complete_reversi_game_398);
+
+ Test.add_func ("/Reversi/reversi/Complete game 399",
+ test_complete_reversi_game_399);
+
+ Test.add_func ("/Reversi/reversi/Complete game 400",
+ test_complete_reversi_game_400);
+
+ Test.add_func ("/Reversi/reversi/Complete game 401",
+ test_complete_reversi_game_401);
+
+ Test.add_func ("/Reversi/reversi/Complete game 402",
+ test_complete_reversi_game_402);
+
+ Test.add_func ("/Reversi/reversi/Complete game 403",
+ test_complete_reversi_game_403);
+
+ Test.add_func ("/Reversi/reversi/Complete game 404",
+ test_complete_reversi_game_404);
+
+ Test.add_func ("/Reversi/reversi/Complete game 405",
+ test_complete_reversi_game_405);
+
+ Test.add_func ("/Reversi/reversi/Complete game 406",
+ test_complete_reversi_game_406);
+
+ Test.add_func ("/Reversi/reversi/Complete game 407",
+ test_complete_reversi_game_407);
+
+ Test.add_func ("/Reversi/reversi/Complete game 408",
+ test_complete_reversi_game_408);
+
+ Test.add_func ("/Reversi/reversi/Complete game 409",
+ test_complete_reversi_game_409);
+
+ Test.add_func ("/Reversi/reversi/Complete game 410",
+ test_complete_reversi_game_410);
+
+ Test.add_func ("/Reversi/reversi/Complete game 411",
+ test_complete_reversi_game_411);
+
+ Test.add_func ("/Reversi/reversi/Complete game 412",
+ test_complete_reversi_game_412);
+
+ Test.add_func ("/Reversi/reversi/Complete game 413",
+ test_complete_reversi_game_413);
+
+ Test.add_func ("/Reversi/reversi/Complete game 414",
+ test_complete_reversi_game_414);
+
+ Test.add_func ("/Reversi/reversi/Complete game 415",
+ test_complete_reversi_game_415);
+
+ Test.add_func ("/Reversi/reversi/Complete game 416",
+ test_complete_reversi_game_416);
+
+ Test.add_func ("/Reversi/reversi/Complete game 417",
+ test_complete_reversi_game_417);
+
+ Test.add_func ("/Reversi/reversi/Complete game 418",
+ test_complete_reversi_game_418);
+
+ Test.add_func ("/Reversi/reversi/Complete game 419",
+ test_complete_reversi_game_419);
+
+ Test.add_func ("/Reversi/reversi/Complete game 420",
+ test_complete_reversi_game_420);
+
+ Test.add_func ("/Reversi/reversi/Complete game 421",
+ test_complete_reversi_game_421);
+
+ Test.add_func ("/Reversi/reversi/Complete game 422",
+ test_complete_reversi_game_422);
+
+ Test.add_func ("/Reversi/reversi/Complete game 423",
+ test_complete_reversi_game_423);
+
+ Test.add_func ("/Reversi/reversi/Complete game 424",
+ test_complete_reversi_game_424);
+
+ Test.add_func ("/Reversi/reversi/Complete game 425",
+ test_complete_reversi_game_425);
+
+ Test.add_func ("/Reversi/reversi/Complete game 426",
+ test_complete_reversi_game_426);
+
+ Test.add_func ("/Reversi/reversi/Complete game 427",
+ test_complete_reversi_game_427);
+
+ Test.add_func ("/Reversi/reversi/Complete game 428",
+ test_complete_reversi_game_428);
+
+ Test.add_func ("/Reversi/reversi/Complete game 429",
+ test_complete_reversi_game_429);
+
+ Test.add_func ("/Reversi/reversi/Complete game 430",
+ test_complete_reversi_game_430);
+
+ Test.add_func ("/Reversi/reversi/Complete game 431",
+ test_complete_reversi_game_431);
+
+ Test.add_func ("/Reversi/reversi/Complete game 432",
+ test_complete_reversi_game_432);
+
+ Test.add_func ("/Reversi/reversi/Complete game 433",
+ test_complete_reversi_game_433);
+
+ Test.add_func ("/Reversi/reversi/Complete game 434",
+ test_complete_reversi_game_434);
+
+ Test.add_func ("/Reversi/reversi/Complete game 435",
+ test_complete_reversi_game_435);
+
+ Test.add_func ("/Reversi/reversi/Complete game 436",
+ test_complete_reversi_game_436);
+
+ Test.add_func ("/Reversi/reversi/Complete game 437",
+ test_complete_reversi_game_437);
+
+ Test.add_func ("/Reversi/reversi/Complete game 438",
+ test_complete_reversi_game_438);
+
+ Test.add_func ("/Reversi/reversi/Complete game 439",
+ test_complete_reversi_game_439);
+
+ Test.add_func ("/Reversi/reversi/Complete game 440",
+ test_complete_reversi_game_440);
+
+ Test.add_func ("/Reversi/reversi/Complete game 441",
+ test_complete_reversi_game_441);
+
+ Test.add_func ("/Reversi/reversi/Complete game 442",
+ test_complete_reversi_game_442);
+
+ Test.add_func ("/Reversi/reversi/Complete game 443",
+ test_complete_reversi_game_443);
+
+ Test.add_func ("/Reversi/reversi/Complete game 444",
+ test_complete_reversi_game_444);
+
+ Test.add_func ("/Reversi/reversi/Complete game 445",
+ test_complete_reversi_game_445);
+
+ Test.add_func ("/Reversi/reversi/Complete game 446",
+ test_complete_reversi_game_446);
+
+ Test.add_func ("/Reversi/reversi/Complete game 447",
+ test_complete_reversi_game_447);
+
+ Test.add_func ("/Reversi/reversi/Complete game 448",
+ test_complete_reversi_game_448);
+
+ Test.add_func ("/Reversi/reversi/Complete game 449",
+ test_complete_reversi_game_449);
+
+ Test.add_func ("/Reversi/reversi/Complete game 450",
+ test_complete_reversi_game_450);
+
+ Test.add_func ("/Reversi/reversi/Complete game 451",
+ test_complete_reversi_game_451);
+
+ Test.add_func ("/Reversi/reversi/Complete game 452",
+ test_complete_reversi_game_452);
+
+ Test.add_func ("/Reversi/reversi/Complete game 453",
+ test_complete_reversi_game_453);
+
+ Test.add_func ("/Reversi/reversi/Complete game 454",
+ test_complete_reversi_game_454);
+
+ Test.add_func ("/Reversi/reversi/Complete game 455",
+ test_complete_reversi_game_455);
+
+ Test.add_func ("/Reversi/reversi/Complete game 456",
+ test_complete_reversi_game_456);
+
+ Test.add_func ("/Reversi/reversi/Complete game 457",
+ test_complete_reversi_game_457);
+
+ Test.add_func ("/Reversi/reversi/Complete game 458",
+ test_complete_reversi_game_458);
+
+ Test.add_func ("/Reversi/reversi/Complete game 459",
+ test_complete_reversi_game_459);
+
+ Test.add_func ("/Reversi/reversi/Complete game 460",
+ test_complete_reversi_game_460);
+
+ Test.add_func ("/Reversi/reversi/Complete game 461",
+ test_complete_reversi_game_461);
+
+ Test.add_func ("/Reversi/reversi/Complete game 462",
+ test_complete_reversi_game_462);
+
+ Test.add_func ("/Reversi/reversi/Complete game 463",
+ test_complete_reversi_game_463);
+
+ Test.add_func ("/Reversi/reversi/Complete game 464",
+ test_complete_reversi_game_464);
+
+ Test.add_func ("/Reversi/reversi/Complete game 465",
+ test_complete_reversi_game_465);
+
+ Test.add_func ("/Reversi/reversi/Complete game 466",
+ test_complete_reversi_game_466);
+
+ Test.add_func ("/Reversi/reversi/Complete game 467",
+ test_complete_reversi_game_467);
+
+ Test.add_func ("/Reversi/reversi/Complete game 468",
+ test_complete_reversi_game_468);
+
+ Test.add_func ("/Reversi/reversi/Complete game 469",
+ test_complete_reversi_game_469);
+
+ Test.add_func ("/Reversi/reversi/Complete game 470",
+ test_complete_reversi_game_470);
+
+ Test.add_func ("/Reversi/reversi/Complete game 471",
+ test_complete_reversi_game_471);
+
+ Test.add_func ("/Reversi/reversi/Complete game 472",
+ test_complete_reversi_game_472);
+
+ Test.add_func ("/Reversi/reversi/Complete game 473",
+ test_complete_reversi_game_473);
+
+ Test.add_func ("/Reversi/reversi/Complete game 474",
+ test_complete_reversi_game_474);
+
+ Test.add_func ("/Reversi/reversi/Complete game 475",
+ test_complete_reversi_game_475);
+
+ Test.add_func ("/Reversi/reversi/Complete game 476",
+ test_complete_reversi_game_476);
+
+ Test.add_func ("/Reversi/reversi/Complete game 477",
+ test_complete_reversi_game_477);
+
+ Test.add_func ("/Reversi/reversi/Complete game 478",
+ test_complete_reversi_game_478);
+
+ Test.add_func ("/Reversi/reversi/Complete game 479",
+ test_complete_reversi_game_479);
+
+ Test.add_func ("/Reversi/reversi/Complete game 480",
+ test_complete_reversi_game_480);
+
+ Test.add_func ("/Reversi/reversi/Complete game 481",
+ test_complete_reversi_game_481);
+
+ Test.add_func ("/Reversi/reversi/Complete game 482",
+ test_complete_reversi_game_482);
+
+ Test.add_func ("/Reversi/reversi/Complete game 483",
+ test_complete_reversi_game_483);
+
+ Test.add_func ("/Reversi/reversi/Complete game 484",
+ test_complete_reversi_game_484);
+
+ Test.add_func ("/Reversi/reversi/Complete game 485",
+ test_complete_reversi_game_485);
+
+ Test.add_func ("/Reversi/reversi/Complete game 486",
+ test_complete_reversi_game_486);
+
+ Test.add_func ("/Reversi/reversi/Complete game 487",
+ test_complete_reversi_game_487);
+
+ Test.add_func ("/Reversi/reversi/Complete game 488",
+ test_complete_reversi_game_488);
+
+ Test.add_func ("/Reversi/reversi/Complete game 489",
+ test_complete_reversi_game_489);
+
+ Test.add_func ("/Reversi/reversi/Complete game 490",
+ test_complete_reversi_game_490);
+
+ Test.add_func ("/Reversi/reversi/Complete game 491",
+ test_complete_reversi_game_491);
+
+ Test.add_func ("/Reversi/reversi/Complete game 492",
+ test_complete_reversi_game_492);
+
+ Test.add_func ("/Reversi/reversi/Complete game 493",
+ test_complete_reversi_game_493);
+
+ Test.add_func ("/Reversi/reversi/Complete game 494",
+ test_complete_reversi_game_494);
+
+ Test.add_func ("/Reversi/reversi/Complete game 495",
+ test_complete_reversi_game_495);
+ }
+
+ /*\
+ * * perfs tests
+ \*/
+
+ private static inline void test_complete_reversi_game_1 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . D L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_2 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L L .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_3 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_4 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_5 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_6 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . D . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_7 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_8 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_9 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L L .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_10 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_11 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_12 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_13 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_14 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L L L .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_15 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_16 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_17 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_18 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_19 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_20 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L L L .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_21 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_22 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_23 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_24 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_25 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L L L L .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_26 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_27 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_28 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_29 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . L . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_30 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_31 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_32 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_33 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_34 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . L L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_35 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_36 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_37 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_38 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ }
+
+ private static inline void test_complete_reversi_game_39 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_40 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . L L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reversi_game_41 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 5));
+ }
+
+ private static inline void test_complete_reversi_game_42 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_43 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_44 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_45 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . D L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_46 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . D L . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_47 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . D L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_48 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . L L L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_49 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D D L D . .",
+ /* 5 */ " . . . L . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_50 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . D D L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_51 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . L . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_52 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . L . L D . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_53 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_54 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_55 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_56 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ }
+
+ private static inline void test_complete_reversi_game_57 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_58 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_59 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_60 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_61 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_62 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L D .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_63 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_64 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L D D .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_65 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_66 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L D D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_67 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . D D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_68 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_69 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_70 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L L . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_71 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_72 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_73 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_74 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_75 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L L . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_76 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_77 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_78 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_79 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_80 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L L L .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_81 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_82 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 5));
+ }
+
+ private static inline void test_complete_reversi_game_83 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_84 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . D .",
+ /* 3 */ " . . . L L D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_85 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_86 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . L . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_87 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . D . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_88 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_89 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . L . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_90 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_91 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_92 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_93 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_94 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_95 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . L L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ }
+
+ private static inline void test_complete_reversi_game_96 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . L . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_97 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_98 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_99 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_100 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . L L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_101 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . D . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_102 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . D D L . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_103 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_104 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_105 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . D . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_106 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . D L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_107 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D D D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_108 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . D D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_109 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . D L D . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_110 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_111 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_112 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . L . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_113 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . L . L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_114 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_115 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_116 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_117 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_118 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_119 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_120 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_121 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_122 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reversi_game_123 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_124 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_125 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ }
+
+ private static inline void test_complete_reversi_game_126 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_127 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_128 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . L . . . . .",
+ /* 2 */ " . . . L L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_129 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_130 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_131 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_132 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . L .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_133 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . L .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_134 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_135 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_136 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L . . .",
+ /* 2 */ " . . . D L D . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_137 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D D D . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_138 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D D D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_139 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L D . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_140 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . D D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_141 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . D D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_142 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . D D . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_143 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . L D D . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_144 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . L . . D . .",
+ /* 2 */ " . . . L D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_145 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_146 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_147 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_148 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_149 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_150 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_151 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_152 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_153 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_154 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_155 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_156 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_157 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_158 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_159 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_160 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_161 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_162 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_163 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 2));
+ }
+
+ private static inline void test_complete_reversi_game_164 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_165 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_166 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_167 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_168 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_169 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_170 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . L L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_171 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_172 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_173 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_174 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_175 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . . L L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_176 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_177 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_178 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . D D D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_179 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . D D D L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_180 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . D D D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_181 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . L . . . .",
+ /* 2 */ " . D D L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_182 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . D D D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_183 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . L . . . . . .",
+ /* 2 */ " . D L D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_184 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_185 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_186 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L L . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_187 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . L L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_188 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_189 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_190 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_191 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L L . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_192 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . L L L L . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_193 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . D L . L .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_194 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . L .",
+ /* 3 */ " . . D D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_195 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L D D . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_196 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L . . .",
+ /* 3 */ " . . D L D D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_197 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L L L .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_198 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L D . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_199 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L D . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_200 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L D . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_201 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_202 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_203 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . L . D . . .",
+ /* 3 */ " . . D L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_204 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . L L L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 2));
+ }
+
+ private static inline void test_complete_reversi_game_205 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_206 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_207 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_208 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_209 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_210 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_211 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_212 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_213 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_214 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_215 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_216 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_217 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_218 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_219 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_220 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_221 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_222 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_223 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_224 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_225 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_226 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_227 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_228 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_229 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_230 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L L D . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_231 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . L L L D . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_232 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_233 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . L D .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_234 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_235 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_236 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_237 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_238 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_239 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_240 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_241 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . L .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_242 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_243 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_244 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_245 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_246 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . L L . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_247 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . D D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_248 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_249 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . D D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_250 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_251 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_252 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_253 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_254 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_255 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reversi_game_256 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reversi_game_257 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 0));
+ }
+
+ private static inline void test_complete_reversi_game_258 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . L . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_259 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_260 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_261 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_262 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_263 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_264 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . L . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_265 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D L . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_266 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L L L . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_267 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_268 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_269 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_270 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_271 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_272 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . D D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_273 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_274 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_275 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_276 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . D L . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_277 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_278 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . D D D L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_279 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . D D D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_280 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_281 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . L . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_282 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_283 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_284 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . L . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_285 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L . L . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_286 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_287 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_288 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L L L . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_289 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . . . L . .",
+ /* 6 */ " . . . . . . L .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ }
+
+ private static inline void test_complete_reversi_game_290 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_291 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_292 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_293 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_294 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . D L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_295 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . D L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_296 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . L L L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_297 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . D L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_298 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_299 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . L L L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_300 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_301 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_302 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_303 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_304 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_305 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_306 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . L . D .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ }
+
+ private static inline void test_complete_reversi_game_307 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_308 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . L . D .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ }
+
+ private static inline void test_complete_reversi_game_309 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reversi_game_310 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_311 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . D .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_312 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . D .",
+ /* 4 */ " . . . L L L L .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_313 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_314 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_315 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_316 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_317 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_318 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . D .",
+ /* 4 */ " . . . L L D . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_319 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . L L . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_320 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . D D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_321 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . L D . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_322 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D L . .",
+ /* 5 */ " . . . . D D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_323 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_324 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reversi_game_325 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_326 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_327 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_328 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_329 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_330 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_331 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_332 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_333 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ }
+
+ private static inline void test_complete_reversi_game_334 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_335 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_336 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_337 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_338 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_339 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_340 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_341 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . D L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_342 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_343 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_344 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . L . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_345 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D L . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_346 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . D L . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_347 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L L L . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_348 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_349 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_350 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_351 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_352 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_353 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . D D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_354 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ }
+
+ private static inline void test_complete_reversi_game_355 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_356 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . L L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ }
+
+ private static inline void test_complete_reversi_game_357 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_358 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_359 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_360 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . D L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_361 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D D L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_362 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . D D D L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_363 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . D D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_364 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_365 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . L . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_366 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_367 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . D L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_368 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . L . D D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_369 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_370 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_371 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . D L . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_372 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . L L L . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_373 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_374 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . . . D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_375 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L L L . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_376 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_377 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D . . . . .",
+ /* 2 */ " . . . D . L . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_378 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . D L . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_379 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_380 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reversi_game_381 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_382 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_383 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . . D . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_384 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_385 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_386 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_387 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_388 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D D . L .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_389 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_390 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_391 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L L L .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_392 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L D . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_393 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_394 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_395 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L D . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_396 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_397 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . L D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_398 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_399 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_400 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . L . D . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_401 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_402 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_403 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_404 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_405 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . L L L . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_406 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_407 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_408 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . L L L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_409 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . L D . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_410 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . L D . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_411 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . L D . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_412 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ }
+
+ private static inline void test_complete_reversi_game_413 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_414 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_415 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_416 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L . D . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_417 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_418 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_419 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_420 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_421 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_422 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_423 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_424 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_425 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_426 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_427 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_428 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_429 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_430 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_431 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D L . . . .",
+ /* 6 */ " . . . . L . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_432 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_433 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . L L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_434 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L D L . . .",
+ /* 5 */ " . . D D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_435 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_436 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_437 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_438 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_439 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_440 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_441 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . D . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_442 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . D . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reversi_game_443 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . D . D L . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_444 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . D . D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_445 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . D . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_446 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . D . D D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_447 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . D . L D . . .",
+ /* 4 */ " . . D L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_448 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . D . D D . . .",
+ /* 4 */ " . L L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ }
+
+ private static inline void test_complete_reversi_game_449 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_450 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_451 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ }
+
+ private static inline void test_complete_reversi_game_452 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L L L L .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 7));
+ }
+
+ private static inline void test_complete_reversi_game_453 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_454 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ }
+
+ private static inline void test_complete_reversi_game_455 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D D L . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_456 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L L L . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . . D D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_457 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . . L D . . .",
+ /* 6 */ " . . . L . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_458 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L L L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_459 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_460 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L D . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_461 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L . . .",
+ /* 3 */ " . . D D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_462 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . D D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . . L . . . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_463 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . . . . .",
+ /* 3 */ " . . L D D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . . D . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_464 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . L D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ }
+
+ private static inline void test_complete_reversi_game_465 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_466 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 6));
+ }
+
+ private static inline void test_complete_reversi_game_467 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_468 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D D L . .",
+ /* 5 */ " . . D . . . L .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_469 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L D . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_470 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . L D D D . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_471 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D D D . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_472 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L D D . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_473 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . L .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_474 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . L .",
+ /* 3 */ " . . . D D L . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_475 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_476 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L . . .",
+ /* 3 */ " . . . L D D . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ }
+
+ private static inline void test_complete_reversi_game_477 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L L L .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ }
+
+ private static inline void test_complete_reversi_game_478 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 7));
+ }
+
+ private static inline void test_complete_reversi_game_479 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . L . L D . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_480 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . L D . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ }
+
+ private static inline void test_complete_reversi_game_481 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ }
+
+ private static inline void test_complete_reversi_game_482 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . L L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_483 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . L . D . . .",
+ /* 3 */ " . . . L L . . .",
+ /* 4 */ " . . . D L . . .",
+ /* 5 */ " . . D . . . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 7));
+ }
+
+ private static inline void test_complete_reversi_game_484 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . D . .",
+ /* 2 */ " . . . . D . . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . . L L . . .",
+ /* 5 */ " . . L . . . . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 2, 4));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 5));
+ }
+
+ private static inline void test_complete_reversi_game_485 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_486 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_487 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 0));
+ }
+
+ private static inline void test_complete_reversi_game_488 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . . D . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_489 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . . L . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ }
+
+ private static inline void test_complete_reversi_game_490 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . L . . D . .",
+ /* 6 */ " . L . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 4, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 2, 0));
+ }
+
+ private static inline void test_complete_reversi_game_491 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . L . . .",
+ /* 6 */ " . . . . . L . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 6, 6));
+ }
+
+ private static inline void test_complete_reversi_game_492 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . . . .",
+ /* 3 */ " . . . D D . . .",
+ /* 4 */ " . . L L L L . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_493 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . . L . .",
+ /* 3 */ " . . . D L . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 6, 1));
+ }
+
+ private static inline void test_complete_reversi_game_494 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . . L . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 6, 0));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 2));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 0, 7));
+ }
+
+ private static inline void test_complete_reversi_game_495 ()
+ {
+ /* 0 1 2 3 4 5 6 7 */
+ string [] board = {/* 0 */ " . . . . . . . .",
+ /* 1 */ " . . . . . . . .",
+ /* 2 */ " . . . L . . . .",
+ /* 3 */ " . . . L D . . .",
+ /* 4 */ " . . L L D . . .",
+ /* 5 */ " . . D . D . . .",
+ /* 6 */ " . . . . . . . .",
+ /* 7 */ " . . . . . . . ."};
+
+ Game game = new Game.from_strings (board, Player.DARK, /* reverse */ false);
+ ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 1, /* fixed heuristic */ true);
+
+ assert_true (ai_move (ai, 2, 1));
+ assert_true (ai_move (ai, 2, 6));
+ assert_true (ai_move (ai, 2, 2));
+ assert_true (ai_move (ai, 5, 6));
+ assert_true (ai_move (ai, 4, 6));
+ assert_true (ai_move (ai, 5, 2));
+ assert_true (ai_move (ai, 5, 4));
+ assert_true (ai_move (ai, 4, 2));
+ assert_true (ai_move (ai, 6, 2));
+ assert_true (ai_move (ai, 3, 1));
+ assert_true (ai_move (ai, 2, 0));
+ assert_true (ai_move (ai, 1, 2));
+ assert_true (ai_move (ai, 1, 3));
+ assert_true (ai_move (ai, 1, 4));
+ assert_true (ai_move (ai, 0, 2));
+ assert_true (ai_move (ai, 4, 0));
+ assert_true (ai_move (ai, 2, 3));
+ assert_true (ai_move (ai, 5, 1));
+ assert_true (ai_move (ai, 5, 3));
+ assert_true (ai_move (ai, 7, 2));
+ assert_true (ai_move (ai, 5, 0));
+ assert_true (ai_move (ai, 3, 0));
+ assert_true (ai_move (ai, 4, 1));
+ assert_true (ai_move (ai, 6, 3));
+ assert_true (ai_move (ai, 6, 4));
+ assert_true (ai_move (ai, 0, 3));
+ assert_true (ai_move (ai, 2, 7));
+ assert_true (ai_move (ai, 0, 1));
+ assert_true (ai_move (ai, 0, 5));
+ assert_true (ai_move (ai, 1, 5));
+ assert_true (ai_move (ai, 7, 3));
+ assert_true (ai_move (ai, 3, 5));
+ assert_true (ai_move (ai, 7, 1));
+ assert_true (ai_move (ai, 5, 7));
+ assert_true (ai_move (ai, 4, 7));
+ assert_true (ai_move (ai, 5, 5));
+ assert_true (ai_move (ai, 6, 5));
+ assert_true (ai_move (ai, 3, 7));
+ assert_true (ai_move (ai, 6, 7));
+ assert_true (ai_move (ai, 3, 6));
+ assert_true (ai_move (ai, 6, 1));
+ assert_true (ai_move (ai, 7, 4));
+ assert_true (ai_move (ai, 7, 5));
+ assert_true (ai_move (ai, 1, 1));
+ assert_true (ai_move (ai, 0, 4));
+ assert_true (ai_move (ai, 0, 6));
+ assert_true (ai_move (ai, 1, 6));
+ assert_true (ai_move (ai, 1, 0));
+ assert_true (ai_move (ai, 0, 0));
+ assert_true (ai_move (ai, 0, 7));
+ assert_true (ai_move (ai, 1, 7));
+ assert_true (ai_move (ai, 7, 7));
+ assert_true (game.pass ());
+ assert_true (ai_move (ai, 7, 6));
+ assert_true (ai_move (ai, 6, 6));
+ assert_true (ai_move (ai, 7, 0));
+ assert_true (ai_move (ai, 6, 0));
+ }
+}
diff --git a/src/test-iagno.vala b/src/test-iagno.vala
index 432d5fd..18e41ea 100644
--- a/src/test-iagno.vala
+++ b/src/test-iagno.vala
@@ -1,5 +1,5 @@
-/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
+/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+
This file is part of GNOME Reversi, also known as Iagno.
Copyright 2013, 2014 Michael Catanzaro
@@ -19,57 +19,40 @@
along with GNOME Reversi. If not, see <https://www.gnu.org/licenses/>.
*/
-private class TestIagno : Object
+namespace TestReversi
{
private static int main (string [] args)
{
Test.init (ref args);
- Test.add_func ("/Iagno/test tests",
- test_tests);
+ Test.add_func ("/Reversi/test tests",
+ test_tests);
- // if meson is configured with -Dperfs_tests=true,
- // both tests are performed, else only short_tests
- if (Test.perf ())
- perfs_tests ();
- else
- short_tests ();
+ short_tests ();
return Test.run ();
}
private static void short_tests ()
{
- Test.add_func ("/Iagno/Pass then Undo",
+ Test.add_func ("/Reversi/Pass then Undo",
test_undo_after_pass);
- Test.add_func ("/Iagno/Undo at Start",
+ Test.add_func ("/Reversi/Undo at Start",
test_undo_at_start);
- Test.add_func ("/Iagno/Current Color after Pass",
+ Test.add_func ("/Reversi/Current Color after Pass",
test_current_color_after_pass);
- Test.add_func ("/Iagno/AI Search 1",
+ Test.add_func ("/Reversi/AI Search 1",
test_ai_search_1);
- Test.add_func ("/Iagno/AI Search 2",
+ Test.add_func ("/Reversi/AI Search 2",
test_ai_search_2);
- Test.add_func ("/Iagno/AI Search 3",
+ Test.add_func ("/Reversi/AI Search 3",
test_ai_search_3);
- Test.add_func ("/Iagno/AI Search 4",
+ Test.add_func ("/Reversi/AI Search 4",
test_ai_search_4);
- Test.add_func ("/Iagno/AI Search 5",
+ Test.add_func ("/Reversi/AI Search 5",
test_ai_search_5);
}
- private static void perfs_tests ()
- {
- Test.add_func ("/Iagno/Complete game 1",
- test_complete_game_1);
- Test.add_func ("/Iagno/Complete game 2",
- test_complete_game_2);
- Test.add_func ("/Iagno/Complete game 3",
- test_complete_game_3);
- Test.add_func ("/Iagno/Complete game 4",
- test_complete_game_4);
- }
-
private static void test_tests ()
{
assert_true (1 + 1 == 2);
@@ -116,13 +99,14 @@ private class TestIagno : Object
assert_true (game.number_of_moves == 2);
game.undo (2);
assert_true (game.number_of_moves == 0);
- assert_true (game.to_string ().strip () == string.joinv ("\n", board).strip ());
+ string? [] board2 = (string? []) board; // TODO report bug
+ assert_true (game.to_string ().strip () == string.joinv ("\n", board2).strip ());
assert_true (game.place_tile (7, 2));
assert_true (game.number_of_moves == 1);
assert_true (!game.current_player_can_move);
game.undo (1);
assert_true (game.number_of_moves == 0);
- assert_true (game.to_string ().strip () == string.joinv ("\n", board).strip ());
+ assert_true (game.to_string ().strip () == string.joinv ("\n", board2).strip ());
}
private static void test_undo_at_start ()
@@ -232,303 +216,4 @@ private class TestIagno : Object
assert_true (ai_move (ai, 0, 5));
/* didn't crash */
}
-
- /*\
- * * perfs tests
- \*/
-
- private static void test_complete_game_1 ()
- {
- /* human starts 0 1 2 3 4 5 6 7 */
- string [] board = {/* 0 */ " . . . . . . . .",
- /* 1 */ " . . . L . . . .",
- /* 2 */ " . . . . L . . .",
- /* 3 */ " . . . L D L . .",
- /* 4 */ " . . . D D D . .",
- /* 5 */ " . . . . . . . .",
- /* 6 */ " . . . . . . . .",
- /* 7 */ " . . . . . . . ." };
-
- Game game = new Game.from_strings (board, Player.DARK);
- ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 6);
-
- assert_true (game.place_tile (4, 1));
- assert_true (ai_move (ai, 5, 5));
- assert_true (game.place_tile (4, 5));
- assert_true (ai_move (ai, 3, 5));
- assert_true (game.place_tile (2, 5));
- assert_true (ai_move (ai, 2, 4));
- assert_true (game.place_tile (4, 6));
- assert_true (ai_move (ai, 2, 6));
- assert_true (game.place_tile (1, 4));
- assert_true (ai_move (ai, 0, 4));
- assert_true (game.place_tile (2, 3));
- assert_true (ai_move (ai, 1, 3));
- assert_true (game.place_tile (1, 5));
- assert_true (ai_move (ai, 2, 2));
- assert_true (game.place_tile (3, 2));
- assert_true (ai_move (ai, 5, 2));
- assert_true (game.place_tile (6, 4));
- assert_true (ai_move (ai, 5, 6));
- assert_true (game.place_tile (3, 0));
- assert_true (ai_move (ai, 0, 5));
- assert_true (game.place_tile (3, 6));
- assert_true (ai_move (ai, 5, 7));
- assert_true (game.place_tile (0, 3));
- assert_true (ai_move (ai, 0, 2));
- assert_true (game.place_tile (6, 5));
- assert_true (ai_move (ai, 1, 2));
- assert_true (game.place_tile (3, 7));
- assert_true (ai_move (ai, 2, 7));
- assert_true (game.place_tile (4, 7));
- assert_true (ai_move (ai, 6, 6));
- assert_true (game.place_tile (2, 1));
- assert_true (ai_move (ai, 2, 0));
- assert_true (game.place_tile (1, 0));
- assert_true (ai_move (ai, 1, 1));
- assert_true (game.place_tile (6, 2));
- assert_true (ai_move (ai, 4, 0));
- assert_true (game.place_tile (5, 0));
- assert_true (ai_move (ai, 7, 3));
- assert_true (game.place_tile (6, 3));
- assert_true (ai_move (ai, 7, 2));
- assert_true (game.place_tile (5, 1));
- assert_true (ai_move (ai, 6, 1));
- assert_true (game.place_tile (7, 4));
- assert_true (ai_move (ai, 7, 5));
- assert_true (game.place_tile (7, 1));
- assert_true (ai_move (ai, 7, 0));
- assert_true (game.place_tile (7, 7));
- assert_true (ai_move (ai, 6, 7));
- assert_true (game.place_tile (7, 6));
- assert_true (ai_move (ai, 6, 0));
- assert_true (game.place_tile (0, 0));
- assert_true (ai_move (ai, 0, 1));
- assert_true (game.place_tile (0, 6));
- assert_true (ai_move (ai, 1, 6));
- assert_true (game.place_tile (1, 7));
- assert_true (ai_move (ai, 0, 7));
- }
-
- private static void test_complete_game_2 ()
- {
- /* human starts 0 1 2 3 4 5 6 7 */
- string [] board = {/* 0 */ " . . . . . . . .",
- /* 1 */ " . . . . . . . .",
- /* 2 */ " . . . D . . . .",
- /* 3 */ " . . L L L L . .",
- /* 4 */ " . . . D D D . .",
- /* 5 */ " . . . . . . . .",
- /* 6 */ " . . . . . . . .",
- /* 7 */ " . . . . . . . ." };
-
- Game game = new Game.from_strings (board, Player.DARK);
- ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 6);
-
- assert_true (game.place_tile (4, 2));
- assert_true (ai_move (ai, 5, 5));
- assert_true (game.place_tile (6, 4));
- assert_true (ai_move (ai, 5, 2));
- assert_true (game.place_tile (6, 5));
- assert_true (ai_move (ai, 2, 2));
- assert_true (game.place_tile (3, 1));
- assert_true (ai_move (ai, 4, 5));
- assert_true (game.place_tile (3, 5));
- assert_true (ai_move (ai, 6, 3));
- assert_true (game.place_tile (2, 4));
- assert_true (ai_move (ai, 3, 6));
- assert_true (game.place_tile (7, 3));
- assert_true (ai_move (ai, 2, 5));
- assert_true (game.place_tile (3, 7));
- assert_true (ai_move (ai, 7, 5));
- assert_true (game.place_tile (5, 6));
- assert_true (ai_move (ai, 5, 7));
- assert_true (game.place_tile (6, 2));
- assert_true (ai_move (ai, 4, 6));
- assert_true (game.place_tile (4, 7));
- assert_true (ai_move (ai, 2, 7));
- assert_true (game.place_tile (1, 3));
- assert_true (ai_move (ai, 1, 2));
- assert_true (game.place_tile (0, 2));
- assert_true (ai_move (ai, 2, 1));
- assert_true (game.place_tile (2, 0));
- assert_true (ai_move (ai, 1, 1));
- assert_true (game.place_tile (2, 6));
- assert_true (ai_move (ai, 1, 7));
- assert_true (game.place_tile (4, 1));
- assert_true (ai_move (ai, 7, 4));
- assert_true (game.place_tile (7, 6));
- assert_true (ai_move (ai, 0, 4));
- assert_true (game.place_tile (0, 3));
- assert_true (ai_move (ai, 0, 1));
- assert_true (game.place_tile (1, 4));
- assert_true (ai_move (ai, 6, 6));
- assert_true (game.place_tile (1, 6));
- assert_true (ai_move (ai, 4, 0));
- assert_true (game.place_tile (3, 0));
- assert_true (ai_move (ai, 1, 0));
- assert_true (game.place_tile (5, 1));
- assert_true (ai_move (ai, 7, 2));
- assert_true (game.place_tile (7, 7));
- assert_true (ai_move (ai, 6, 0));
- assert_true (game.place_tile (6, 1));
- assert_true (ai_move (ai, 6, 7));
- assert_true (game.place_tile (0, 7));
- assert_true (ai_move (ai, 5, 0));
- assert_true (game.place_tile (0, 0));
- assert_true (ai_move (ai, 0, 6));
- assert_true (game.place_tile (0, 5));
- assert_true (ai_move (ai, 1, 5));
- assert_true (game.place_tile (7, 0));
- assert_true (ai_move (ai, 7, 1));
- }
-
- private static void test_complete_game_3 ()
- {
- /* AI starts 0 1 2 3 4 5 6 7 */
- string [] board = {/* 0 */ " . . . . . . . .",
- /* 1 */ " . . . . . . . .",
- /* 2 */ " . . . . . D . .",
- /* 3 */ " . . . L D D . .",
- /* 4 */ " . . . D L D . .",
- /* 5 */ " . . . . . L . .",
- /* 6 */ " . . . . . . . .",
- /* 7 */ " . . . . . . . ." };
-
- Game game = new Game.from_strings (board, Player.DARK);
- ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 6);
-
- assert_true (ai_move (ai, 3, 5));
- assert_true (game.place_tile (6, 3));
- assert_true (ai_move (ai, 3, 2));
- assert_true (game.place_tile (2, 3));
- assert_true (ai_move (ai, 1, 4));
- assert_true (game.place_tile (4, 5));
- assert_true (ai_move (ai, 6, 5));
- assert_true (game.place_tile (2, 6));
- assert_true (ai_move (ai, 2, 5));
- assert_true (game.place_tile (3, 6));
- assert_true (ai_move (ai, 2, 2));
- assert_true (game.place_tile (0, 3));
- assert_true (ai_move (ai, 6, 2));
- assert_true (game.place_tile (1, 3));
- assert_true (ai_move (ai, 0, 5));
- assert_true (game.place_tile (4, 1));
- assert_true (ai_move (ai, 5, 1));
- assert_true (game.place_tile (6, 4));
- assert_true (ai_move (ai, 1, 5));
- assert_true (game.place_tile (5, 0));
- assert_true (ai_move (ai, 7, 3));
- assert_true (game.place_tile (2, 4));
- assert_true (ai_move (ai, 3, 0));
- assert_true (game.place_tile (4, 2));
- assert_true (ai_move (ai, 3, 1));
- assert_true (game.place_tile (0, 4));
- assert_true (ai_move (ai, 0, 2));
- assert_true (game.place_tile (1, 2));
- assert_true (ai_move (ai, 4, 7));
- assert_true (game.place_tile (2, 7));
- assert_true (ai_move (ai, 0, 6));
- assert_true (game.place_tile (4, 6));
- assert_true (ai_move (ai, 5, 7));
- assert_true (game.place_tile (5, 6));
- assert_true (ai_move (ai, 2, 1));
- assert_true (game.place_tile (2, 0));
- assert_true (ai_move (ai, 1, 0));
- assert_true (game.place_tile (7, 5));
- assert_true (ai_move (ai, 6, 7));
- assert_true (game.place_tile (7, 2));
- assert_true (ai_move (ai, 7, 6));
- assert_true (game.place_tile (7, 7));
- assert_true (ai_move (ai, 3, 7));
- assert_true (game.place_tile (7, 4));
- assert_true (ai_move (ai, 1, 1));
- assert_true (game.place_tile (6, 6));
- assert_true (ai_move (ai, 6, 1));
- assert_true (game.place_tile (0, 0));
- assert_true (ai_move (ai, 1, 7));
- assert_true (game.place_tile (4, 0));
- assert_true (ai_move (ai, 6, 0));
- assert_true (game.place_tile (0, 7));
- assert_true (ai_move (ai, 0, 1));
- assert_true (game.place_tile (1, 6));
- assert_true (ai_move (ai, 7, 1));
- assert_true (game.place_tile (7, 0));
- }
-
- private static void test_complete_game_4 ()
- {
- /* AI starts 0 1 2 3 4 5 6 7 */
- string [] board = {/* 0 */ " . . . . . . . .",
- /* 1 */ " . . . . . . . .",
- /* 2 */ " . . . D . L . .",
- /* 3 */ " . . . D L . . .",
- /* 4 */ " . . L L D . . .",
- /* 5 */ " . . . . D . . .",
- /* 6 */ " . . . . . . . .",
- /* 7 */ " . . . . . . . ." };
-
- Game game = new Game.from_strings (board, Player.DARK);
- ComputerPlayer ai = new ComputerReversiHard (game, /* depth */ 6);
-
- assert_true (ai_move (ai, 5, 4));
- assert_true (game.place_tile (6, 4));
- assert_true (ai_move (ai, 1, 5));
- assert_true (game.place_tile (2, 2));
- assert_true (ai_move (ai, 3, 5));
- assert_true (game.place_tile (1, 4));
- assert_true (ai_move (ai, 6, 3));
- assert_true (game.place_tile (4, 2));
- assert_true (ai_move (ai, 4, 1));
- assert_true (game.place_tile (5, 5));
- assert_true (ai_move (ai, 2, 3));
- assert_true (game.place_tile (4, 0));
- assert_true (ai_move (ai, 5, 6));
- assert_true (game.place_tile (2, 6));
- assert_true (ai_move (ai, 2, 5));
- assert_true (game.place_tile (0, 4));
- assert_true (ai_move (ai, 0, 6));
- assert_true (game.place_tile (1, 3));
- assert_true (ai_move (ai, 5, 1));
- assert_true (game.place_tile (6, 7));
- assert_true (ai_move (ai, 3, 6));
- assert_true (game.place_tile (3, 7));
- assert_true (ai_move (ai, 5, 0));
- assert_true (game.place_tile (6, 5));
- assert_true (ai_move (ai, 3, 0));
- assert_true (game.place_tile (3, 1));
- assert_true (ai_move (ai, 0, 2));
- assert_true (game.place_tile (5, 3));
- assert_true (ai_move (ai, 7, 4));
- assert_true (game.place_tile (7, 2));
- assert_true (ai_move (ai, 7, 5));
- assert_true (game.place_tile (4, 6));
- assert_true (ai_move (ai, 1, 2));
- assert_true (game.place_tile (7, 3));
- assert_true (ai_move (ai, 6, 2));
- assert_true (game.place_tile (7, 6));
- assert_true (ai_move (ai, 2, 7));
- assert_true (game.place_tile (1, 7));
- assert_true (ai_move (ai, 2, 0));
- assert_true (game.place_tile (7, 1));
- assert_true (ai_move (ai, 6, 6));
- assert_true (game.place_tile (0, 3));
- assert_true (ai_move (ai, 0, 5));
- assert_true (game.place_tile (7, 7));
- assert_true (ai_move (ai, 6, 1));
- assert_true (game.place_tile (7, 0));
- assert_true (ai_move (ai, 6, 0));
- assert_true (game.place_tile (1, 0));
- assert_true (ai_move (ai, 1, 6));
- assert_true (game.place_tile (2, 1));
- assert_true (game.pass ());
- assert_true (game.place_tile (0, 7));
- assert_true (game.pass ());
- assert_true (game.place_tile (0, 1));
- assert_true (ai_move (ai, 1, 1));
- assert_true (game.place_tile (0, 0));
- assert_true (game.pass ());
- assert_true (game.place_tile (4, 7));
- assert_true (ai_move (ai, 5, 7));
- }
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
