mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-19 03:13:40 +00:00
33eb3028f5
tests/accumulator/*.m:
tests/analysis_*/*.m:
tests/benchmarks*/*.m:
tests/debugger*/*.{m,exp,inp}:
tests/declarative_debugger*/*.{m,exp,inp}:
tests/dppd*/*.m:
tests/exceptions*/*.m:
tests/general*/*.m:
tests/grade_subdirs*/*.m:
tests/hard_coded*/*.m:
Make these tests use four-space indentation, and ensure that
each module is imported on its own line. (I intend to use the latter
to figure out which subdirectories' tests can be executed in parallel.)
These changes usually move code to different lines. For the debugger tests,
specify the new line numbers in .inp files and expect them in .exp files.
165 lines
5.9 KiB
Mathematica
165 lines
5.9 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% vim: ts=4 sw=4 et ft=mercury
|
|
%---------------------------------------------------------------------------%
|
|
% Copyright (C) 1997-1998 The University of Melbourne.
|
|
% This file may only be copied under the terms of the GNU Library General
|
|
% Public License - see the file COPYING.LIB in the Mercury distribution.
|
|
%---------------------------------------------------------------------------%
|
|
|
|
% File: test_loop_check.m.
|
|
% Main author: fjh.
|
|
|
|
% Test cases that combine exception handling and `pragma loop_check'.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- module test_loop_check.
|
|
:- interface.
|
|
:- import_module io.
|
|
|
|
:- pred main(io__state::di, io__state::uo) is cc_multi.
|
|
|
|
:- implementation.
|
|
:- import_module std_util.
|
|
:- import_module exception.
|
|
|
|
% repeat the test several times, so that we test both
|
|
% construction of the tables and use of the tables.
|
|
main -->
|
|
print("--- first time ---"), nl,
|
|
test,
|
|
print("--- second time ---"), nl,
|
|
test,
|
|
print("--- third time ---"), nl,
|
|
test.
|
|
|
|
:- pred test(io__state::di, io__state::uo) is cc_multi.
|
|
test -->
|
|
{ try(det_throw, DetThrowResult) },
|
|
print("det_throw: "), print(DetThrowResult), nl,
|
|
{ try(det_succeed, DetSucceedResult) },
|
|
print("det_succeed: "), print(DetSucceedResult), nl,
|
|
|
|
{ try(semidet_throw, SemidetThrowResult) },
|
|
print("semidet_throw: "), print(SemidetThrowResult), nl,
|
|
|
|
{ try(semidet_succeed, SemidetSucceedResult) },
|
|
print("semidet_succeed: "), print(SemidetSucceedResult), nl,
|
|
|
|
{ try(semidet_fail, SemidetFailResult) },
|
|
print("semidet_fail: "), print(SemidetFailResult), nl,
|
|
|
|
{ try(cc_multi_throw, CCMultiThrowResult) },
|
|
print("cc_multi_throw: "), print(CCMultiThrowResult), nl,
|
|
{ try(cc_multi_succeed, CCMultiSucceedResult) },
|
|
print("cc_multi_succeed: "), print(CCMultiSucceedResult), nl,
|
|
|
|
{ try(cc_nondet_throw, CCNondetThrowResult) },
|
|
print("cc_nondet_throw: "), print(CCNondetThrowResult), nl,
|
|
|
|
{ try(cc_nondet_succeed, CCNondetSucceedResult) },
|
|
print("cc_nondet_succeed: "), print(CCNondetSucceedResult), nl,
|
|
|
|
{ try(cc_nondet_fail, CCNondetFailResult) },
|
|
print("cc_nondet_fail: "), print(CCNondetFailResult), nl,
|
|
|
|
{ try((pred(R::out) is det :- solutions(multi_throw, R)),
|
|
MultiThrowResult) },
|
|
print("multi_throw: "), print(MultiThrowResult), nl,
|
|
{ try((pred(R::out) is det :- solutions(multi_succeed, R)),
|
|
MultiSucceedResult) },
|
|
print("multi_succeed: "), print(MultiSucceedResult), nl,
|
|
{ try((pred(R::out) is det :-
|
|
solutions(multi_succeed_then_throw, R)),
|
|
MultiSucceedThenThrowResult) },
|
|
print("multi_succeed_then_throw: "),
|
|
print(MultiSucceedThenThrowResult), nl,
|
|
|
|
{ try((pred(R::out) is det :- solutions(nondet_throw, R)),
|
|
NondetThrowResult) },
|
|
print("nondet_throw: "), print(NondetThrowResult), nl,
|
|
{ try((pred(R::out) is det :- solutions(nondet_succeed, R)),
|
|
NondetSucceedResult) },
|
|
print("nondet_succeed: "), print(NondetSucceedResult), nl,
|
|
{ try((pred(R::out) is det :- solutions(nondet_fail, R)),
|
|
NondetFailResult) },
|
|
print("nondet_fail: "), print(NondetFailResult), nl,
|
|
{ try((pred(R::out) is det :-
|
|
solutions(nondet_succeed_then_throw, R)),
|
|
NondetSucceedThenThrowResult) },
|
|
print("nondet_succeed_then_throw: "),
|
|
print(NondetSucceedThenThrowResult), nl.
|
|
|
|
:- pred det_throw(string::out) is det.
|
|
:- pragma loop_check(det_throw/1).
|
|
det_throw(_) :- throw("det_throw").
|
|
|
|
:- pred semidet_throw(string::out) is semidet.
|
|
:- pragma loop_check(semidet_throw/1).
|
|
semidet_throw(_) :- throw("semidet_throw").
|
|
|
|
:- pred nondet_throw(string::out) is nondet.
|
|
nondet_throw(_) :- throw("nondet_throw").
|
|
|
|
:- pred multi_throw(string::out) is multi.
|
|
multi_throw(_) :- throw("multi_throw").
|
|
|
|
:- pred cc_nondet_throw(string::out) is cc_nondet.
|
|
:- pragma loop_check(cc_nondet_throw/1).
|
|
cc_nondet_throw(_) :- throw("cc_nondet_throw").
|
|
|
|
:- pred cc_multi_throw(string::out) is cc_multi.
|
|
:- pragma loop_check(cc_multi_throw/1).
|
|
cc_multi_throw(_) :- throw("cc_multi_throw").
|
|
|
|
:- pred det_succeed(string::out) is det.
|
|
:- pragma loop_check(det_succeed/1).
|
|
det_succeed("det_succeed").
|
|
|
|
:- pred semidet_succeed(string::out) is semidet.
|
|
:- pragma loop_check(semidet_succeed/1).
|
|
semidet_succeed("semidet_succeed").
|
|
|
|
:- pred nondet_succeed(string::out) is nondet.
|
|
nondet_succeed("nondet_succeed 1").
|
|
nondet_succeed("nondet_succeed 2").
|
|
|
|
:- pred multi_succeed(string::out) is multi.
|
|
multi_succeed("multi_succeed 1").
|
|
multi_succeed("multi_succeed 2").
|
|
|
|
:- pred cc_nondet_succeed(string::out) is cc_nondet.
|
|
:- pragma loop_check(cc_nondet_succeed/1).
|
|
cc_nondet_succeed("cc_nondet_succeed").
|
|
cc_nondet_succeed("cc_nondet_succeed 2").
|
|
|
|
:- pred cc_multi_succeed(string::out) is cc_multi.
|
|
:- pragma loop_check(cc_multi_succeed/1).
|
|
cc_multi_succeed("cc_multi_succeed").
|
|
cc_multi_succeed("cc_multi_succeed 2").
|
|
|
|
:- pred semidet_fail(string::out) is semidet.
|
|
:- pragma loop_check(semidet_fail/1).
|
|
semidet_fail("semidet_fail") :- fail.
|
|
|
|
:- pred nondet_fail(string::out) is nondet.
|
|
nondet_fail("nondet_fail 1") :- fail.
|
|
nondet_fail("nondet_fail 2") :- fail.
|
|
|
|
:- pred cc_nondet_fail(string::out) is cc_nondet.
|
|
:- pragma loop_check(cc_nondet_fail/1).
|
|
cc_nondet_fail("cc_nondet_fail 1") :- fail.
|
|
cc_nondet_fail("cc_nondet_fail 2") :- fail.
|
|
|
|
:- pred nondet_succeed_then_throw(string::out) is nondet.
|
|
nondet_succeed_then_throw("nondet_succeed_then_throw 1").
|
|
nondet_succeed_then_throw("nondet_succeed_then_throw 2").
|
|
nondet_succeed_then_throw(_) :- throw("nondet_succeed_then_throw 3").
|
|
nondet_succeed_then_throw("nondet_succeed_then_throw 4").
|
|
|
|
:- pred multi_succeed_then_throw(string::out) is multi.
|
|
multi_succeed_then_throw("multi_succeed_then_throw 1").
|
|
multi_succeed_then_throw("multi_succeed_then_throw 2").
|
|
multi_succeed_then_throw(_) :- throw("multi_succeed_then_throw 3").
|
|
multi_succeed_then_throw("multi_succeed_then_throw 4").
|