-- Vet LOS for symmetry.
local FAILMAP = 'losfail.map'
local checks = 0
local function test_los()
  -- Send the player to a random spot on the level.
  you.random_teleport()
  -- Forcibly redo LOS.
  you.losight()
  -- And draw the view to keep the watcher entertained.
  crawl.redraw_view()
  checks = checks + 1
  local you_x, you_y = you.pos()
  local visible_spots = { }
  for y = -8, 8 do
    for x = -8, 8 do
      if x ~= 0 or y ~= 0 then
        local px, py = x + you_x, y + you_y
        if you.see_grid(px, py) then
          table.insert(visible_spots, { px, py })
        end
      end
    end
  end
  -- For each position in LOS, jump to that position and make sure we
  -- can see the original spot.
  for _, spot in ipairs(visible_spots) do
    local x, y = unpack(spot)
    you.moveto(x, y)
    you.losight()
    if not you.see_grid(you_x, you_y) then
      crawl.redraw_view()
      local this_p = dgn.point(x, y)
      local you_p = dgn.point(you_x, you_y)
      dgn.grid(you_x, you_y, "floor_special")
      dgn.dbg_dump_map(FAILMAP)
      assert(false,
             "LOS asymmetry detected (iter #" .. checks .. "): " .. you_p ..
               " sees " .. this_p .. ", but not vice versa." ..
               " Map saved to " .. FAILMAP)
    end
  end
end
local function run_los_tests(depth, nlevels, tests_per_level)
  local place = "D:" .. depth
  crawl.mpr("Running LOS tests on " .. place)
  dgn.dbg_goto_place(place)
  for lev_i = 1, nlevels do
    dgn.dbg_flush_map_memory()
    dgn.dbg_generate_level()
    for t_i = 1, tests_per_level do
      test_los()
    end
  end
end
for depth = 1, 27 do
  run_los_tests(depth, 10, 100)
end

    if (exit_code && !crawl_state.arena && !crawl_state.seen_hups)

    if (exit_code && !crawl_state.arena
        && !crawl_state.seen_hups && !crawl_state.test)

    bool test;              // Set if we want to run self-tests and exit.

test: $(GAME)
	$(PWD)/$(GAME) -test

ctest.o \

#include "message.h"

#include "place.h"
#include "spells3.h"

// WARNING: This is a very low-level call.
LUAFN(dgn_dbg_goto_place)
{
    try
    {
        const level_id id = level_id::parse_level_id(luaL_checkstring(ls, 1));
        you.level_type = id.level_type;
        if (id.level_type == LEVEL_DUNGEON)
        {
            you.where_are_you = static_cast<branch_type>(id.branch);
            you.your_level = absdungeon_depth(id.branch, id.depth);
        }
    }
    catch (const std::string &err)
    {
        luaL_error(ls, err.c_str());
    }
    return (0);
}
LUAFN(dgn_dbg_flush_map_memory)
{
    dgn_flush_map_memory();
    init_level_connectivity();
    return (0);
}
LUAFN(dgn_dbg_generate_level)
{
    no_messages mx;
    env.show.init(0);
    env.map.init(map_cell());
    builder(you.your_level, you.level_type);
    return (0);
}

LUAFN(dgn_debug_dump_map)

LUAFN(dgn_dbg_dump_map)

    { "dbg_goto_place", dgn_dbg_goto_place },
    { "dbg_flush_map_memory", dgn_dbg_flush_map_memory },
    { "dbg_generate_level", dgn_dbg_generate_level },
    { "dbg_dump_map", dgn_dbg_dump_map },

    { "debug_dump_map", dgn_debug_dump_map },

LUAFN(_crawl_redraw_view)
{
    viewwindow(true, false);
    return (0);
}

    { "redraw_view", _crawl_redraw_view },

// see_grid should not be exposed to user scripts. The game should
// never disclose grid coordinates to the player. Therefore we load it
// only into the core Lua interpreter (dlua), never into the user
// script interpreter (clua).
LUARET1(you_see_grid, boolean,
        see_grid(luaL_checkint(ls, 1), luaL_checkint(ls, 2)))
LUARET1(you_see_grid_no_trans, boolean,
        see_grid_no_trans(luaL_checkint(ls, 1), luaL_checkint(ls, 2)))
LUAFN(you_moveto)
{
    const coord_def place(luaL_checkint(ls, 1), luaL_checkint(ls, 2));
    ASSERT(map_bounds(place));
    you.moveto(place);
    return (0);
}
LUAFN(you_random_teleport)
{
    you_teleport_now(false, false);
    return (0);
}
LUAFN(you_losight)
{
    calc_show_los();
    return (0);
}

    { "moveto", you_moveto },
    { "see_grid",          you_see_grid },
    { "see_grid_no_trans", you_see_grid_no_trans },
    { "random_teleport", you_random_teleport },
    { "losight", you_losight },

    CLO_TEST,

    "mapstat", "arena", "help"

    "mapstat", "arena", "test", "help"

    COMPILE_CHECK(ARRAYSZ(cmd_ops) == CLO_NOPS, c1);

        case CLO_TEST:
            crawl_state.test = true;
            break;

