mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-21 04:13:46 +00:00
369154884a
tests/invalid/invalid_int16_inst.{m,err_exp}:
tests/invalid/invalid_int32_inst.{m,err_exp}:
tests/invalid/invalid_int64_inst.{m,err_exp}:
tests/invalid/invalid_int8_inst.{m,err_exp}:
tests/invalid/invalid_uint16_inst.{m,err_exp}:
tests/invalid/invalid_uint32_inst.{m,err_exp}:
tests/invalid/invalid_uint64_inst.{m,err_exp}:
tests/invalid/invalid_uint8_inst.{m,err_exp}:
tests/invalid/invalid_uint_inst.{m,err_exp}:
Delete these test cases, which are designed to test mode errors
in calls, though one (invalid_int8_inst.m} tested a type error,
tests/invalid/invalid_integral_call_inst.{m,err_exp}:
Replace all nine test cases with this one new test case,
which does all the tests they did (and tests plain "int" as well).
tests/invalid/Mmakefile:
Invoke the new test, not the old ones.
166 lines
3.6 KiB
Mathematica
166 lines
3.6 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% vim: ts=4 sw=4 et ft=mercury
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Check the error messages we generate when a call has vars with invalid
|
|
% instantiation states involving integer literals that need suffixes.
|
|
%
|
|
|
|
:- module invalid_integral_call_inst.
|
|
:- interface.
|
|
|
|
:- import_module io.
|
|
|
|
:- pred main(io::di, io::uo) is det.
|
|
|
|
:- implementation.
|
|
|
|
main(!IO) :-
|
|
main_i08(!IO),
|
|
main_i16(!IO),
|
|
main_i32(!IO),
|
|
main_i64(!IO),
|
|
main_i(!IO),
|
|
main_u08(!IO),
|
|
main_u16(!IO),
|
|
main_u32(!IO),
|
|
main_u64(!IO),
|
|
main_u(!IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred main_i08(io::di, io::uo) is det.
|
|
|
|
main_i08(!IO) :-
|
|
NI08 = 7i8,
|
|
XI08 = test_int08(NI08),
|
|
io.print_line(XI08, !IO).
|
|
|
|
:- pred main_i16(io::di, io::uo) is det.
|
|
|
|
main_i16(!IO) :-
|
|
NI16 = 7i16,
|
|
XI16 = test_int16(NI16),
|
|
io.print_line(XI16, !IO).
|
|
|
|
:- pred main_i32(io::di, io::uo) is det.
|
|
|
|
main_i32(!IO) :-
|
|
NI32 = 7i32,
|
|
XI32 = test_int32(NI32),
|
|
io.print_line(XI32, !IO).
|
|
|
|
:- pred main_i64(io::di, io::uo) is det.
|
|
|
|
main_i64(!IO) :-
|
|
NI64 = 7i64,
|
|
XI64 = test_int64(NI64),
|
|
io.print_line(XI64, !IO).
|
|
|
|
:- pred main_i(io::di, io::uo) is det.
|
|
|
|
main_i(!IO) :-
|
|
NI = 7,
|
|
XI = test_int(NI),
|
|
io.print_line(XI, !IO).
|
|
|
|
:- pred main_u08(io::di, io::uo) is det.
|
|
|
|
main_u08(!IO) :-
|
|
NU08 = 7u8,
|
|
XU08 = test_uint08(NU08),
|
|
io.print_line(XU08, !IO).
|
|
|
|
:- pred main_u16(io::di, io::uo) is det.
|
|
|
|
main_u16(!IO) :-
|
|
NU16 = 7u16,
|
|
XU16 = test_uint16(NU16),
|
|
io.print_line(XU16, !IO).
|
|
|
|
:- pred main_u32(io::di, io::uo) is det.
|
|
|
|
main_u32(!IO) :-
|
|
NU32 = 7u32,
|
|
XU32 = test_uint32(NU32),
|
|
io.print_line(XU32, !IO).
|
|
|
|
:- pred main_u64(io::di, io::uo) is det.
|
|
|
|
main_u64(!IO) :-
|
|
NU64 = 7u64,
|
|
XU64 = test_uint64(NU64),
|
|
io.print_line(XU64, !IO).
|
|
|
|
:- pred main_u(io::di, io::uo) is det.
|
|
|
|
main_u(!IO) :-
|
|
NU = 7u,
|
|
XU = test_uint(NU),
|
|
io.print_line(XU, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- func test_int08(int8::in(bound(2i8 ; 4i8 ; 6i8))) = (int8::out) is det.
|
|
|
|
test_int08(2i8) = 4i8.
|
|
test_int08(4i8) = 9i8.
|
|
test_int08(6i8) = 12i8.
|
|
|
|
:- func test_int16(int16::in(bound(2i16 ; 4i16 ; 6i16))) = (int16::out) is det.
|
|
|
|
test_int16(2i16) = 4i16.
|
|
test_int16(4i16) = 9i16.
|
|
test_int16(6i16) = 12i16.
|
|
|
|
:- func test_int32(int32::in(bound(2i32 ; 4i32 ; 6i32))) = (int32::out) is det.
|
|
|
|
test_int32(2i32) = 4i32.
|
|
test_int32(4i32) = 9i32.
|
|
test_int32(6i32) = 12i32.
|
|
|
|
:- func test_int64(int64::in(bound(2i64 ; 4i64 ; 6i64))) = (int64::out) is det.
|
|
|
|
test_int64(2i64) = 4i64.
|
|
test_int64(4i64) = 9i64.
|
|
test_int64(6i64) = 12i64.
|
|
|
|
:- func test_int(int::in(bound(2 ; 4 ; 6))) = (int::out) is det.
|
|
|
|
test_int(2) = 4.
|
|
test_int(4) = 9.
|
|
test_int(6) = 12.
|
|
|
|
:- func test_uint08(uint8::in(bound(2u8 ; 4u8 ; 6u8))) = (uint8::out) is det.
|
|
|
|
test_uint08(2u8) = 4u8.
|
|
test_uint08(4u8) = 9u8.
|
|
test_uint08(6u8) = 12u8.
|
|
|
|
:- func test_uint16(uint16::in(bound(2u16 ; 4u16 ; 6u16))) = (uint16::out)
|
|
is det.
|
|
|
|
test_uint16(2u16) = 4u16.
|
|
test_uint16(4u16) = 9u16.
|
|
test_uint16(6u16) = 12u16.
|
|
|
|
:- func test_uint32(uint32::in(bound(2u32 ; 4u32 ; 6u32))) = (uint32::out)
|
|
is det.
|
|
|
|
test_uint32(2u32) = 4u32.
|
|
test_uint32(4u32) = 9u32.
|
|
test_uint32(6u32) = 12u32.
|
|
|
|
:- func test_uint64(uint64::in(bound(2u64 ; 4u64 ; 6u64))) = (uint64::out)
|
|
is det.
|
|
|
|
test_uint64(2u64) = 4u64.
|
|
test_uint64(4u64) = 9u64.
|
|
test_uint64(6u64) = 12u64.
|
|
|
|
:- func test_uint(uint::in(bound(2u ; 4u ; 6u))) = (uint::out) is det.
|
|
|
|
test_uint(2u) = 4u.
|
|
test_uint(4u) = 9u.
|
|
test_uint(6u) = 12u.
|