|
|
% ===============================================
|
|
|
% ТЕСТЫ ДЛЯ LAB9 TASK1
|
|
|
% Автоматические тесты всех предикатов
|
|
|
% ===============================================
|
|
|
|
|
|
% Запуск всех тестов
|
|
|
run_tests :-
|
|
|
write('=== ЗАПУСК АВТОМАТИЧЕСКИХ ТЕСТОВ ==='), nl,
|
|
|
test_max,
|
|
|
test_factorial,
|
|
|
test_digit_sum,
|
|
|
test_square_free,
|
|
|
test_list_operations,
|
|
|
test_remove_by_digit_sum,
|
|
|
write('=== ВСЕ ТЕСТЫ ЗАВЕРШЕНЫ ==='), nl.
|
|
|
|
|
|
% ===============================================
|
|
|
% ТЕСТЫ ДЛЯ MAX/4
|
|
|
% ===============================================
|
|
|
test_max :-
|
|
|
write('--- Тестирование max/4 ---'), nl,
|
|
|
|
|
|
% Тест 1: обычные числа
|
|
|
(max(5, 3, 7, 7) ->
|
|
|
write('✓ max(5,3,7,7) - ПРОЙДЕН') ;
|
|
|
write('✗ max(5,3,7,7) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест 2: отрицательные числа
|
|
|
(max(-5, -3, -7, -3) ->
|
|
|
write('✓ max(-5,-3,-7,-3) - ПРОЙДЕН') ;
|
|
|
write('✗ max(-5,-3,-7,-3) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест 3: одинаковые числа
|
|
|
(max(5, 5, 5, 5) ->
|
|
|
write('✓ max(5,5,5,5) - ПРОЙДЕН') ;
|
|
|
write('✗ max(5,5,5,5) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест 4: генерация максимума
|
|
|
max(10, 20, 15, Z),
|
|
|
(Z =:= 20 ->
|
|
|
write('✓ max(10,20,15,Z) где Z=20 - ПРОЙДЕН') ;
|
|
|
write('✗ max(10,20,15,Z) - ПРОВАЛЕН')), nl,
|
|
|
nl.
|
|
|
|
|
|
% ===============================================
|
|
|
% ТЕСТЫ ДЛЯ ФАКТОРИАЛОВ
|
|
|
% ===============================================
|
|
|
test_factorial :-
|
|
|
write('--- Тестирование факториалов ---'), nl,
|
|
|
|
|
|
% Тест базового случая
|
|
|
(fact_up(0, 1) ->
|
|
|
write('✓ fact_up(0,1) - ПРОЙДЕН') ;
|
|
|
write('✗ fact_up(0,1) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
(fact_down(0, 1) ->
|
|
|
write('✓ fact_down(0,1) - ПРОЙДЕН') ;
|
|
|
write('✗ fact_down(0,1) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест небольших значений
|
|
|
TestValues = [1, 3, 5, 6],
|
|
|
forall(member(N, TestValues), test_factorial_value(N)),
|
|
|
|
|
|
% Тест эквивалентности рекурсий
|
|
|
test_factorial_equivalence([0, 1, 2, 3, 4, 5, 6, 7]),
|
|
|
nl.
|
|
|
|
|
|
test_factorial_value(N) :-
|
|
|
fact_up(N, F1),
|
|
|
fact_down(N, F2),
|
|
|
write('fact_up('), write(N), write(') = '), write(F1),
|
|
|
write(', fact_down('), write(N), write(') = '), write(F2),
|
|
|
(F1 =:= F2 -> write(' ✓') ; write(' ✗')), nl.
|
|
|
|
|
|
test_factorial_equivalence([]).
|
|
|
test_factorial_equivalence([N|Rest]) :-
|
|
|
fact_up(N, F1),
|
|
|
fact_down(N, F2),
|
|
|
(F1 =:= F2 ->
|
|
|
write('✓ Факториалы '), write(N), write(' эквивалентны') ;
|
|
|
write('✗ Факториалы '), write(N), write(' НЕ эквивалентны')), nl,
|
|
|
test_factorial_equivalence(Rest).
|
|
|
|
|
|
% ===============================================
|
|
|
% ТЕСТЫ ДЛЯ СУММЫ ЦИФР
|
|
|
% ===============================================
|
|
|
test_digit_sum :-
|
|
|
write('--- Тестирование суммы цифр ---'), nl,
|
|
|
|
|
|
% Тест базового случая
|
|
|
(digit_sum_up(0, 0) ->
|
|
|
write('✓ digit_sum_up(0,0) - ПРОЙДЕН') ;
|
|
|
write('✗ digit_sum_up(0,0) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
(digit_sum_down(0, 0) ->
|
|
|
write('✓ digit_sum_down(0,0) - ПРОЙДЕН') ;
|
|
|
write('✗ digit_sum_down(0,0) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест известных значений
|
|
|
TestCases = [(123, 6), (456, 15), (999, 27), (1000, 1), (12345, 15)],
|
|
|
forall(member((N, ExpectedSum), TestCases), test_digit_sum_value(N, ExpectedSum)),
|
|
|
|
|
|
% Тест эквивалентности рекурсий
|
|
|
test_digit_sum_equivalence([0, 1, 12, 123, 1234, 12345, 999, 1000]),
|
|
|
nl.
|
|
|
|
|
|
test_digit_sum_value(N, ExpectedSum) :-
|
|
|
digit_sum_up(N, S1),
|
|
|
digit_sum_down(N, S2),
|
|
|
write('digit_sum для '), write(N), write(': up='), write(S1), write(', down='), write(S2),
|
|
|
write(', ожидалось='), write(ExpectedSum),
|
|
|
((S1 =:= ExpectedSum, S2 =:= ExpectedSum) -> write(' ✓') ; write(' ✗')), nl.
|
|
|
|
|
|
test_digit_sum_equivalence([]).
|
|
|
test_digit_sum_equivalence([N|Rest]) :-
|
|
|
digit_sum_up(N, S1),
|
|
|
digit_sum_down(N, S2),
|
|
|
(S1 =:= S2 ->
|
|
|
write('✓ Суммы цифр '), write(N), write(' эквивалентны') ;
|
|
|
write('✗ Суммы цифр '), write(N), write(' НЕ эквивалентны')), nl,
|
|
|
test_digit_sum_equivalence(Rest).
|
|
|
|
|
|
% ===============================================
|
|
|
% ТЕСТЫ ДЛЯ SQUARE_FREE
|
|
|
% ===============================================
|
|
|
test_square_free :-
|
|
|
write('--- Тестирование square_free ---'), nl,
|
|
|
|
|
|
% Числа, свободные от квадратов
|
|
|
SquareFreeNumbers = [1, 2, 3, 5, 6, 7, 10, 11, 13, 14, 15],
|
|
|
forall(member(N, SquareFreeNumbers), test_square_free_positive(N)),
|
|
|
|
|
|
% Числа, НЕ свободные от квадратов
|
|
|
NonSquareFreeNumbers = [4, 8, 9, 12, 16, 18, 20, 24, 25, 27],
|
|
|
forall(member(N, NonSquareFreeNumbers), test_square_free_negative(N)),
|
|
|
nl.
|
|
|
|
|
|
test_square_free_positive(N) :-
|
|
|
(square_free(N) ->
|
|
|
write('✓ '), write(N), write(' корректно определено как свободное от квадратов') ;
|
|
|
write('✗ '), write(N), write(' ошибочно определено как НЕ свободное от квадратов')), nl.
|
|
|
|
|
|
test_square_free_negative(N) :-
|
|
|
(\+ square_free(N) ->
|
|
|
write('✓ '), write(N), write(' корректно определено как НЕ свободное от квадратов') ;
|
|
|
write('✗ '), write(N), write(' ошибочно определено как свободное от квадратов')), nl.
|
|
|
|
|
|
% ===============================================
|
|
|
% ТЕСТЫ ДЛЯ ОПЕРАЦИЙ СО СПИСКАМИ
|
|
|
% ===============================================
|
|
|
test_list_operations :-
|
|
|
write('--- Тестирование операций со списками ---'), nl,
|
|
|
|
|
|
% Тест пустого списка
|
|
|
(sum_list_down([], 0) ->
|
|
|
write('✓ sum_list_down([],0) - ПРОЙДЕН') ;
|
|
|
write('✗ sum_list_down([],0) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
(sum_list_up([], 0) ->
|
|
|
write('✓ sum_list_up([],0) - ПРОЙДЕН') ;
|
|
|
write('✗ sum_list_up([],0) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест одного элемента
|
|
|
(sum_list_down([5], 5) ->
|
|
|
write('✓ sum_list_down([5],5) - ПРОЙДЕН') ;
|
|
|
write('✗ sum_list_down([5],5) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
(sum_list_up([5], 5) ->
|
|
|
write('✓ sum_list_up([5],5) - ПРОЙДЕН') ;
|
|
|
write('✗ sum_list_up([5],5) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест различных списков
|
|
|
TestLists = [
|
|
|
([1, 2, 3], 6),
|
|
|
([10, 20, 30], 60),
|
|
|
([-1, 1, -2, 2], 0),
|
|
|
([0, 0, 0], 0),
|
|
|
([100], 100)
|
|
|
],
|
|
|
forall(member((List, ExpectedSum), TestLists), test_list_sum(List, ExpectedSum)),
|
|
|
|
|
|
% Тест эквивалентности рекурсий
|
|
|
test_list_sum_equivalence([
|
|
|
[],
|
|
|
[1],
|
|
|
[1, 2],
|
|
|
[1, 2, 3],
|
|
|
[1, 2, 3, 4, 5],
|
|
|
[-1, -2, -3],
|
|
|
[0, 0, 0, 0]
|
|
|
]),
|
|
|
nl.
|
|
|
|
|
|
test_list_sum(List, ExpectedSum) :-
|
|
|
sum_list_down(List, S1),
|
|
|
sum_list_up(List, S2),
|
|
|
write('Сумма '), write(List), write(': down='), write(S1), write(', up='), write(S2),
|
|
|
write(', ожидалось='), write(ExpectedSum),
|
|
|
((S1 =:= ExpectedSum, S2 =:= ExpectedSum) -> write(' ✓') ; write(' ✗')), nl.
|
|
|
|
|
|
test_list_sum_equivalence([]).
|
|
|
test_list_sum_equivalence([List|Rest]) :-
|
|
|
sum_list_down(List, S1),
|
|
|
sum_list_up(List, S2),
|
|
|
(S1 =:= S2 ->
|
|
|
write('✓ Суммы списка '), write(List), write(' эквивалентны') ;
|
|
|
write('✗ Суммы списка '), write(List), write(' НЕ эквивалентны')), nl,
|
|
|
test_list_sum_equivalence(Rest).
|
|
|
|
|
|
% ===============================================
|
|
|
% ТЕСТЫ ДЛЯ УДАЛЕНИЯ ПО СУММЕ ЦИФР
|
|
|
% ===============================================
|
|
|
test_remove_by_digit_sum :-
|
|
|
write('--- Тестирование remove_by_digit_sum ---'), nl,
|
|
|
|
|
|
% Тест пустого списка
|
|
|
(remove_by_digit_sum([], 5, []) ->
|
|
|
write('✓ remove_by_digit_sum([],5,[]) - ПРОЙДЕН') ;
|
|
|
write('✗ remove_by_digit_sum([],5,[]) - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест удаления всех элементов
|
|
|
remove_by_digit_sum([11, 20, 101, 110], 2, Result1),
|
|
|
(Result1 = [] ->
|
|
|
write('✓ Удаление всех элементов с суммой цифр 2 - ПРОЙДЕН') ;
|
|
|
write('✗ Удаление всех элементов с суммой цифр 2 - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест удаления части элементов
|
|
|
remove_by_digit_sum([12, 21, 34, 43, 50], 3, Result2),
|
|
|
Expected2 = [34, 43, 50],
|
|
|
(Result2 = Expected2 ->
|
|
|
write('✓ Частичное удаление элементов - ПРОЙДЕН') ;
|
|
|
write('✗ Частичное удаление элементов - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Тест с нецелыми элементами
|
|
|
remove_by_digit_sum([12, abc, 21, -5, 30], 3, Result3),
|
|
|
Expected3 = [abc, -5],
|
|
|
(Result3 = Expected3 ->
|
|
|
write('✓ Обработка нецелых элементов - ПРОЙДЕН') ;
|
|
|
write('✗ Обработка нецелых элементов - ПРОВАЛЕН')), nl,
|
|
|
|
|
|
% Дополнительные тесты
|
|
|
TestCases = [
|
|
|
(([123, 456, 789], 6), [456, 789]),
|
|
|
(([1, 11, 111, 1111], 1), [11, 111]),
|
|
|
(([0, 10, 100, 1000], 1), [0]),
|
|
|
(([999, 888, 777], 27), [888, 777])
|
|
|
],
|
|
|
forall(member(((List, TargetSum), Expected), TestCases),
|
|
|
test_remove_case(List, TargetSum, Expected)),
|
|
|
nl.
|
|
|
|
|
|
test_remove_case(List, TargetSum, Expected) :-
|
|
|
remove_by_digit_sum(List, TargetSum, Result),
|
|
|
write('remove_by_digit_sum('), write(List), write(', '), write(TargetSum), write(') = '),
|
|
|
write(Result), write(', ожидалось: '), write(Expected),
|
|
|
(Result = Expected -> write(' ✓') ; write(' ✗')), nl.
|
|
|
|
|
|
% ===============================================
|
|
|
% ДОПОЛНИТЕЛЬНЫЕ ТЕСТЫ
|
|
|
% ===============================================
|
|
|
|
|
|
% Тест производительности
|
|
|
performance_test :-
|
|
|
write('--- Тест производительности ---'), nl,
|
|
|
|
|
|
write('Тестирование факториала для больших чисел:'), nl,
|
|
|
TestNumbers = [10, 15, 20],
|
|
|
forall(member(N, TestNumbers), test_factorial_performance(N)),
|
|
|
|
|
|
write('Тестирование суммы цифр для больших чисел:'), nl,
|
|
|
BigNumbers = [12345, 123456, 1234567],
|
|
|
forall(member(N, BigNumbers), test_digit_sum_performance(N)),
|
|
|
nl.
|
|
|
|
|
|
test_factorial_performance(N) :-
|
|
|
get_time(T1),
|
|
|
fact_up(N, F1),
|
|
|
get_time(T2),
|
|
|
fact_down(N, F2),
|
|
|
get_time(T3),
|
|
|
|
|
|
TimeUp is T2 - T1,
|
|
|
TimeDown is T3 - T2,
|
|
|
|
|
|
write('Факториал '), write(N), write(': up='), write(TimeUp),
|
|
|
write('с, down='), write(TimeDown), write('с, результат='), write(F1),
|
|
|
(F1 =:= F2 -> write(' ✓') ; write(' ✗')), nl.
|
|
|
|
|
|
test_digit_sum_performance(N) :-
|
|
|
get_time(T1),
|
|
|
digit_sum_up(N, S1),
|
|
|
get_time(T2),
|
|
|
digit_sum_down(N, S2),
|
|
|
get_time(T3),
|
|
|
|
|
|
TimeUp is T2 - T1,
|
|
|
TimeDown is T3 - T2,
|
|
|
|
|
|
write('Сумма цифр '), write(N), write(': up='), write(TimeUp),
|
|
|
write('с, down='), write(TimeDown), write('с, результат='), write(S1),
|
|
|
(S1 =:= S2 -> write(' ✓') ; write(' ✗')), nl.
|
|
|
|
|
|
% Стресс-тест
|
|
|
stress_test :-
|
|
|
write('--- Стресс-тест ---'), nl,
|
|
|
|
|
|
write('Тестирование 100 случайных чисел для square_free:'), nl,
|
|
|
stress_test_square_free(100),
|
|
|
|
|
|
write('Тестирование 50 случайных списков для sum_list:'), nl,
|
|
|
stress_test_list_sum(50),
|
|
|
nl.
|
|
|
|
|
|
stress_test_square_free(0) :- !.
|
|
|
stress_test_square_free(N) :-
|
|
|
N > 0,
|
|
|
random(1, 100, TestNumber),
|
|
|
(square_free(TestNumber) -> Result = 'free' ; Result = 'not_free'),
|
|
|
(N mod 10 =:= 0 ->
|
|
|
(write('Тест '), write(N), write(': '), write(TestNumber), write(' - '), write(Result), nl)
|
|
|
; true),
|
|
|
N1 is N - 1,
|
|
|
stress_test_square_free(N1).
|
|
|
|
|
|
stress_test_list_sum(0) :- !.
|
|
|
stress_test_list_sum(N) :-
|
|
|
N > 0,
|
|
|
random(1, 10, ListLength),
|
|
|
generate_random_list(ListLength, TestList),
|
|
|
sum_list_down(TestList, S1),
|
|
|
sum_list_up(TestList, S2),
|
|
|
(N mod 10 =:= 0 ->
|
|
|
(write('Тест '), write(N), write(': '), write(TestList),
|
|
|
write(' - суммы равны: '), (S1 =:= S2 -> write('да') ; write('нет')), nl)
|
|
|
; true),
|
|
|
N1 is N - 1,
|
|
|
stress_test_list_sum(N1).
|
|
|
|
|
|
generate_random_list(0, []) :- !.
|
|
|
generate_random_list(N, [H|T]) :-
|
|
|
N > 0,
|
|
|
random(0, 100, H),
|
|
|
N1 is N - 1,
|
|
|
generate_random_list(N1, T). |