std::vector<std::string> get_dir_files(const std::string &dir);
std::vector<std::string> get_dir_files_ext(const std::string &dir,
                                           const std::string &ext);

}
std::vector<std::string> get_dir_files_ext(const std::string &dir,
                                           const std::string &ext)
{
    const std::vector<std::string> allfiles(get_dir_files(dir));
    std::vector<std::string> filtered;
    for (int i = 0, size = allfiles.size(); i < size; ++i)
        if (ends_with(allfiles[i], ext))
            filtered.push_back(allfiles[i]);
    return (filtered);

void dgn_flush_map_memory();

}
void dgn_flush_map_memory()
{
    you.uniq_map_tags.clear();
    you.uniq_map_names.clear();

    save_game_state();

    if (!crawl_state.test)
        save_game_state();

#ifndef CTEST_H
#define CTEST_H
#include "AppHdr.h"
#ifdef DEBUG_DIAGNOSTICS
namespace crawl_tests
{
    void run_tests(bool exit_on_complete);
}
#endif
#endif

/*
 *  File:       ctest.cc
 *  Summary:    Crawl Lua test cases
 *  Written by: Darshan Shaligram
 *
 *  Modified for Crawl Reference by $Author$ on $Date$
 *
 *  ctest runs Lua tests found in the test directory. The intent here
 *  is to test parts of Crawl that can be easily tested from within Crawl
 *  itself (such as LOS). As a side-effect, writing Lua bindings to support
 *  tests will expand the available Lua bindings. :-)
 *
 *  Tests will run only with Crawl built in its source tree without
 *  DATA_DIR_PATH set.
 */
#include "AppHdr.h"
#if DEBUG_DIAGNOSTICS
#include "clua.h"
#include "files.h"
#include "luadgn.h"
#include "maps.h"
#include "stuff.h"
#include <algorithm>
#include <vector>
namespace crawl_tests
{
    const std::string test_dir = "test";
    const std::string test_player_name = "Superbug99";
    int ntests = 0;
    int nsuccess = 0;
    typedef std::pair<std::string, std::string> file_error;
    std::vector<file_error> failures;
    void reset_test_data()
    {
        ntests = 0;
        nsuccess = 0;
        failures.clear();
        // XXX: Good grief, you.your_name is still not a C++ string?!
        strncpy(you.your_name, test_player_name.c_str(), kNameLen);
        you.your_name[kNameLen - 1] = 0;
    }
    int crawl_begin_test(lua_State *ls)
    {
        mprf(MSGCH_PROMPT, "Starting tests: %s", luaL_checkstring(ls, 1));
        lua_pushnumber(ls, ++ntests);
        return (1);
    }
    int crawl_test_success(lua_State *ls)
    {
        mprf(MSGCH_PROMPT, "Test success: %s", luaL_checkstring(ls, 1));
        lua_pushnumber(ls, ++nsuccess);
        return (1);
    }
    static const struct luaL_reg crawl_test_lib[] =
    {
        { "begin_test", crawl_begin_test },
        { "test_success", crawl_test_success },
        { NULL, NULL }
    };
    void init_test_bindings()
    {
        lua_stack_cleaner clean(dlua);
        luaL_openlib(dlua, "crawl", crawl_test_lib, 0);
    }
    void run_test(const std::string &file)
    {
        ++ntests;
        const std::string path(catpath(test_dir, file));
        dlua.execfile(path.c_str(), true, false);
        if (dlua.error.empty())
            ++nsuccess;
        else
            failures.push_back(file_error(file, dlua.error));
    }
    // Assumes curses has already been initialized.
    bool run_tests(bool exit_on_complete)
    {
        run_map_preludes();
        reset_test_data();
        init_test_bindings();
        // Get a list of Lua files in test. Order of execution of
        // tests should be irrelevant.
        const std::vector<std::string> tests(
            get_dir_files_ext(test_dir, ".lua"));
        std::for_each(tests.begin(), tests.end(),
                      run_test);
        if (exit_on_complete)
        {
            cio_cleanup();
            for (int i = 0, size = failures.size(); i < size; ++i)
            {
                const file_error &fe(failures[i]);
                fprintf(stderr, "Test error: %s\n",
                        fe.second.c_str());
            }
            const int code = failures.empty() ? 0 : 1;
            end(code, false, "%d tests, %d succeeded, %d failed",
                ntests, nsuccess, failures.size());
        }
        return (failures.empty());
    }
}
#endif // DEBUG_DIAGNOSTICS

LUARET1(you_see_grid, boolean,
        see_grid(luaL_checkint(ls, 1), luaL_checkint(ls, 2)))
LUARET1(you_see_grid_no_trans, boolean,
        see_grid_no_trans(luaL_checkint(ls, 1), luaL_checkint(ls, 2)))

    { "see_grid",          you_see_grid },
    { "see_grid_no_trans", you_see_grid_no_trans },

                fputc(grid_character_at(coord_def(x,y)), fp);

            {
                if (you.pos() == coord_def(x, y))
                    fputc('@', fp);
                else if (grd[x][y] == DNGN_FLOOR_SPECIAL)
                    fputc('?', fp);
                else
                    fputc(grid_character_at(coord_def(x,y)), fp);
            }

#include "ctest.h"

#if DEBUG_DIAGNOSTICS
    puts("");
    puts("  -test            run test cases in ./test");
#endif

    if (crawl_state.test)
    {
#ifdef DEBUG_DIAGNOSTICS
        crawl_tests::run_tests(true);
        // Superfluous, just to make it clear that this is the end of
        // the line.
        end(0, false);
#else
        end(1, false, "Non-debug Crawl cannot run tests. "
            "Please use a debug build");
#endif
    }

debug.map

*.map