mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-16 01:43:35 +00:00
f2f9fb1d5c
tests/hard_coded/test_generic_ref.{m,exp}:
Extend this test to cover 64-bit integer types.
257 lines
7.1 KiB
Mathematica
257 lines
7.1 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- module test_generic_ref.
|
|
:- interface.
|
|
|
|
:- import_module io.
|
|
|
|
:- pred main(io::di, io::uo) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module bool.
|
|
:- import_module char.
|
|
:- import_module deconstruct.
|
|
:- import_module float.
|
|
:- import_module int.
|
|
:- import_module int64.
|
|
:- import_module store.
|
|
:- import_module uint64.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
main(!IO) :-
|
|
do_test(test1_orig, test1_expected, !IO),
|
|
io.nl(!IO),
|
|
do_test(test2_orig, test2_expected, !IO),
|
|
io.nl(!IO),
|
|
do_test(test3_orig, test3_expected, !IO),
|
|
io.nl(!IO),
|
|
do_test(test4_orig, test4_expected, !IO),
|
|
io.nl(!IO),
|
|
do_test(test5_orig, test5_expected, !IO),
|
|
io.nl(!IO),
|
|
do_test(test6_orig, test6_expected, !IO),
|
|
io.nl(!IO),
|
|
do_test(test7_orig, test7_expected, !IO),
|
|
io.nl(!IO),
|
|
do_test(test8_orig, test8_expected, !IO),
|
|
io.nl(!IO),
|
|
do_test(test9_orig, test9_expected, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
% do_test(TermA, TermB, !IO):
|
|
% If TermA and TermB have the same top-level functor then place a copy
|
|
% of TermA in a generic_ref and then individually update each of its
|
|
% fields using arg_ref and set_ref_value so they match those of TermB.
|
|
% When the term is extracted from the generic ref it should match TermB.
|
|
%
|
|
:- pred do_test(T::in, T::in, io::di, io::uo) is det.
|
|
|
|
do_test(OrigTerm, ExpectedTerm, !IO) :-
|
|
io.print(" Orig. Term: ", !IO),
|
|
io.print_line(OrigTerm, !IO),
|
|
% Note that 'canonicalize' is what ref_functor/4 does.
|
|
deconstruct.functor(ExpectedTerm, canonicalize, ExpectedFunctor,
|
|
ExpectedArity),
|
|
some [!Store] (
|
|
copy(OrigTerm, UniqTerm),
|
|
store.init(!:Store),
|
|
store.new_ref(UniqTerm, Ref, !Store),
|
|
store.ref_functor(Ref, Functor, Arity, !Store),
|
|
( if
|
|
ExpectedFunctor = Functor,
|
|
ExpectedArity = Arity
|
|
then
|
|
int.fold_up(update_arg(Ref, ExpectedTerm), 0, Arity - 1, !Store),
|
|
store.extract_ref_value(!.Store, Ref, FinalTerm),
|
|
io.print(" Updated Term: ", !IO),
|
|
io.print_line(FinalTerm, !IO),
|
|
io.print("Expected Term: ", !IO),
|
|
io.print_line(ExpectedTerm, !IO),
|
|
( if FinalTerm \= ExpectedTerm then
|
|
io.print_line("*** MATCH FAILED ***", !IO)
|
|
else
|
|
true
|
|
)
|
|
else
|
|
io.print_line("Cannot update - terms have different functors.", !IO)
|
|
)
|
|
).
|
|
|
|
:- pred update_arg(generic_ref(T, S)::in, T::in, int::in, S::di, S::uo)
|
|
is det <= store(S).
|
|
|
|
update_arg(Ref, ExpectedTerm, N, !Store) :-
|
|
deconstruct.det_arg(ExpectedTerm, do_not_allow, N, Value),
|
|
store.arg_ref(Ref, N, ArgNRef, !Store),
|
|
copy(Value, UniqValue),
|
|
store.set_ref_value(ArgNRef, UniqValue, !Store).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type test1_struct
|
|
---> test1_struct(int).
|
|
|
|
:- func test1_orig = test1_struct.
|
|
|
|
test1_orig = test1_struct(561).
|
|
|
|
:- func test1_expected = test1_struct.
|
|
|
|
test1_expected = test1_struct(41041).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type test2_struct --->
|
|
test2_struct(int, int, int).
|
|
|
|
:- func test2_orig = test2_struct.
|
|
|
|
test2_orig = test2_struct(111, 111, 111).
|
|
|
|
:- func test2_expected = test2_struct.
|
|
|
|
test2_expected = test2_struct(222, 222, 222).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type test3_struct
|
|
---> test3_struct(bool, bool, bool, uint16).
|
|
|
|
:- func test3_orig = test3_struct.
|
|
|
|
test3_orig = test3_struct(yes, yes, yes, 0xffffu16).
|
|
|
|
:- func test3_expected = test3_struct.
|
|
|
|
test3_expected = test3_struct(no, no, no, 0x0000u16).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type animal
|
|
---> ant
|
|
; bat
|
|
; cat
|
|
; dog
|
|
; eel
|
|
; fox
|
|
; gnu
|
|
; hog
|
|
; ibis
|
|
; jay
|
|
; kea
|
|
; lark
|
|
; moa
|
|
; newt
|
|
; owl
|
|
; pug.
|
|
|
|
:- type test4_struct
|
|
---> test4_struct(
|
|
animal, animal,
|
|
int,
|
|
string,
|
|
animal, animal, animal, animal
|
|
).
|
|
|
|
:- func test4_orig = test4_struct.
|
|
|
|
test4_orig = test4_struct(bat, bat, 561, "Hello", owl, owl, owl, owl).
|
|
|
|
:- func test4_expected = test4_struct.
|
|
|
|
test4_expected = test4_struct(fox, fox, 41041, "World", hog, hog, hog, hog).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type dummy
|
|
---> dummy.
|
|
|
|
:- type nested_dummy
|
|
---> nested_dummy(dummy).
|
|
|
|
:- type test5_struct
|
|
---> test5_struct(int, dummy, nested_dummy, string, bool, bool).
|
|
|
|
:- func test5_orig = test5_struct.
|
|
|
|
test5_orig =
|
|
test5_struct(561, dummy, nested_dummy(dummy), "Hello", yes, yes).
|
|
|
|
:- func test5_expected = test5_struct.
|
|
|
|
test5_expected =
|
|
test5_struct(41041, dummy, nested_dummy(dummy), "World", no, no).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type test6_struct
|
|
---> test6_struct(uint8, uint8, dummy, uint16).
|
|
|
|
:- func test6_orig = test6_struct.
|
|
|
|
test6_orig =
|
|
test6_struct(0xffu8, 0xffu8, dummy, 0xffffu16).
|
|
|
|
:- func test6_expected = test6_struct.
|
|
|
|
test6_expected =
|
|
test6_struct(0x1u8, 0x1u8, dummy, 0x1u16).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Tests 7-8.
|
|
|
|
:- type packed(T)
|
|
---> packed_1(int8, uint8, dummy, dummy, int8, uint8, T)
|
|
; some [U] packed_2(dummy, U, int8, uint8, dummy, int8, uint8)
|
|
; packed_3(int)
|
|
; packed_4(int)
|
|
; packed_5(int)
|
|
; packed_6(int)
|
|
; packed_7(int)
|
|
; packed_8(T, dummy, int8, uint8, dummy, dummy, int8, uint8,
|
|
float, int)
|
|
; some [U] packed_9(T, dummy, U, int8, uint8, dummy, int8, uint8).
|
|
|
|
:- func test7_orig = packed(float).
|
|
|
|
test7_orig =
|
|
'new packed_2'(dummy, 561.0, 1i8, 1u8, dummy, 2i8, 3u8).
|
|
|
|
:- func test7_expected = packed(float).
|
|
|
|
test7_expected =
|
|
'new packed_2'(dummy, 41041.0, 127i8, 255u8, dummy, 127i8, 255u8).
|
|
|
|
:- func test8_orig = packed(char).
|
|
|
|
test8_orig = packed_1(1i8, 1u8, dummy, dummy, 0i8, 0u8, 'A').
|
|
|
|
:- func test8_expected = packed(char).
|
|
|
|
test8_expected = packed_1(127i8, 255u8, dummy, dummy, 127i8, 255u8, 'Z').
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type test9_struct
|
|
---> test9_struct(int64, uint64, float, uint64).
|
|
|
|
:- func test9_orig = test9_struct.
|
|
|
|
test9_orig = test9_struct(int64.max_int64, uint64.max_uint64, float.infinity,
|
|
uint64.max_uint64).
|
|
|
|
:- func test9_expected = test9_struct.
|
|
|
|
test9_expected = test9_struct(1i64, 1u64, -1.0, 1u64).
|
|
|
|
%---------------------------------------------------------------------------%
|