%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 1997-2016. All Rights Reserved. %% %% Licensed under the Apache License, Version 2.0 (the "License"); %% you may not use this file except in compliance with the License. %% You may obtain a copy of the License at %% %% http://www.apache.org/licenses/LICENSE-2.0 %% %% Unless required by applicable law or agreed to in writing, software %% distributed under the License is distributed on an "AS IS" BASIS, %% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %% See the License for the specific language governing permissions and %% limitations under the License. %% %% %CopyrightEnd% %% %%%---------------------------------------------------------------- %%% Purpose:Stdlib application test suite. %%%----------------------------------------------------------------- -module(stdlib_SUITE). -include_lib("common_test/include/ct.hrl"). -compile(export_all). %% %% all/1 %% suite() -> [{ct_hooks,[ts_install_cth]}]. all() -> [app_test, appup_test, assert_test]. init_per_suite(Config) -> Config. end_per_suite(_Config) -> ok. init_per_group(_GroupName, Config) -> Config. end_per_group(_GroupName, Config) -> Config. init_per_testcase(_Case, Config) -> Config. end_per_testcase(_Case, _Config) -> ok. %% %% Test cases starts here. %% %% Application consistency test. app_test(Config) when is_list(Config) -> test_server:app_test(stdlib), ok. %% Test that appup allows upgrade from/downgrade to a maximum of one %% major release back. appup_test(_Config) -> appup_tests(stdlib,create_test_vsns(stdlib)). appup_tests(_App,{[],[]}) -> {skip,"no previous releases available"}; appup_tests(App,{OkVsns0,NokVsns}) -> application:load(App), {_,_,Vsn} = lists:keyfind(App,1,application:loaded_applications()), AppupFileName = atom_to_list(App) ++ ".appup", AppupFile = filename:join([code:lib_dir(App),ebin,AppupFileName]), {ok,[{Vsn,UpFrom,DownTo}=AppupScript]} = file:consult(AppupFile), ct:log("~p~n",[AppupScript]), OkVsns = case OkVsns0 -- [Vsn] of OkVsns0 -> OkVsns0; Ok -> ct:log("Current version, ~p, is same as in previous release.~n" "Removing this from the list of ok versions.", [Vsn]), Ok end, ct:log("Testing that appup allows upgrade from these versions: ~p~n", [OkVsns]), check_appup(OkVsns,UpFrom,{ok,[restart_new_emulator]}), check_appup(OkVsns,DownTo,{ok,[restart_new_emulator]}), ct:log("Testing that appup does not allow upgrade from these versions: ~p~n", [NokVsns]), check_appup(NokVsns,UpFrom,error), check_appup(NokVsns,DownTo,error), ok. create_test_vsns(App) -> ThisMajor = erlang:system_info(otp_release), FirstMajor = previous_major(ThisMajor), SecondMajor = previous_major(FirstMajor), Ok = app_vsn(App,[ThisMajor,FirstMajor]), Nok0 = app_vsn(App,[SecondMajor]), Nok = case Ok of [Ok1|_] -> [Ok1 ++ ",1" | Nok0]; % illegal _ -> Nok0 end, {Ok,Nok}. previous_major("17") -> "r16b"; previous_major("r16b") -> "r15b"; previous_major(Rel) -> integer_to_list(list_to_integer(Rel)-1). app_vsn(App,[R|Rs]) -> OldRel = case test_server:is_release_available(R) of true -> {release,R}; false -> case ct:get_config({otp_releases,list_to_atom(R)}) of undefined -> false; Prog0 -> case os:find_executable(Prog0) of false -> false; Prog -> {prog,Prog} end end end, case OldRel of false -> app_vsn(App,Rs); _ -> {ok,N} = test_server:start_node(prevrel,peer,[{erl,[OldRel]}]), _ = rpc:call(N,application,load,[App]), As = rpc:call(N,application,loaded_applications,[]), {_,_,V} = lists:keyfind(App,1,As), test_server:stop_node(N), [V|app_vsn(App,Rs)] end; app_vsn(_App,[]) -> []. check_appup([Vsn|Vsns],Instrs,Expected) -> case systools_relup:appup_search_for_version(Vsn, Instrs) of Expected -> check_appup(Vsns,Instrs,Expected); Other -> ct:fail({unexpected_result_for_vsn,Vsn,Other}) end; check_appup([],_,_) -> ok. -include_lib("stdlib/include/assert.hrl"). -include_lib("stdlib/include/assert.hrl"). % test repeated inclusion %% Assert macros test. assert_test(_Config) -> ok = ?assert(true), {'EXIT',{{assert, _},_}} = (catch ?assert(false)), {'EXIT',{{assert, Info1},_}} = (catch ?assert(0)), {not_boolean,0} = lists:keyfind(not_boolean,1,Info1), ok = ?assertNot(false), {'EXIT',{{assert, _},_}} = (catch ?assertNot(true)), {'EXIT',{{assert, Info2},_}} = (catch ?assertNot(0)), {not_boolean,0} = lists:keyfind(not_boolean,1,Info2), ok = ?assertMatch({foo,_}, {foo,bar}), {'EXIT',{{assertMatch,_},_}} = (catch ?assertMatch({foo,_}, {foo})), ok = ?assertMatch({foo,N} when N > 0, {foo,1}), {'EXIT',{{assertMatch,_},_}} = (catch ?assertMatch({foo,N} when N > 0, {foo,0})), ok = ?assertNotMatch({foo,_}, {foo,bar,baz}), {'EXIT',{{assertNotMatch,_},_}} = (catch ?assertNotMatch({foo,_}, {foo,baz})), ok = ?assertNotMatch({foo,N} when N > 0, {foo,0}), {'EXIT',{{assertNotMatch,_},_}} = (catch ?assertNotMatch({foo,N} when N > 0, {foo,1})), ok = ?assertEqual(1.0, 1.0), {'EXIT',{{assertEqual,_},_}} = (catch ?assertEqual(1, 1.0)), ok = ?assertNotEqual(1, 1.0), {'EXIT',{{assertNotEqual,_},_}} = (catch ?assertNotEqual(1.0, 1.0)), ok = ?assertException(error, badarith, 1/0), ok = ?assertException(exit, foo, exit(foo)), ok = ?assertException(throw, foo, throw(foo)), ok = ?assertException(throw, {foo,_}, throw({foo,bar})), ok = ?assertException(throw, {foo,N} when N > 0, throw({foo,1})), {'EXIT',{{assertException,Why1},_}} = (catch ?assertException(error, badarith, 0/1)), true = lists:keymember(unexpected_success,1,Why1), {'EXIT',{{assertException,Why2},_}} = (catch ?assertException(error, badarith, 1/length(0))), true = lists:keymember(unexpected_exception,1,Why2), {'EXIT',{{assertException,Why3},_}} = (catch ?assertException(throw, {foo,N} when N > 0, throw({foo,0}))), true = lists:keymember(unexpected_exception,1,Why3), ok = ?assertNotException(throw, {foo,baz}, throw({foo,bar})), {'EXIT',{{assertNotException,Why4},_}} = (catch ?assertNotException(throw, {foo,bar}, throw({foo,bar}))), true = lists:keymember(unexpected_exception,1,Why4), ok = ?assertError(badarith, 1/0), ok = ?assertExit(foo, exit(foo)), ok = ?assertThrow(foo, throw(foo)), ok.