aboutsummaryrefslogtreecommitdiffstats
path: root/lib/os_mon/test/memsup_SUITE.erl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/os_mon/test/memsup_SUITE.erl')
-rw-r--r--lib/os_mon/test/memsup_SUITE.erl914
1 files changed, 436 insertions, 478 deletions
diff --git a/lib/os_mon/test/memsup_SUITE.erl b/lib/os_mon/test/memsup_SUITE.erl
index 904c9b95b0..ed78b1ab1c 100644
--- a/lib/os_mon/test/memsup_SUITE.erl
+++ b/lib/os_mon/test/memsup_SUITE.erl
@@ -21,7 +21,7 @@
-include_lib("common_test/include/ct.hrl").
%% Test server specific exports
--export([all/0, suite/0,groups/0,init_per_group/2,end_per_group/2]).
+-export([all/0, suite/0]).
-export([init_per_suite/1, end_per_suite/1]).
-export([init_per_testcase/2, end_per_testcase/2]).
@@ -30,384 +30,362 @@
-export([config/1, timeout/1, unavailable/1, port/1]).
-export([otp_5910/1]).
-%% Default timetrap timeout (set in init_per_testcase)
--define(default_timeout, ?t:minutes(1)).
-
init_per_suite(Config) when is_list(Config) ->
- ?line ok = application:start(os_mon),
+ ok = application:start(os_mon),
Config.
end_per_suite(Config) when is_list(Config) ->
- ?line ok = application:stop(os_mon),
+ ok = application:stop(os_mon),
Config.
init_per_testcase(_Case, Config) ->
- Dog = ?t:timetrap(?default_timeout),
- [{watchdog,Dog} | Config].
-
-end_per_testcase(_Case, Config) ->
- Dog = ?config(watchdog, Config),
- ?t:timetrap_cancel(Dog),
Config.
-suite() -> [{ct_hooks,[ts_install_cth]}].
+end_per_testcase(_Case, _Config) ->
+ ok.
+
+suite() ->
+ [{ct_hooks,[ts_install_cth]},
+ {timetrap,{minutes,1}}].
all() ->
All = case test_server:os_type() of
- {unix, sunos} ->
- [api, alarm1, alarm2, process, config, timeout,
- unavailable, port];
- {unix, linux} ->
- [api, alarm1, alarm2, process, timeout];
- _OS -> [api, alarm1, alarm2, process]
- end,
+ {unix, sunos} ->
+ [api, alarm1, alarm2, process, config, timeout,
+ unavailable, port];
+ {unix, linux} ->
+ [api, alarm1, alarm2, process, timeout];
+ _OS -> [api, alarm1, alarm2, process]
+ end,
Bugs = [otp_5910],
All ++ Bugs.
-groups() ->
- [].
-
-init_per_group(_GroupName, Config) ->
- Config.
-
-end_per_group(_GroupName, Config) ->
- Config.
-
-api(suite) ->
- [];
-api(doc) ->
- ["Test of API functions"];
+%% Test of API functions
api(Config) when is_list(Config) ->
%% get_memory_data()
- ?line RegMemData = memsup:get_memory_data(),
+ RegMemData = memsup:get_memory_data(),
case RegMemData of
- {TotMem, AllBytes, {Pid, PidBytes}} when is_integer(TotMem),
- is_integer(AllBytes),
- is_pid(Pid),
- is_integer(PidBytes) ->
- ok;
- {0, 0, _WorstPid} ->
- ?line ?t:fail(first_data_collection_failed);
- _ ->
- ?line ?t:fail({bad_return, RegMemData})
+ {TotMem, AllBytes, {Pid, PidBytes}} when is_integer(TotMem),
+ is_integer(AllBytes),
+ is_pid(Pid),
+ is_integer(PidBytes) ->
+ ok;
+ {0, 0, _WorstPid} ->
+ ct:fail(first_data_collection_failed);
+ _ ->
+ ct:fail({bad_return, RegMemData})
end,
%% get_system_memory_data()
- ?line ExtMemData = memsup:get_system_memory_data(),
- Tags = [ total_memory,
- free_memory,
- system_total_memory,
- largest_free,
- number_of_free,
- free_swap,
- total_swap,
- cached_memory,
- buffered_memory,
- shared_memory],
-
- ?line true = lists:all(fun({Tag,Value}) when is_atom(Tag),
- is_integer(Value) ->
- lists:member(Tag, Tags);
- (_) ->
- false
- end,
- ExtMemData),
+ ExtMemData = memsup:get_system_memory_data(),
+ Tags = [total_memory,
+ free_memory,
+ system_total_memory,
+ largest_free,
+ number_of_free,
+ free_swap,
+ total_swap,
+ cached_memory,
+ buffered_memory,
+ shared_memory],
+
+ true = lists:all(fun({Tag,Value}) when is_atom(Tag),
+ is_integer(Value) ->
+ lists:member(Tag, Tags);
+ (_) ->
+ false
+ end, ExtMemData),
%% get_os_wordsize()
- ?line ok = case memsup:get_os_wordsize() of
- 32 -> ok;
- 64 -> ok;
- unsupported_os -> ok;
- _ -> error
- end,
+ ok = case memsup:get_os_wordsize() of
+ 32 -> ok;
+ 64 -> ok;
+ unsupported_os -> ok;
+ _ -> error
+ end,
%% get_check_interval()
- ?line 60000 = memsup:get_check_interval(),
+ 60000 = memsup:get_check_interval(),
%% set_check_interval(Minutes)
- ?line ok = memsup:set_check_interval(2),
- ?line 120000 = memsup:get_check_interval(),
- ?line {'EXIT',{badarg,_}} =
- (catch memsup:set_check_interval(0.2)),
- ?line 120000 = memsup:get_check_interval(),
- ?line ok = memsup:set_check_interval(1),
+ ok = memsup:set_check_interval(2),
+ 120000 = memsup:get_check_interval(),
+ {'EXIT',{badarg,_}} =
+ (catch memsup:set_check_interval(0.2)),
+ 120000 = memsup:get_check_interval(),
+ ok = memsup:set_check_interval(1),
%% get_procmem_high_watermark()
- ?line 5 = memsup:get_procmem_high_watermark(),
+ 5 = memsup:get_procmem_high_watermark(),
%% set_procmem_high_watermark()
- ?line ok = memsup:set_procmem_high_watermark(0.1),
- ?line 10 = memsup:get_procmem_high_watermark(),
- ?line {'EXIT',{badarg,_}} =
- (catch memsup:set_procmem_high_watermark(-0.1)),
- ?line 10 = memsup:get_procmem_high_watermark(),
- ?line ok = memsup:set_procmem_high_watermark(0.05),
+ ok = memsup:set_procmem_high_watermark(0.1),
+ 10 = memsup:get_procmem_high_watermark(),
+ {'EXIT',{badarg,_}} =
+ (catch memsup:set_procmem_high_watermark(-0.1)),
+ 10 = memsup:get_procmem_high_watermark(),
+ ok = memsup:set_procmem_high_watermark(0.05),
%% get_sysmem_high_watermark()
- ?line 80 = memsup:get_sysmem_high_watermark(),
+ 80 = memsup:get_sysmem_high_watermark(),
%% set_sysmem_high_watermark()
- ?line ok = memsup:set_sysmem_high_watermark(0.9),
- ?line 90 = memsup:get_sysmem_high_watermark(),
- ?line {'EXIT',{badarg,_}} =
- (catch memsup:set_sysmem_high_watermark(-0.9)),
- ?line 90 = memsup:get_sysmem_high_watermark(),
- ?line ok = memsup:set_sysmem_high_watermark(0.8),
+ ok = memsup:set_sysmem_high_watermark(0.9),
+ 90 = memsup:get_sysmem_high_watermark(),
+ {'EXIT',{badarg,_}} =
+ (catch memsup:set_sysmem_high_watermark(-0.9)),
+ 90 = memsup:get_sysmem_high_watermark(),
+ ok = memsup:set_sysmem_high_watermark(0.8),
%% get|set_helper_timeout
- ?line 30 = memsup:get_helper_timeout(),
- ?line ok = memsup:set_helper_timeout(29),
- ?line 29 = memsup:get_helper_timeout(),
- ?line {'EXIT',{badarg,_}} = (catch memsup:set_helper_timeout(31.0)),
- ?line 29 = memsup:get_helper_timeout(),
+ 30 = memsup:get_helper_timeout(),
+ ok = memsup:set_helper_timeout(29),
+ 29 = memsup:get_helper_timeout(),
+ {'EXIT',{badarg,_}} = (catch memsup:set_helper_timeout(31.0)),
+ 29 = memsup:get_helper_timeout(),
ok.
%%----------------------------------------------------------------------
%% NOTE: The test case is a bit weak as it will fail if the memory
%% usage changes too much during its course.
%%----------------------------------------------------------------------
-alarm1(suite) ->
- [];
-alarm1(doc) ->
- ["Test alarms when memsup_system_only==false"];
+
+%% Test alarms when memsup_system_only==false
alarm1(Config) when is_list(Config) ->
%% If system memory usage is too high, the testcase cannot
%% be run correctly
- ?line {Total, Alloc, {_Pid,_PidAlloc}} = memsup:get_memory_data(),
+ {Total, Alloc, {_Pid,_PidAlloc}} = memsup:get_memory_data(),
io:format("alarm1: Total: ~p, Alloc: ~p~n", [Total, Alloc]),
- ?line SysUsage = Alloc/Total,
+ SysUsage = Alloc/Total,
if
- SysUsage>0.99 ->
- {skip, sys_mem_too_high};
- true ->
- alarm1(Config, SysUsage)
+ SysUsage > 0.99 ->
+ {skip, sys_mem_too_high};
+ true ->
+ alarm1(Config, SysUsage)
end.
alarm1(_Config, SysUsage) ->
%% Set a long memory check interval, we will force memory checks
%% instead
- ?line ok = memsup:set_check_interval(60),
+ ok = memsup:set_check_interval(60),
%% Check thresholds
- ?line SysThreshold = (memsup:get_sysmem_high_watermark()/100),
- ?line ProcThreshold = (memsup:get_procmem_high_watermark()/100),
+ SysThreshold = (memsup:get_sysmem_high_watermark()/100),
+ ProcThreshold = (memsup:get_procmem_high_watermark()/100),
%% Check if a system alarm already should be set or not
SysP = if
- SysUsage>SysThreshold -> true;
- SysUsage=<SysThreshold -> false
- end,
+ SysUsage>SysThreshold -> true;
+ SysUsage=<SysThreshold -> false
+ end,
%% If system memory is higher than threshold, make sure the system
%% alarm is set. Otherwise, make sure it is not set
case alarm_set(system_memory_high_watermark) of
- {true, []} when SysP ->
- ok;
- false when not SysP ->
- ok;
- _ ->
- ?line ?t:fail({sys_alarm, SysUsage, SysThreshold})
+ {true, []} when SysP ->
+ ok;
+ false when not SysP ->
+ ok;
+ _ ->
+ ct:fail({sys_alarm, SysUsage, SysThreshold})
end,
%% Lower/raise the threshold to clear/set the alarm
NewSysThreshold = if
- SysP ->
- Value = 1.1*SysUsage,
- if
- Value > 0.99 -> 0.99;
- true -> Value
- end;
- not SysP -> 0.9*SysUsage
- end,
+ SysP ->
+ Value = 1.1*SysUsage,
+ if
+ Value > 0.99 -> 0.99;
+ true -> Value
+ end;
+ not SysP -> 0.9*SysUsage
+ end,
- ?line ok = memsup:set_sysmem_high_watermark(NewSysThreshold),
+ ok = memsup:set_sysmem_high_watermark(NewSysThreshold),
%% Initiate and wait for a new data collection
- ?line ok = force_collection(),
+ ok = force_collection(),
%% Make sure the alarm is cleared/set
- ?t:sleep(?t:seconds(5)),
+ ct:sleep({seconds,5}),
case alarm_set(system_memory_high_watermark) of
- {true, []} when not SysP ->
- ok;
- false when SysP ->
- ok;
- _ ->
- ?line ?t:fail({sys_alarm, SysUsage, NewSysThreshold})
+ {true, []} when not SysP ->
+ ok;
+ false when SysP ->
+ ok;
+ _ ->
+ ct:fail({sys_alarm, SysUsage, NewSysThreshold})
end,
%% Reset the threshold to set/clear the alarm again
- ?line ok = memsup:set_sysmem_high_watermark(SysThreshold),
- ?line ok = force_collection(),
- ?t:sleep(?t:seconds(1)),
+ ok = memsup:set_sysmem_high_watermark(SysThreshold),
+ ok = force_collection(),
+ ct:sleep({seconds,1}),
case alarm_set(system_memory_high_watermark) of
- {true, []} when SysP ->
- ok;
- false when not SysP ->
- ok;
- _ ->
- ?line ?t:fail({sys_alarm, SysUsage, SysThreshold})
+ {true, []} when SysP ->
+ ok;
+ false when not SysP ->
+ ok;
+ _ ->
+ ct:fail({sys_alarm, SysUsage, SysThreshold})
end,
%% Check memory usage
- ?line {Total2, _, {WorstPid, PidAlloc}} = memsup:get_memory_data(),
+ {Total2, _, {WorstPid, PidAlloc}} = memsup:get_memory_data(),
%% Check if a process alarm already should be set or not
PidUsage = PidAlloc/Total2,
ProcP = if
- PidUsage>ProcThreshold -> true;
- PidUsage=<ProcThreshold -> false
- end,
+ PidUsage>ProcThreshold -> true;
+ PidUsage=<ProcThreshold -> false
+ end,
%% Make sure the process alarm is set/not set accordingly
case alarm_set(process_memory_high_watermark) of
- {true, WorstPid} when ProcP ->
- ok;
- false when not ProcP ->
- ok;
- {true, BadPid1} when ProcP ->
- ?line ?t:fail({proc_alarm, WorstPid, BadPid1});
- _ ->
- ?line ?t:fail({proc_alarm, PidUsage, ProcThreshold})
+ {true, WorstPid} when ProcP ->
+ ok;
+ false when not ProcP ->
+ ok;
+ {true, BadPid1} when ProcP ->
+ ct:fail({proc_alarm, WorstPid, BadPid1});
+ _ ->
+ ct:fail({proc_alarm, PidUsage, ProcThreshold})
end,
%% Lower/raise the threshold to clear/set the alarm
NewProcThreshold = if
- ProcP -> 1.1*PidUsage;
- not ProcP -> 0.9*PidUsage
- end,
- ?line ok = memsup:set_procmem_high_watermark(NewProcThreshold),
- ?line ok = force_collection(),
- ?t:sleep(?t:seconds(1)),
+ ProcP -> 1.1*PidUsage;
+ not ProcP -> 0.9*PidUsage
+ end,
+ ok = memsup:set_procmem_high_watermark(NewProcThreshold),
+ ok = force_collection(),
+ ct:sleep({seconds,1}),
case alarm_set(process_memory_high_watermark) of
- {true, WorstPid} when not ProcP ->
- ok;
- false when ProcP ->
- ok;
- {true, BadPid2} when not ProcP ->
- ?line test_server:fail({proc_alarm, WorstPid, BadPid2});
- _ ->
- ?line ?t:fail({proc_alarm, PidUsage, ProcThreshold})
+ {true, WorstPid} when not ProcP ->
+ ok;
+ false when ProcP ->
+ ok;
+ {true, BadPid2} when not ProcP ->
+ ct:fail({proc_alarm, WorstPid, BadPid2});
+ _ ->
+ ct:fail({proc_alarm, PidUsage, ProcThreshold})
end,
%% Reset the threshold to clear/set the alarm
- ?line ok = memsup:set_procmem_high_watermark(ProcThreshold),
- ?line ok = force_collection(),
- ?t:sleep(?t:seconds(1)),
+ ok = memsup:set_procmem_high_watermark(ProcThreshold),
+ ok = force_collection(),
+ ct:sleep({seconds,1}),
case alarm_set(process_memory_high_watermark) of
- {true, WorstPid} when ProcP ->
- ok;
- false when not ProcP ->
- ok;
- {true, BadPid3} when ProcP ->
- ?line test_server:fail({proc_alarm, WorstPid, BadPid3});
- _ ->
- ?line ?t:fail({proc_alarm, PidUsage, ProcThreshold})
+ {true, WorstPid} when ProcP ->
+ ok;
+ false when not ProcP ->
+ ok;
+ {true, BadPid3} when ProcP ->
+ ct:fail({proc_alarm, WorstPid, BadPid3});
+ _ ->
+ ct:fail({proc_alarm, PidUsage, ProcThreshold})
end,
%% Reset memory check interval
- ?line ok = memsup:set_check_interval(1),
+ ok = memsup:set_check_interval(1),
ok.
-alarm2(suite) ->
- [];
-alarm2(doc) ->
- ["Test alarms when memsup_system_only==true"];
+%% Test alarms when memsup_system_only==true
alarm2(Config) when is_list(Config) ->
%% If system memory usage is too high, the testcase cannot
%% be run correctly
- ?line {Total, Alloc, {_Pid,_PidAlloc}} = memsup:get_memory_data(),
- ?line SysUsage = Alloc/Total,
+ {Total, Alloc, {_Pid,_PidAlloc}} = memsup:get_memory_data(),
+ SysUsage = Alloc/Total,
if
- SysUsage>0.99 ->
- {skip, sys_mem_too_high};
- true ->
- alarm2(Config, SysUsage)
+ SysUsage>0.99 ->
+ {skip, sys_mem_too_high};
+ true ->
+ alarm2(Config, SysUsage)
end.
alarm2(_Config, _SysUsage) ->
%% Change memsup_system_only and restart memsup
- ?line ok = application:set_env(os_mon, memsup_system_only, true),
- ?line ok = supervisor:terminate_child(os_mon_sup, memsup),
- ?line {ok, _Memsup1} = supervisor:restart_child(os_mon_sup, memsup),
+ ok = application:set_env(os_mon, memsup_system_only, true),
+ ok = supervisor:terminate_child(os_mon_sup, memsup),
+ {ok, _Memsup1} = supervisor:restart_child(os_mon_sup, memsup),
%% Set a long memory check interval, we will force memory checks
%% instead
- ?line ok = memsup:set_check_interval(60),
+ ok = memsup:set_check_interval(60),
%% Check data and thresholds
- ?line {Total, Alloc, undefined} = memsup:get_memory_data(),
- ?line SysThreshold = (memsup:get_sysmem_high_watermark()/100),
- ?line true = is_integer(memsup:get_procmem_high_watermark()),
+ {Total, Alloc, undefined} = memsup:get_memory_data(),
+ SysThreshold = (memsup:get_sysmem_high_watermark()/100),
+ true = is_integer(memsup:get_procmem_high_watermark()),
%% Check if a system alarm already should be set or not
- ?line SysUsage = Alloc/Total,
+ SysUsage = Alloc/Total,
SysP = if
- SysUsage>SysThreshold -> true;
- SysUsage=<SysThreshold -> false
- end,
+ SysUsage>SysThreshold -> true;
+ SysUsage=<SysThreshold -> false
+ end,
%% If system memory is higher than threshold, make sure the system
%% alarm is set. Otherwise, make sure it is not set
case alarm_set(system_memory_high_watermark) of
- {true, []} when SysP ->
- ok;
- false when not SysP ->
- ok;
- _ ->
- ?line ?t:fail({sys_alarm, SysUsage, SysThreshold})
+ {true, []} when SysP ->
+ ok;
+ false when not SysP ->
+ ok;
+ _ ->
+ ct:fail({sys_alarm, SysUsage, SysThreshold})
end,
%% Lower/raise the threshold to clear/set the alarm
NewSysThreshold = if
- SysP ->
- Value = 1.1*SysUsage,
- if
- Value > 0.99 -> 0.99;
- true -> Value
- end;
- not SysP -> 0.9*SysUsage
- end,
+ SysP ->
+ Value = 1.1*SysUsage,
+ if
+ Value > 0.99 -> 0.99;
+ true -> Value
+ end;
+ not SysP -> 0.9*SysUsage
+ end,
- ?line ok = memsup:set_sysmem_high_watermark(NewSysThreshold),
+ ok = memsup:set_sysmem_high_watermark(NewSysThreshold),
%% Initiate and wait for a new data collection
- ?line ok = force_collection(),
+ ok = force_collection(),
%% Make sure the alarm is cleared/set
- ?t:sleep(?t:seconds(1)),
+ ct:sleep({seconds,1}),
case alarm_set(system_memory_high_watermark) of
- {true, []} when not SysP ->
- ok;
- false when SysP ->
- ok;
- _ ->
- ?line ?t:fail({sys_alarm, SysUsage, NewSysThreshold})
+ {true, []} when not SysP ->
+ ok;
+ false when SysP ->
+ ok;
+ _ ->
+ ct:fail({sys_alarm, SysUsage, NewSysThreshold})
end,
%% Reset the threshold to set/clear the alarm again
- ?line ok = memsup:set_sysmem_high_watermark(SysThreshold),
- ?line ok = force_collection(),
- ?t:sleep(?t:seconds(1)),
+ ok = memsup:set_sysmem_high_watermark(SysThreshold),
+ ok = force_collection(),
+ ct:sleep({seconds,1}),
case alarm_set(system_memory_high_watermark) of
- {true, []} when SysP ->
- ok;
- false when not SysP ->
- ok;
- _ ->
- ?line ?t:fail({sys_alarm, SysUsage, SysThreshold})
+ {true, []} when SysP ->
+ ok;
+ false when not SysP ->
+ ok;
+ _ ->
+ ct:fail({sys_alarm, SysUsage, SysThreshold})
end,
%% Reset memsup_system_only and restart memsup
%% (memory check interval is then automatically reset)
- ?line ok = application:set_env(os_mon, memsup_system_only, false),
- ?line ok = supervisor:terminate_child(os_mon_sup, memsup),
- ?line {ok, _Memsup2} = supervisor:restart_child(os_mon_sup, memsup),
+ ok = application:set_env(os_mon, memsup_system_only, false),
+ ok = supervisor:terminate_child(os_mon_sup, memsup),
+ {ok, _Memsup2} = supervisor:restart_child(os_mon_sup, memsup),
ok.
@@ -420,39 +398,36 @@ alarm_set(Alarm, [_|T]) ->
alarm_set(_Alarm, []) ->
false.
-process(suite) ->
- [];
-process(doc) ->
- ["Make sure memsup discovers a process grown very large"];
+%% Make sure memsup discovers a process grown very large
process(Config) when is_list(Config) ->
%% Set a long memory check interval, we will force memory checks
%% instead
- ?line ok = memsup:set_check_interval(60),
+ ok = memsup:set_check_interval(60),
%% Collect data
MemData = memsup:get_memory_data(),
io:format("process: memsup:get_memory_data() = ~p~n", [MemData]),
- ?line {_Total,_Free,{_,Bytes}} = MemData,
+ {_Total,_Free,{_,Bytes}} = MemData,
%% Start a new process larger than Worst
- ?line WorsePid = spawn(fun() -> new_hog(Bytes) end),
- ?t:sleep(?t:seconds(1)),
+ WorsePid = spawn(fun() -> new_hog(Bytes) end),
+ ct:sleep({seconds,1}),
%% Initiate and wait for a new data collection
- ?line ok = force_collection(),
+ ok = force_collection(),
%% Check that get_memory_data() returns updated result
- ?line case memsup:get_memory_data() of
- {_, _, {WorsePid, _MoreBytes}} ->
- ok;
- {_, _, BadWorst} ->
- ?line ?t:fail({worst_pid, BadWorst})
- end,
+ case memsup:get_memory_data() of
+ {_, _, {WorsePid, _MoreBytes}} ->
+ ok;
+ {_, _, BadWorst} ->
+ ct:fail({worst_pid, BadWorst})
+ end,
%% Reset memory check interval
- ?line exit(WorsePid, done),
- ?line ok = memsup:set_check_interval(1),
+ exit(WorsePid, done),
+ ok = memsup:set_check_interval(1),
ok.
new_hog(Bytes) ->
@@ -463,110 +438,101 @@ new_hog(Bytes) ->
new_hog_1(List) ->
receive
- _Any -> exit(List)
+ _Any -> exit(List)
end.
-config(suite) ->
- [];
-config(doc) ->
- ["Test configuration"];
+%% Test configuration
config(Config) when is_list(Config) ->
%% Change configuration parameters and make sure change is reflected
%% when memsup is restarted
- ?line ok = application:set_env(os_mon, memory_check_interval, 2),
- ?line ok =
- application:set_env(os_mon, system_memory_high_watermark, 0.9),
- ?line ok =
- application:set_env(os_mon, process_memory_high_watermark, 0.1),
- ?line ok = application:set_env(os_mon, memsup_helper_timeout, 35),
- ?line ok = application:set_env(os_mon, memsup_system_only, true),
-
- ?line ok = supervisor:terminate_child(os_mon_sup, memsup),
- ?line {ok, _Child1} = supervisor:restart_child(os_mon_sup, memsup),
-
- ?line 120000 = memsup:get_check_interval(),
- ?line 90 = memsup:get_sysmem_high_watermark(),
- ?line 10 = memsup:get_procmem_high_watermark(),
- ?line 35 = memsup:get_helper_timeout(),
+ ok = application:set_env(os_mon, memory_check_interval, 2),
+ ok =
+ application:set_env(os_mon, system_memory_high_watermark, 0.9),
+ ok =
+ application:set_env(os_mon, process_memory_high_watermark, 0.1),
+ ok = application:set_env(os_mon, memsup_helper_timeout, 35),
+ ok = application:set_env(os_mon, memsup_system_only, true),
+
+ ok = supervisor:terminate_child(os_mon_sup, memsup),
+ {ok, _Child1} = supervisor:restart_child(os_mon_sup, memsup),
+
+ 120000 = memsup:get_check_interval(),
+ 90 = memsup:get_sysmem_high_watermark(),
+ 10 = memsup:get_procmem_high_watermark(),
+ 35 = memsup:get_helper_timeout(),
%% Also try this with bad parameter values, should be ignored
- ?line ok = application:set_env(os_mon, memory_check_interval, 0.2),
- ?line ok =
- application:set_env(os_mon, system_memory_high_watermark, -0.9),
- ?line ok =
- application:set_env(os_mon, process_memory_high_watermark,-0.1),
- ?line ok = application:set_env(os_mon, memsup_helper_timeout, 0.35),
- ?line ok = application:set_env(os_mon, memsup_system_only, arne),
-
- ?line ok = supervisor:terminate_child(os_mon_sup, memsup),
- ?line {ok, _Child2} = supervisor:restart_child(os_mon_sup, memsup),
-
- ?line 60000 = memsup:get_check_interval(),
- ?line 80 = memsup:get_sysmem_high_watermark(),
- ?line 5 = memsup:get_procmem_high_watermark(),
- ?line 30 = memsup:get_helper_timeout(),
+ ok = application:set_env(os_mon, memory_check_interval, 0.2),
+ ok =
+ application:set_env(os_mon, system_memory_high_watermark, -0.9),
+ ok =
+ application:set_env(os_mon, process_memory_high_watermark,-0.1),
+ ok = application:set_env(os_mon, memsup_helper_timeout, 0.35),
+ ok = application:set_env(os_mon, memsup_system_only, arne),
+
+ ok = supervisor:terminate_child(os_mon_sup, memsup),
+ {ok, _Child2} = supervisor:restart_child(os_mon_sup, memsup),
+
+ 60000 = memsup:get_check_interval(),
+ 80 = memsup:get_sysmem_high_watermark(),
+ 5 = memsup:get_procmem_high_watermark(),
+ 30 = memsup:get_helper_timeout(),
%% Reset configuration parameters
- ?line ok = application:set_env(os_mon, memory_check_interval, 1),
- ?line ok =
- application:set_env(os_mon, system_memory_high_watermark, 0.8),
- ?line ok =
- application:set_env(os_mon, process_memory_high_watermark,0.05),
- ?line ok = application:set_env(os_mon, memsup_helper_timeout, 30),
- ?line ok = application:set_env(os_mon, memsup_system_only, false),
+ ok = application:set_env(os_mon, memory_check_interval, 1),
+ ok =
+ application:set_env(os_mon, system_memory_high_watermark, 0.8),
+ ok =
+ application:set_env(os_mon, process_memory_high_watermark,0.05),
+ ok = application:set_env(os_mon, memsup_helper_timeout, 30),
+ ok = application:set_env(os_mon, memsup_system_only, false),
ok.
-unavailable(suite) ->
- [];
-unavailable(doc) ->
- ["Test correct behaviour when service is unavailable"];
+%% Test correct behaviour when service is unavailable
unavailable(Config) when is_list(Config) ->
%% Close memsup
- ?line ok = application:set_env(os_mon, start_memsup, false),
- ?line ok = supervisor:terminate_child(os_mon_sup, memsup),
+ ok = application:set_env(os_mon, start_memsup, false),
+ ok = supervisor:terminate_child(os_mon_sup, memsup),
%% Make sure all API functions return their dummy values
- ?line {0,0,{_Pid,0}} = memsup:get_memory_data(),
- ?line ok = application:set_env(os_mon, memsup_system_only, true),
- ?line {0,0,undefined} = memsup:get_memory_data(),
- ?line ok = application:set_env(os_mon, memsup_system_only, false),
- ?line [] = memsup:get_system_memory_data(),
- ?line 0 = memsup:get_os_wordsize(),
- ?line 60000 = memsup:get_check_interval(),
- ?line ok = memsup:set_check_interval(2),
- ?line 5 = memsup:get_procmem_high_watermark(),
- ?line ok = memsup:set_procmem_high_watermark(0.10),
- ?line 80 = memsup:get_sysmem_high_watermark(),
- ?line ok = memsup:set_sysmem_high_watermark(0.90),
- ?line 30 = memsup:get_helper_timeout(),
- ?line ok = memsup:set_helper_timeout(35),
+ {0,0,{_Pid,0}} = memsup:get_memory_data(),
+ ok = application:set_env(os_mon, memsup_system_only, true),
+ {0,0,undefined} = memsup:get_memory_data(),
+ ok = application:set_env(os_mon, memsup_system_only, false),
+ [] = memsup:get_system_memory_data(),
+ 0 = memsup:get_os_wordsize(),
+ 60000 = memsup:get_check_interval(),
+ ok = memsup:set_check_interval(2),
+ 5 = memsup:get_procmem_high_watermark(),
+ ok = memsup:set_procmem_high_watermark(0.10),
+ 80 = memsup:get_sysmem_high_watermark(),
+ ok = memsup:set_sysmem_high_watermark(0.90),
+ 30 = memsup:get_helper_timeout(),
+ ok = memsup:set_helper_timeout(35),
%% Start memsup again,
- ?line ok = application:set_env(os_mon, start_memsup, true),
- ?line {ok, _Child} = supervisor:restart_child(os_mon_sup, memsup),
+ ok = application:set_env(os_mon, start_memsup, true),
+ {ok, _Child} = supervisor:restart_child(os_mon_sup, memsup),
ok.
-timeout(suite) ->
- [];
-timeout(doc) ->
- ["Test stability of memsup when data collection times out"];
+%% Test stability of memsup when data collection times out
timeout(Config) when is_list(Config) ->
%% Set a long memory check interval and memsup_helper timeout,
%% we will force memory checks instead and fake timeouts
- ?line ok = memsup:set_check_interval(60),
- ?line ok = memsup:set_helper_timeout(3600),
+ ok = memsup:set_check_interval(60),
+ ok = memsup:set_helper_timeout(3600),
%% Provoke a timeout during memory collection
- ?line memsup ! time_to_collect,
- ?line memsup ! reg_collection_timeout,
+ memsup ! time_to_collect,
+ memsup ! reg_collection_timeout,
%% Not much we can check though, except that memsup is still running
- ?line {_,_,_} = memsup:get_memory_data(),
+ {_,_,_} = memsup:get_memory_data(),
%% Provoke a timeout during extensive memory collection
%% We fake a gen_server:call/2 to be able to send a timeout message
@@ -574,140 +540,133 @@ timeout(Config) when is_list(Config) ->
%% Linux should be handled the same way as solaris.
-% TimeoutMsg = case ?t:os_type() of
-% {unix, sunos} -> ext_collection_timeout;
-% {unix, linux} -> reg_collection_timeout
-% end,
+ % TimeoutMsg = case ?t:os_type() of
+ % {unix, sunos} -> ext_collection_timeout;
+ % {unix, linux} -> reg_collection_timeout
+ % end,
TimeoutMsg = ext_collection_timeout,
- ?line Pid = whereis(memsup),
- ?line Mref = erlang:monitor(process, Pid),
- ?line Pid ! {'$gen_call', {self(), Mref}, get_system_memory_data},
- ?line Pid ! TimeoutMsg,
+ Pid = whereis(memsup),
+ Mref = erlang:monitor(process, Pid),
+ Pid ! {'$gen_call', {self(), Mref}, get_system_memory_data},
+ Pid ! TimeoutMsg,
receive
- {Mref, []} ->
- erlang:demonitor(Mref),
- ?line ok;
- {Mref, Res} ->
- erlang:demonitor(Mref),
- ?line ?t:fail({unexpected_result, Res});
- {'DOWN', Mref, _, _, _} ->
- ?line ?t:fail(no_result)
+ {Mref, []} ->
+ erlang:demonitor(Mref),
+ ok;
+ {Mref, Res} ->
+ erlang:demonitor(Mref),
+ ct:fail({unexpected_result, Res});
+ {'DOWN', Mref, _, _, _} ->
+ ct:fail(no_result)
end,
%% Reset memory check interval and memsup_helper timeout
- ?line ok = memsup:set_check_interval(1),
- ?line ok = memsup:set_helper_timeout(30),
- ?line memsup ! time_to_collect,
+ ok = memsup:set_check_interval(1),
+ ok = memsup:set_helper_timeout(30),
+ memsup ! time_to_collect,
- ?line [_|_] = memsup:get_system_memory_data(),
+ [_|_] = memsup:get_system_memory_data(),
ok.
-port(suite) ->
- [];
-port(doc) ->
- ["Test that memsup handles a terminating port program"];
+%% Test that memsup handles a terminating port program
port(Config) when is_list(Config) ->
- ?line Str = os:cmd("ps -e | grep '[m]emsup'"),
+ Str = os:cmd("ps -e | grep '[m]emsup'"),
case io_lib:fread("~s", Str) of
- {ok, [Pid], _Rest} ->
-
- %% Monitor memsup
- ?line MonRef = erlang:monitor(process, memsup),
- ?line {Total1,_Alloc1,_Worst1} = memsup:get_memory_data(),
- ?line true = Total1>0,
-
- %% Kill the port program
- case os:cmd("kill -9 " ++ Pid) of
- [] ->
-
- %% memsup should now terminate
- receive
- {'DOWN', MonRef, _, _, {port_died, _Reason}} ->
- ok;
- {'DOWN', MonRef, _, _, Reason} ->
- ?line ?t:fail({unexpected_exit_reason, Reason})
- after
- 3000 ->
- ?line ?t:fail(still_alive)
- end,
-
- %% Give os_mon_sup time to restart memsup
- ?t:sleep(?t:seconds(3)),
- ?line {Total2,_Alloc2,_Worst2} =
- memsup:get_memory_data(),
- ?line true = Total2>0,
-
- ok;
-
- Line ->
- erlang:demonitor(MonRef),
- {skip, {not_killed, Line}}
- end;
- _ ->
- {skip, {os_pid_not_found, Str}}
+ {ok, [Pid], _Rest} ->
+
+ %% Monitor memsup
+ MonRef = erlang:monitor(process, memsup),
+ {Total1,_Alloc1,_Worst1} = memsup:get_memory_data(),
+ true = Total1>0,
+
+ %% Kill the port program
+ case os:cmd("kill -9 " ++ Pid) of
+ [] ->
+
+ %% memsup should now terminate
+ receive
+ {'DOWN', MonRef, _, _, {port_died, _Reason}} ->
+ ok;
+ {'DOWN', MonRef, _, _, Reason} ->
+ ct:fail({unexpected_exit_reason, Reason})
+ after
+ 3000 ->
+ ct:fail(still_alive)
+ end,
+
+ %% Give os_mon_sup time to restart memsup
+ ct:sleep({seconds,3}),
+ {Total2,_Alloc2,_Worst2} =
+ memsup:get_memory_data(),
+ true = Total2>0,
+
+ ok;
+
+ Line ->
+ erlang:demonitor(MonRef),
+ {skip, {not_killed, Line}}
+ end;
+ _ ->
+ {skip, {os_pid_not_found, Str}}
end.
-otp_5910(suite) ->
- [];
-otp_5910(doc) ->
- ["Test that alarms are cleared and not set twice"];
+%% Test that alarms are cleared and not set twice
otp_5910(Config) when is_list(Config) ->
Alarms =
- [system_memory_high_watermark, process_memory_high_watermark],
+ [system_memory_high_watermark, process_memory_high_watermark],
%% Make sure memsup sets both alarms
- ?line ok = application:set_env(os_mon, memory_check_interval, 60),
- ?line ok = memsup:set_check_interval(60),
- ?line SysThreshold = (memsup:get_sysmem_high_watermark()/100),
- ?line ProcThreshold = (memsup:get_procmem_high_watermark()/100),
+ ok = application:set_env(os_mon, memory_check_interval, 60),
+ ok = memsup:set_check_interval(60),
+ SysThreshold = (memsup:get_sysmem_high_watermark()/100),
+ ProcThreshold = (memsup:get_procmem_high_watermark()/100),
MemData = memsup:get_memory_data(),
io:format("otp_5910: memsup:get_memory_data() = ~p~n", [MemData]),
- ?line {Total, Alloc, {_Pid, _Bytes}} = MemData,
- ?line Pid = spawn_opt(fun() ->
- receive
- die -> ok
- end
- end, [{min_heap_size, 1000}]),
+ {Total, Alloc, {_Pid, _Bytes}} = MemData,
+ Pid = spawn_opt(fun() ->
+ receive
+ die -> ok
+ end
+ end, [{min_heap_size, 1000}]),
%% Create a process guaranteed to live, be constant and
%% break memsup process limit
- ?line {memory, Bytes} = erlang:process_info(Pid,memory),
- ?line SysUsage = Alloc/Total,
- ?line ProcUsage = Bytes/Total,
+ {memory, Bytes} = erlang:process_info(Pid,memory),
+ SysUsage = Alloc/Total,
+ ProcUsage = Bytes/Total,
if
- SysUsage>SysThreshold ->
- ok;
- SysUsage=<SysThreshold ->
- ?line ok = application:set_env(os_mon,
- sys_mem_high_watermark,
- 0.5 * SysUsage),
- ?line ok = memsup:set_sysmem_high_watermark(0.5 * SysUsage)
+ SysUsage>SysThreshold ->
+ ok;
+ SysUsage=<SysThreshold ->
+ ok = application:set_env(os_mon,
+ sys_mem_high_watermark,
+ 0.5 * SysUsage),
+ ok = memsup:set_sysmem_high_watermark(0.5 * SysUsage)
end,
if
- ProcUsage>ProcThreshold ->
- ok;
- ProcUsage=<ProcThreshold ->
- ?line ok = application:set_env(os_mon,
- proc_mem_high_watermark,
- 0.5 * ProcUsage),
- ?line ok = memsup:set_procmem_high_watermark(0.5 *ProcUsage)
+ ProcUsage>ProcThreshold ->
+ ok;
+ ProcUsage=<ProcThreshold ->
+ ok = application:set_env(os_mon,
+ proc_mem_high_watermark,
+ 0.5 * ProcUsage),
+ ok = memsup:set_procmem_high_watermark(0.5 *ProcUsage)
end,
- ?line ok = force_collection(),
- ?t:sleep(?t:seconds(1)),
+ ok = force_collection(),
+ ct:sleep({seconds,1}),
lists:foreach(fun(AlarmId) ->
- case alarm_set(AlarmId) of
- {true, _} -> ok;
- false ->
- ?line ?t:fail({alarm_not_set,
- AlarmId})
- end
- end,
- Alarms),
+ case alarm_set(AlarmId) of
+ {true, _} -> ok;
+ false ->
+ ct:fail({alarm_not_set, AlarmId})
+ end
+ end,
+ Alarms),
%% Kill guaranteed process...
Pid ! die,
@@ -715,42 +674,41 @@ otp_5910(Config) when is_list(Config) ->
exit(whereis(memsup), faked_memsup_crash),
%% Wait a little to make sure memsup has been restarted,
%% then make sure the alarms are set once, but not twice
- ?t:sleep(?t:seconds(1)),
- ?line MemUsage = memsup:get_memory_data(),
+ ct:sleep({seconds,1}),
+ MemUsage = memsup:get_memory_data(),
SetAlarms = alarm_handler:get_alarms(),
case lists:foldl(fun(system_memory_high_watermark, {S, P}) ->
- {S+1, P};
- (process_memory_high_watermark, {S, P}) ->
- {S, P+1};
- (_AlarmId, Acc0) ->
- Acc0
- end,
- {0, 0},
- SetAlarms) of
- {0, 0} ->
- ok;
- _ ->
- ?line ?t:fail({bad_number_of_alarms, SetAlarms, MemUsage})
+ {S+1, P};
+ (process_memory_high_watermark, {S, P}) ->
+ {S, P+1};
+ (_AlarmId, Acc0) ->
+ Acc0
+ end,
+ {0, 0},
+ SetAlarms) of
+ {0, 0} ->
+ ok;
+ _ ->
+ ct:fail({bad_number_of_alarms, SetAlarms, MemUsage})
end,
%% Stop OS_Mon and make sure all memsup alarms are cleared
- ?line ok = application:stop(os_mon),
- ?t:sleep(?t:seconds(1)),
+ ok = application:stop(os_mon),
+ ct:sleep({seconds,1}),
lists:foreach(fun(AlarmId) ->
- case alarm_set(AlarmId) of
- false -> ok;
- {true, _} ->
- ?line ?t:fail({alarm_is_set, AlarmId})
- end
- end,
- Alarms),
+ case alarm_set(AlarmId) of
+ false -> ok;
+ {true, _} ->
+ ct:fail({alarm_is_set, AlarmId})
+ end
+ end,
+ Alarms),
%% Reset configuration and restart OS_Mon
- ?line ok = application:set_env(os_mon,memory_check_interval,1),
- ?line ok = application:set_env(os_mon,sys_mem_high_watermark,0.8),
- ?line ok = application:set_env(os_mon,proc_mem_high_watermark,0.05),
- ?line ok = application:start(os_mon),
-
+ ok = application:set_env(os_mon,memory_check_interval,1),
+ ok = application:set_env(os_mon,sys_mem_high_watermark,0.8),
+ ok = application:set_env(os_mon,proc_mem_high_watermark,0.05),
+ ok = application:start(os_mon),
ok.
%%----------------------------------------------------------------------
@@ -765,30 +723,30 @@ force_collection() ->
force_collection(TimerRef) ->
receive
- {trace, _Pid, 'receive', {collected_sys, _Sys}} ->
- erlang:cancel_timer(TimerRef),
- erlang:trace(whereis(memsup), false, ['receive']),
- flush(),
- ok;
- {trace, _Pid, 'receive', reg_collection_timeout} ->
- erlang:cancel_timer(TimerRef),
- erlang:trace(whereis(memsup), false, ['receive']),
- flush(),
- collection_timeout;
- timout ->
- erlang:trace(whereis(memsup), false, ['receive']),
- flush(),
- timeout;
- _Msg ->
- force_collection(TimerRef)
+ {trace, _Pid, 'receive', {collected_sys, _Sys}} ->
+ erlang:cancel_timer(TimerRef),
+ erlang:trace(whereis(memsup), false, ['receive']),
+ flush(),
+ ok;
+ {trace, _Pid, 'receive', reg_collection_timeout} ->
+ erlang:cancel_timer(TimerRef),
+ erlang:trace(whereis(memsup), false, ['receive']),
+ flush(),
+ collection_timeout;
+ timout ->
+ erlang:trace(whereis(memsup), false, ['receive']),
+ flush(),
+ timeout;
+ _Msg ->
+ force_collection(TimerRef)
end.
flush() ->
receive
- {trace, _, _, _} ->
- flush();
- timeout ->
- flush()
+ {trace, _, _, _} ->
+ flush();
+ timeout ->
+ flush()
after 0 ->
- ok
+ ok
end.