Merge branch 'rickard/time-unit/OTP-13735' into maint

* rickard/time-unit/OTP-13735:
  Update test-cases to use new symbolic time units
  Replace misspelled symbolic time units

Conflicts:
	erts/doc/src/erlang.xml
	erts/emulator/test/long_timers_test.erl

27 files changed, 94 insertions, 94 deletions

diff --git a/erts/emulator/test/after_SUITE.erl b/erts/emulator/test/after_SUITE.erl
index 4f20ad3656..b1f7e06bf5 100644
--- a/erts/emulator/test/after_SUITE.erl
+++ b/erts/emulator/test/after_SUITE.erl
@@ -223,7 +223,7 @@ recv_after_32bit(_, _) ->
 blaster() ->
     receive
 	{go, TimeoutTime} ->
-	    Tmo = TimeoutTime - erlang:monotonic_time(milli_seconds),
+	    Tmo = TimeoutTime - erlang:monotonic_time(millisecond),
 	    receive after Tmo -> ok end
     end.
 
@@ -234,7 +234,7 @@ spawn_blasters(N) ->
 
 receive_after_blast(Config) when is_list(Config) ->
     PMs = spawn_blasters(10000),
-    TimeoutTime = erlang:monotonic_time(milli_seconds) + 5000,
+    TimeoutTime = erlang:monotonic_time(millisecond) + 5000,
     lists:foreach(fun ({P, _}) -> P ! {go, TimeoutTime} end, PMs),
     lists:foreach(fun ({P, M}) ->
                           receive
diff --git a/erts/emulator/test/alloc_SUITE.erl b/erts/emulator/test/alloc_SUITE.erl
index 84cf4921d3..3a721095e2 100644
--- a/erts/emulator/test/alloc_SUITE.erl
+++ b/erts/emulator/test/alloc_SUITE.erl
@@ -342,7 +342,7 @@ start_node_1(Config, Opts) ->
 			++ "-"
 			++ atom_to_list(proplists:get_value(testcase, Config))
 			++ "-"
-			++ integer_to_list(erlang:system_time(seconds))
+			++ integer_to_list(erlang:system_time(second))
 			++ "-"
 			++ integer_to_list(erlang:unique_integer([positive]))),
     test_server:start_node(Name, slave, [{args, Opts++" -pa "++Pa}]).
diff --git a/erts/emulator/test/busy_port_SUITE.erl b/erts/emulator/test/busy_port_SUITE.erl
index bb0632ae08..7094cee992 100644
--- a/erts/emulator/test/busy_port_SUITE.erl
+++ b/erts/emulator/test/busy_port_SUITE.erl
@@ -469,12 +469,12 @@ hs_busy_pcmd(Prt, Opts, StartFun, EndFun) ->
     P = spawn_link(fun () ->
                            erlang:yield(),
                            Tester ! {self(), doing_port_command},
-                           Start = erlang:monotonic_time(micro_seconds),
+                           Start = erlang:monotonic_time(microsecond),
                            Res = try {return,
                                       port_command(Prt, [], Opts)}
                                  catch Exception:Error -> {Exception, Error}
                                  end,
-                           End = erlang:monotonic_time(micro_seconds),
+                           End = erlang:monotonic_time(microsecond),
                            Time = round((End - Start)/1000),
                            Tester ! {self(), port_command_result, Res, Time}
                    end),
@@ -717,7 +717,7 @@ run_command(_M,spawn,{Args,Opts}) ->
 run_command(M,spawn,Args) ->
     run_command(M,spawn,{Args,[]});
 run_command(Mod,Func,Args) ->
-    erlang:display({{Mod,Func,Args}, erlang:system_time(micro_seconds)}),
+    erlang:display({{Mod,Func,Args}, erlang:system_time(microsecond)}),
     apply(Mod,Func,Args).
 
 validate_scenario(Data,[{print,Var}|T]) ->
diff --git a/erts/emulator/test/dirty_nif_SUITE.erl b/erts/emulator/test/dirty_nif_SUITE.erl
index 5e4c81a9cf..658bdc41b6 100644
--- a/erts/emulator/test/dirty_nif_SUITE.erl
+++ b/erts/emulator/test/dirty_nif_SUITE.erl
@@ -148,9 +148,9 @@ dirty_scheduler_exit(Config) when is_list(Config) ->
     [ok] = mcall(Node,
                  [fun() ->
                           ok = erlang:load_nif(NifLib, []),
-			  Start = erlang:monotonic_time(milli_seconds),
+			  Start = erlang:monotonic_time(millisecond),
                           ok = test_dirty_scheduler_exit(),
-			  End = erlang:monotonic_time(milli_seconds),
+			  End = erlang:monotonic_time(millisecond),
 			  io:format("Time=~p ms~n", [End-Start]),
 			  ok
                   end]),
@@ -504,7 +504,7 @@ start_node(Config, Args) when is_list(Config) ->
 			++ "-"
 			++ atom_to_list(proplists:get_value(testcase, Config))
 			++ "-"
-			++ integer_to_list(erlang:system_time(seconds))
+			++ integer_to_list(erlang:system_time(second))
 			++ "-"
 			++ integer_to_list(erlang:unique_integer([positive]))),
     test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
diff --git a/erts/emulator/test/distribution_SUITE.erl b/erts/emulator/test/distribution_SUITE.erl
index 159fbc806b..6994bfef83 100644
--- a/erts/emulator/test/distribution_SUITE.erl
+++ b/erts/emulator/test/distribution_SUITE.erl
@@ -1950,7 +1950,7 @@ port_please(_Name, _Ip) ->
 %%% Utilities
 
 timestamp() ->
-    erlang:monotonic_time(milli_seconds).
+    erlang:monotonic_time(millisecond).
 
 start_node(X) ->
     start_node(X, [], []).
@@ -1974,7 +1974,7 @@ start_node(Config, Args, Rel) when is_list(Config), is_list(Rel) ->
                          ++ "-"
                          ++ atom_to_list(proplists:get_value(testcase, Config))
                          ++ "-"
-                         ++ integer_to_list(erlang:system_time(seconds))
+                         ++ integer_to_list(erlang:system_time(second))
                          ++ "-"
                          ++ integer_to_list(erlang:unique_integer([positive])))),
     start_node(Name, Args, Rel).
@@ -2091,7 +2091,7 @@ node_monitor(Master) ->
                                   Master ! {nodeup, node(), Node}
                           end,
                           Nodes0),
-            io:format("~p ~p: ~p~n", [node(), erlang:system_time(micro_seconds), Nodes0]),
+            io:format("~p ~p: ~p~n", [node(), erlang:system_time(microsecond), Nodes0]),
             node_monitor_loop(Master);
         false ->
             net_kernel:monitor_nodes(false, Opts),
@@ -2112,7 +2112,7 @@ node_monitor_loop(Master) ->
     receive
         {nodeup, Node, _InfoList} = Msg ->
             Master ! {nodeup, node(), Node},
-            io:format("~p ~p: ~p~n", [node(), erlang:system_time(micro_seconds), Msg]),
+            io:format("~p ~p: ~p~n", [node(), erlang:system_time(microsecond), Msg]),
             node_monitor_loop(Master);
         {nodedown, Node, InfoList} = Msg ->
             Reason = case lists:keysearch(nodedown_reason, 1, InfoList) of
@@ -2120,7 +2120,7 @@ node_monitor_loop(Master) ->
                          _ -> undefined
                      end,
             Master ! {nodedown, node(), Node, Reason},
-            io:format("~p ~p: ~p~n", [node(), erlang:system_time(micro_seconds), Msg]),
+            io:format("~p ~p: ~p~n", [node(), erlang:system_time(microsecond), Msg]),
             node_monitor_loop(Master)
     end.
 
diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index a3df0bb2db..1df72193a6 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -2427,7 +2427,7 @@ erl_millisecs() ->
     erl_millisecs(erlang:monotonic_time()).
 
 erl_millisecs(MonotonicTime) ->
-    (1000*MonotonicTime)/erlang:convert_time_unit(1,seconds,native).
+    (1000*MonotonicTime)/erlang:convert_time_unit(1,second,native).
 
 %% Start/stop drivers.
 start_driver(Config, Name, Binary) ->
@@ -2481,7 +2481,7 @@ start_node(Config) when is_list(Config) ->
                         ++ "-"
                         ++ atom_to_list(proplists:get_value(testcase, Config))
                         ++ "-"
-                        ++ integer_to_list(erlang:system_time(seconds))
+                        ++ integer_to_list(erlang:system_time(second))
                         ++ "-"
                         ++ integer_to_list(erlang:unique_integer([positive]))),
     test_server:start_node(Name, slave, [{args, "-pa "++Pa}]).
diff --git a/erts/emulator/test/erl_link_SUITE.erl b/erts/emulator/test/erl_link_SUITE.erl
index 93d2065ba3..89e1aefb50 100644
--- a/erts/emulator/test/erl_link_SUITE.erl
+++ b/erts/emulator/test/erl_link_SUITE.erl
@@ -1011,7 +1011,7 @@ get_names(N, T, Acc) ->
                                     ++ "-"
                                     ++ atom_to_list(T)
                                     ++ "-"
-                                    ++ integer_to_list(erlang:system_time(seconds))
+                                    ++ integer_to_list(erlang:system_time(second))
                                     ++ "-"
                                     ++ integer_to_list(erlang:unique_integer([positive]))) | Acc]).
 
diff --git a/erts/emulator/test/estone_SUITE.erl b/erts/emulator/test/estone_SUITE.erl
index 1180a45585..3ce849b88e 100644
--- a/erts/emulator/test/estone_SUITE.erl
+++ b/erts/emulator/test/estone_SUITE.erl
@@ -364,7 +364,7 @@ monotonic_time() ->
     try erlang:monotonic_time() catch error:undef -> erlang:now() end.
 
 subtr(Before, After) when is_integer(Before), is_integer(After) ->
-    erlang:convert_time_unit(After-Before, native, micro_seconds);
+    erlang:convert_time_unit(After-Before, native, microsecond);
 subtr({_,_,_}=Before, {_,_,_}=After) ->
     timer:now_diff(After, Before).
 
diff --git a/erts/emulator/test/float_SUITE.erl b/erts/emulator/test/float_SUITE.erl
index e85addae3a..36b1f9179f 100644
--- a/erts/emulator/test/float_SUITE.erl
+++ b/erts/emulator/test/float_SUITE.erl
@@ -276,7 +276,7 @@ start_node(Config) when is_list(Config) ->
                         ++ "-"
                         ++ atom_to_list(proplists:get_value(testcase, Config))
                         ++ "-"
-                        ++ integer_to_list(erlang:system_time(seconds))
+                        ++ integer_to_list(erlang:system_time(second))
                         ++ "-"
                         ++ integer_to_list(erlang:unique_integer([positive]))),
     test_server:start_node(Name, slave, [{args, "-pa "++Pa}]).
diff --git a/erts/emulator/test/long_timers_test.erl b/erts/emulator/test/long_timers_test.erl
index 90efe1292c..c9a380a229 100644
--- a/erts/emulator/test/long_timers_test.erl
+++ b/erts/emulator/test/long_timers_test.erl
@@ -248,20 +248,20 @@ to_diff(Timeout, Start, Stop) ->
     (Stop - Start) - Timeout*1000.
 
 ms(Time) ->
-    erlang:convert_time_unit(Time, micro_seconds, milli_seconds).
+    erlang:convert_time_unit(Time, microsecond, millisecond).
 
 max_late() ->
-    erlang:convert_time_unit(?MAX_LATE_MS, milli_seconds, micro_seconds).
+    erlang:convert_time_unit(?MAX_LATE_MS, millisecond, microsecond).
 
 receive_after(Timeout) ->
-    Start = erlang:monotonic_time(micro_seconds),
+    Start = erlang:monotonic_time(microsecond),
     receive
 	{get_result, ?REG_NAME} ->
 	    ?REG_NAME ! #timeout_rec{pid = self(),
 				     type = receive_after,
 				     timeout = Timeout}
     after Timeout ->
-	    Stop = erlang:monotonic_time(micro_seconds),
+	    Stop = erlang:monotonic_time(microsecond),
 	    receive
 		{get_result, ?REG_NAME} ->
 		    ?REG_NAME ! #timeout_rec{pid = self(),
@@ -276,7 +276,7 @@ receive_after(Timeout) ->
 driver(Timeout) ->
     Port = open_port({spawn, ?DRV_NAME},[]),
     link(Port),
-    Start = erlang:monotonic_time(micro_seconds),
+    Start = erlang:monotonic_time(microsecond),
     erlang:port_command(Port, <<?START_TIMER, Timeout:32>>),
     receive
 	{get_result, ?REG_NAME} ->
@@ -284,7 +284,7 @@ driver(Timeout) ->
 				     type = driver,
 				     timeout = Timeout};
 	{Port,{data,[?TIMER]}} ->
-	    Stop = erlang:monotonic_time(micro_seconds),
+	    Stop = erlang:monotonic_time(microsecond),
 	    unlink(Port),
 	    true = erlang:port_close(Port),
 	    receive
@@ -299,7 +299,7 @@ driver(Timeout) ->
     end.
 
 bif_timer(Timeout) ->
-    Start = erlang:monotonic_time(micro_seconds),
+    Start = erlang:monotonic_time(microsecond),
     Tmr = erlang:start_timer(Timeout, self(), ok),
     receive
 	{get_result, ?REG_NAME} ->
@@ -307,7 +307,7 @@ bif_timer(Timeout) ->
 				     type = bif_timer,
 				     timeout = Timeout};
 	{timeout, Tmr, ok} ->
-	    Stop = erlang:monotonic_time(micro_seconds),
+	    Stop = erlang:monotonic_time(microsecond),
 	    receive
 		{get_result, ?REG_NAME} ->
 		    ?REG_NAME ! #timeout_rec{pid = self(),
@@ -335,7 +335,7 @@ test(Starter, DrvDir, StartDone) ->
 	    ok
     end,
     UtilData = new_util(),
-    Start = erlang:monotonic_time(micro_seconds),
+    Start = erlang:monotonic_time(microsecond),
     TORs = lists:map(fun (Min) ->
 			     TO = Min*60*1000,
 			     [#timeout_rec{pid = spawn_opt(
@@ -370,13 +370,13 @@ new_util() ->
 
 new_util(UtilData) ->
     Util = cpu_sup:util(),
-    Time = erlang:monotonic_time(micro_seconds),
+    Time = erlang:monotonic_time(microsecond),
     [{Time, Util} | UtilData].
 
 test_loop(TORs, Start, UtilData) ->
     receive
 	{get_result, ?REG_NAME, Pid} ->
-	    End = erlang:monotonic_time(micro_seconds),
+	    End = erlang:monotonic_time(microsecond),
 	    EndUtilData = new_util(UtilData),
 	    Pid ! {result, ?REG_NAME, get_test_results(TORs), Start, End, EndUtilData},
 	    erl_ddll:unload_driver(?DRV_NAME),
diff --git a/erts/emulator/test/message_queue_data_SUITE.erl b/erts/emulator/test/message_queue_data_SUITE.erl
index 44e77dfad0..e084b9482d 100644
--- a/erts/emulator/test/message_queue_data_SUITE.erl
+++ b/erts/emulator/test/message_queue_data_SUITE.erl
@@ -200,7 +200,7 @@ start_node(Config, Opts) when is_list(Config), is_list(Opts) ->
 			++ "-"
 			++ atom_to_list(proplists:get_value(testcase, Config))
 			++ "-"
-			++ integer_to_list(erlang:system_time(seconds))
+			++ integer_to_list(erlang:system_time(second))
 			++ "-"
 			++ integer_to_list(erlang:unique_integer([positive]))),
     test_server:start_node(Name, slave, [{args, Opts++" -pa "++Pa}]).
diff --git a/erts/emulator/test/monitor_SUITE.erl b/erts/emulator/test/monitor_SUITE.erl
index 90d2bd8c5d..827ed817cc 100644
--- a/erts/emulator/test/monitor_SUITE.erl
+++ b/erts/emulator/test/monitor_SUITE.erl
@@ -697,7 +697,7 @@ mixer(Config) when is_list(Config) ->
 named_down(Config) when is_list(Config) ->
     Name = list_to_atom(atom_to_list(?MODULE)
                         ++ "-named_down-"
-                        ++ integer_to_list(erlang:system_time(seconds))
+                        ++ integer_to_list(erlang:system_time(second))
                         ++ "-" ++ integer_to_list(erlang:unique_integer([positive]))),
     Prio = process_flag(priority,high),
     %% Spawn a bunch of high prio cpu bound processes to prevent
diff --git a/erts/emulator/test/mtx_SUITE.erl b/erts/emulator/test/mtx_SUITE.erl
index 1493e52655..12928ed6d8 100644
--- a/erts/emulator/test/mtx_SUITE.erl
+++ b/erts/emulator/test/mtx_SUITE.erl
@@ -443,7 +443,7 @@ hammer_ets_rwlock_test(XOpts, UW, C, N, NP, SC) ->
                                                                               {'DOWN', M, process, P, _} -> ok
                                                                           end
                                                                   end, Ps),
-                                                    Res = (Stop-Start)/erlang:convert_time_unit(1,seconds,native),
+                                                    Res = (Stop-Start)/erlang:convert_time_unit(1,second,native),
                                                     Caller ! {?MODULE, self(), Res}
                                             end,
                                         TP = spawn_link(T),
diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index b8fa7184b6..8df2733fac 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -1703,7 +1703,7 @@ nif_raise_exceptions(NifFunc) ->
                 end, ok, ExcTerms).
 
 -define(ERL_NIF_TIME_ERROR, -9223372036854775808).
--define(TIME_UNITS, [seconds, milli_seconds, micro_seconds, nano_seconds]).
+-define(TIME_UNITS, [second, millisecond, microsecond, nanosecond]).
 
 nif_monotonic_time(Config) ->
     ?ERL_NIF_TIME_ERROR = monotonic_time(invalid_time_unit),
@@ -1769,8 +1769,8 @@ chk_toffs([TU|TUs]) ->
     chk_toffs(TUs).
 
 nif_convert_time_unit(Config) ->
-    ?ERL_NIF_TIME_ERROR = convert_time_unit(0, seconds, invalid_time_unit),
-    ?ERL_NIF_TIME_ERROR = convert_time_unit(0, invalid_time_unit, seconds),
+    ?ERL_NIF_TIME_ERROR = convert_time_unit(0, second, invalid_time_unit),
+    ?ERL_NIF_TIME_ERROR = convert_time_unit(0, invalid_time_unit, second),
     ?ERL_NIF_TIME_ERROR = convert_time_unit(0, invalid_time_unit, invalid_time_unit),
     lists:foreach(fun (Offset) ->
                           lists:foreach(fun (Diff) ->
@@ -1819,7 +1819,7 @@ nif_convert_time_unit(Config) ->
 ctu_loop(0) ->
     ok;
 ctu_loop(N) ->
-    chk_ctu(erlang:monotonic_time(nano_seconds)),
+    chk_ctu(erlang:monotonic_time(nanosecond)),
     ctu_loop(N-1).
 
 chk_ctu(Time) ->
@@ -1834,7 +1834,7 @@ chk_ctu(Time, [FromTU|FromTUs]) ->
 chk_ctu(_Time, _FromTU, []) ->
     ok;
 chk_ctu(Time, FromTU, [ToTU|ToTUs]) ->
-    T = erlang:convert_time_unit(Time, nano_seconds, FromTU),
+    T = erlang:convert_time_unit(Time, nanosecond, FromTU),
     TE = erlang:convert_time_unit(T, FromTU, ToTU),
     TN = convert_time_unit(T, FromTU, ToTU),
     case TE =:= TN of
diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index 13846244d4..f2b1ef9d24 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -38,10 +38,10 @@ static ERL_NIF_TERM atom_self;
 static ERL_NIF_TERM atom_ok;
 static ERL_NIF_TERM atom_join;
 static ERL_NIF_TERM atom_binary_resource_type;
-static ERL_NIF_TERM atom_seconds;
-static ERL_NIF_TERM atom_milli_seconds;
-static ERL_NIF_TERM atom_micro_seconds;
-static ERL_NIF_TERM atom_nano_seconds;
+static ERL_NIF_TERM atom_second;
+static ERL_NIF_TERM atom_millisecond;
+static ERL_NIF_TERM atom_microsecond;
+static ERL_NIF_TERM atom_nanosecond;
 
 
 typedef struct
@@ -147,10 +147,10 @@ static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
     atom_ok = enif_make_atom(env,"ok");
     atom_join = enif_make_atom(env,"join");
     atom_binary_resource_type = enif_make_atom(env,"binary_resource_type");
-    atom_seconds = enif_make_atom(env,"seconds");
-    atom_milli_seconds = enif_make_atom(env,"milli_seconds");
-    atom_micro_seconds = enif_make_atom(env,"micro_seconds");
-    atom_nano_seconds = enif_make_atom(env,"nano_seconds");
+    atom_second = enif_make_atom(env,"second");
+    atom_millisecond = enif_make_atom(env,"millisecond");
+    atom_microsecond = enif_make_atom(env,"microsecond");
+    atom_nanosecond = enif_make_atom(env,"nanosecond");
 
     *priv_data = data;
     return 0;
@@ -1808,13 +1808,13 @@ static ERL_NIF_TERM monotonic_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM
     if (argc != 1)
 	return atom_false;
 
-    if (enif_compare(argv[0], atom_seconds) == 0)
+    if (enif_compare(argv[0], atom_second) == 0)
 	time_unit = ERL_NIF_SEC;
-    else if (enif_compare(argv[0], atom_milli_seconds) == 0)
+    else if (enif_compare(argv[0], atom_millisecond) == 0)
 	time_unit = ERL_NIF_MSEC;
-    else if (enif_compare(argv[0], atom_micro_seconds) == 0)
+    else if (enif_compare(argv[0], atom_microsecond) == 0)
 	time_unit = ERL_NIF_USEC;
-    else if (enif_compare(argv[0], atom_nano_seconds) == 0)
+    else if (enif_compare(argv[0], atom_nanosecond) == 0)
 	time_unit = ERL_NIF_NSEC;
     else
 	time_unit = 4711; /* invalid time unit */
@@ -1829,13 +1829,13 @@ static ERL_NIF_TERM time_offset(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg
     if (argc != 1)
 	return atom_false;
 
-    if (enif_compare(argv[0], atom_seconds) == 0)
+    if (enif_compare(argv[0], atom_second) == 0)
 	time_unit = ERL_NIF_SEC;
-    else if (enif_compare(argv[0], atom_milli_seconds) == 0)
+    else if (enif_compare(argv[0], atom_millisecond) == 0)
 	time_unit = ERL_NIF_MSEC;
-    else if (enif_compare(argv[0], atom_micro_seconds) == 0)
+    else if (enif_compare(argv[0], atom_microsecond) == 0)
 	time_unit = ERL_NIF_USEC;
-    else if (enif_compare(argv[0], atom_nano_seconds) == 0)
+    else if (enif_compare(argv[0], atom_nanosecond) == 0)
 	time_unit = ERL_NIF_NSEC;
     else
 	time_unit = 4711; /* invalid time unit */
@@ -1856,24 +1856,24 @@ static ERL_NIF_TERM convert_time_unit(ErlNifEnv* env, int argc, const ERL_NIF_TE
 
     val = (ErlNifTime) i64;
 
-    if (enif_compare(argv[1], atom_seconds) == 0)
+    if (enif_compare(argv[1], atom_second) == 0)
 	from = ERL_NIF_SEC;
-    else if (enif_compare(argv[1], atom_milli_seconds) == 0)
+    else if (enif_compare(argv[1], atom_millisecond) == 0)
 	from = ERL_NIF_MSEC;
-    else if (enif_compare(argv[1], atom_micro_seconds) == 0)
+    else if (enif_compare(argv[1], atom_microsecond) == 0)
 	from = ERL_NIF_USEC;
-    else if (enif_compare(argv[1], atom_nano_seconds) == 0)
+    else if (enif_compare(argv[1], atom_nanosecond) == 0)
 	from = ERL_NIF_NSEC;
     else
 	from = 4711; /* invalid time unit */
 
-    if (enif_compare(argv[2], atom_seconds) == 0)
+    if (enif_compare(argv[2], atom_second) == 0)
 	to = ERL_NIF_SEC;
-    else if (enif_compare(argv[2], atom_milli_seconds) == 0)
+    else if (enif_compare(argv[2], atom_millisecond) == 0)
 	to = ERL_NIF_MSEC;
-    else if (enif_compare(argv[2], atom_micro_seconds) == 0)
+    else if (enif_compare(argv[2], atom_microsecond) == 0)
 	to = ERL_NIF_USEC;
-    else if (enif_compare(argv[2], atom_nano_seconds) == 0)
+    else if (enif_compare(argv[2], atom_nanosecond) == 0)
 	to = ERL_NIF_NSEC;
     else
 	to = 4711; /* invalid time unit */
diff --git a/erts/emulator/test/node_container_SUITE.erl b/erts/emulator/test/node_container_SUITE.erl
index 536c91d4ae..af18545bff 100644
--- a/erts/emulator/test/node_container_SUITE.erl
+++ b/erts/emulator/test/node_container_SUITE.erl
@@ -1092,7 +1092,7 @@ wait_until(Pred) ->
 get_nodefirstname_string() ->
     atom_to_list(?MODULE)
     ++ "-"
-    ++ integer_to_list(erlang:system_time(seconds))
+    ++ integer_to_list(erlang:system_time(second))
     ++ "-"
     ++ integer_to_list(erlang:unique_integer([positive])).
 
diff --git a/erts/emulator/test/old_scheduler_SUITE.erl b/erts/emulator/test/old_scheduler_SUITE.erl
index f91d84beea..ffe7d40139 100644
--- a/erts/emulator/test/old_scheduler_SUITE.erl
+++ b/erts/emulator/test/old_scheduler_SUITE.erl
@@ -309,13 +309,13 @@ receiver(T0, TimeSec, Main, {P1,P1N}, {P2,P2N}) ->
 
 %% uncomment lines below to get life sign (debug)
 receiver(T0, Time, Main, P1,P1N,P1Rs, P2,P2N,P2Rs, 0) ->
-    %    T = erlang:convert_time_unit(erlang:monotonic_time() - T0, native, milli_seconds),
+    %    T = erlang:convert_time_unit(erlang:monotonic_time() - T0, native, millisecond),
     %    erlang:display({round(T/1000),P1Rs,P2Rs}),
     receiver(T0, Time, Main, P1,P1N,P1Rs, P2,P2N,P2Rs, 100000);
 
 receiver(T0, Time, Main, P1,P1N,P1Rs, P2,P2N,P2Rs, C) ->
     Remain = Time - erlang:convert_time_unit(erlang:monotonic_time() - T0,
-                                             native, milli_seconds), % test time remaining
+                                             native, millisecond), % test time remaining
     Remain1 = if Remain < 0 ->
                      0;
                  true ->
diff --git a/erts/emulator/test/port_SUITE.erl b/erts/emulator/test/port_SUITE.erl
index a9814d7df9..4323849465 100644
--- a/erts/emulator/test/port_SUITE.erl
+++ b/erts/emulator/test/port_SUITE.erl
@@ -1986,7 +1986,7 @@ exit_status_msb_test(Config, SleepSecs) when is_list(Config) ->
     Parent = self(),
     io:format("SleepSecs = ~p~n", [SleepSecs]),
     PortProg = "sleep " ++ integer_to_list(SleepSecs),
-    Start = erlang:monotonic_time(micro_seconds),
+    Start = erlang:monotonic_time(microsecond),
     NoProcs = case NoSchedsOnln of
                   NProcs when NProcs < ?EXIT_STATUS_MSB_MAX_PROCS ->
                       NProcs;
@@ -2060,12 +2060,12 @@ exit_status_msb_test(Config, SleepSecs) when is_list(Config) ->
                              receive {P, started, SIds} -> SIds end
                      end,
                      Procs),
-    StartedTime = (erlang:monotonic_time(micro_seconds) - Start)/1000000,
+    StartedTime = (erlang:monotonic_time(microsecond) - Start)/1000000,
     io:format("StartedTime = ~p~n", [StartedTime]),
     true = StartedTime < SleepSecs,
     erlang:system_flag(multi_scheduling, block),
     lists:foreach(fun (P) -> receive {P, done} -> ok end end, Procs),
-    DoneTime = (erlang:monotonic_time(micro_seconds) - Start)/1000000,
+    DoneTime = (erlang:monotonic_time(microsecond) - Start)/1000000,
     io:format("DoneTime = ~p~n", [DoneTime]),
     true = DoneTime > SleepSecs,
     ok = verify_multi_scheduling_blocked(),
diff --git a/erts/emulator/test/process_SUITE.erl b/erts/emulator/test/process_SUITE.erl
index 7462c8c593..0f999e0efe 100644
--- a/erts/emulator/test/process_SUITE.erl
+++ b/erts/emulator/test/process_SUITE.erl
@@ -372,7 +372,7 @@ eat_high(Low) ->
     process_flag(priority, high),
     receive after 1000 -> ok end,
     exit(Low, {you, are, dead}),
-    loop(erlang:monotonic_time() + erlang:convert_time_unit(5,seconds,native)).
+    loop(erlang:monotonic_time() + erlang:convert_time_unit(5,second,native)).
 
 %% Busy loop for 5 seconds.
 
@@ -2567,7 +2567,7 @@ start_node(Config, Args) when is_list(Config) ->
 			      ++ "-"
 			      ++ atom_to_list(proplists:get_value(testcase, Config))
 			      ++ "-"
-			      ++ integer_to_list(erlang:system_time(seconds))
+			      ++ integer_to_list(erlang:system_time(second))
 			      ++ "-"
 			      ++ integer_to_list(erlang:unique_integer([positive]))),
     test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
diff --git a/erts/emulator/test/scheduler_SUITE.erl b/erts/emulator/test/scheduler_SUITE.erl
index a95de609aa..3aee15a8fc 100644
--- a/erts/emulator/test/scheduler_SUITE.erl
+++ b/erts/emulator/test/scheduler_SUITE.erl
@@ -2007,10 +2007,10 @@ do_it(Tracer, Low, Normal, High, Max) ->
 do_it(Tracer, Low, Normal, High, Max, RedsPerSchedLimit) ->
     OldPrio = process_flag(priority, max),
     go_work(Low, Normal, High, Max),
-    StartWait = erlang:monotonic_time(milli_seconds),
+    StartWait = erlang:monotonic_time(millisecond),
     %% Give the emulator a chance to balance the load...
     wait_balance(5),
-    EndWait = erlang:monotonic_time(milli_seconds),
+    EndWait = erlang:monotonic_time(millisecond),
     BalanceWait = EndWait-StartWait,
     erlang:display({balance_wait, BalanceWait}),
     Timeout = (15 - 4)*60*1000 - BalanceWait,
@@ -2210,7 +2210,7 @@ start_node(Config, Args) when is_list(Config) ->
 			++ "-"
 			++ atom_to_list(proplists:get_value(testcase, Config))
 			++ "-"
-			++ integer_to_list(erlang:system_time(seconds))
+			++ integer_to_list(erlang:system_time(second))
 			++ "-"
 			++ integer_to_list(erlang:unique_integer([positive]))),
     test_server:start_node(Name, slave, [{args, "-pa "++Pa++" "++Args}]).
diff --git a/erts/emulator/test/signal_SUITE.erl b/erts/emulator/test/signal_SUITE.erl
index 0b11fa13f5..7e516176f7 100644
--- a/erts/emulator/test/signal_SUITE.erl
+++ b/erts/emulator/test/signal_SUITE.erl
@@ -484,7 +484,7 @@ repeat(Fun, N) when is_integer(N)  ->
 start_node(Config) ->
     Name = list_to_atom(atom_to_list(?MODULE)
 			++ "-" ++ atom_to_list(proplists:get_value(testcase, Config))
-			++ "-" ++ integer_to_list(erlang:system_time(seconds))
+			++ "-" ++ integer_to_list(erlang:system_time(second))
 			++ "-" ++ integer_to_list(erlang:unique_integer([positive]))),
     Pa = filename:dirname(code:which(?MODULE)),
     test_server:start_node(Name, slave, [{args,  "-pa " ++ Pa}]).
diff --git a/erts/emulator/test/smoke_test_SUITE.erl b/erts/emulator/test/smoke_test_SUITE.erl
index 042c7225d5..5eccdc562b 100644
--- a/erts/emulator/test/smoke_test_SUITE.erl
+++ b/erts/emulator/test/smoke_test_SUITE.erl
@@ -152,7 +152,7 @@ start_node(Config, Args) when is_list(Config) ->
 	      ++ "-"
 	      ++ atom_to_list(proplists:get_value(testcase, Config))
 	      ++ "-"
-	      ++ integer_to_list(erlang:system_time(seconds))
+	      ++ integer_to_list(erlang:system_time(second))
 	      ++ "-"
 	      ++ integer_to_list(erlang:unique_integer([positive]))),
     Opts = [{args, "-pa "++Pa++" "++Args}],
diff --git a/erts/emulator/test/system_info_SUITE.erl b/erts/emulator/test/system_info_SUITE.erl
index f31d474c20..a4aedb31f6 100644
--- a/erts/emulator/test/system_info_SUITE.erl
+++ b/erts/emulator/test/system_info_SUITE.erl
@@ -508,7 +508,7 @@ start_node(Config, Envs) when is_list(Config) ->
                         ++ "-"
                         ++ atom_to_list(proplists:get_value(testcase, Config))
                         ++ "-"
-                        ++ integer_to_list(erlang:system_time(seconds))
+                        ++ integer_to_list(erlang:system_time(second))
                         ++ "-"
                         ++ integer_to_list(erlang:unique_integer([positive]))),
     test_server:start_node(Name, peer, [{args, "-pa "++Pa}, {env, Envs}]).
diff --git a/erts/emulator/test/time_SUITE.erl b/erts/emulator/test/time_SUITE.erl
index 87b8c62cfa..9501569814 100644
--- a/erts/emulator/test/time_SUITE.erl
+++ b/erts/emulator/test/time_SUITE.erl
@@ -295,7 +295,7 @@ timestamp(Config) when is_list(Config) ->
 
 os_system_time_offset() ->
     erlang:convert_time_unit(os:system_time() - erlang:monotonic_time(),
-			     native, micro_seconds).
+			     native, microsecond).
 
 had_time_warp(Secs) ->
     had_time_warp(os_system_time_offset(), Secs).
@@ -488,12 +488,12 @@ check_time_warp_mode(Config, TimeCorrection, TimeWarpMode) ->
     MonotonicTimeUnit = rpc:call(Node,
 				       erlang,
 				       convert_time_unit,
-				       [1, seconds, native]),
+				       [1, second, native]),
     UpMilliSeconds = erlang:convert_time_unit(MonotonicTime - StartTime,
 					      MonotonicTimeUnit,
-					      milli_seconds),
+					      millisecond),
     io:format("UpMilliSeconds=~p~n", [UpMilliSeconds]),
-    End = erlang:monotonic_time(milli_seconds),
+    End = erlang:monotonic_time(millisecond),
     stop_node(Node),
     try
 	true = (UpMilliSeconds > (98*MonotonicityTimeout) div 100),
@@ -810,10 +810,10 @@ do_check_erlang_timestamp(Done, Mon, TO) ->
     MaxMon = erlang:monotonic_time(),
     TsMin = erlang:convert_time_unit(MinMon+TO,
 				     native,
-				     micro_seconds),
+				     microsecond),
     TsMax = erlang:convert_time_unit(MaxMon+TO,
 				     native,
-				     micro_seconds),
+				     microsecond),
     TsTime = (MegaSec*1000000+Sec)*1000000+MicroSec,
     case (TsMin =< TsTime) andalso (TsTime =< TsMax) of
 	true ->
diff --git a/erts/emulator/test/timer_bif_SUITE.erl b/erts/emulator/test/timer_bif_SUITE.erl
index 44f276f232..7cbd93a0f3 100644
--- a/erts/emulator/test/timer_bif_SUITE.erl
+++ b/erts/emulator/test/timer_bif_SUITE.erl
@@ -489,7 +489,7 @@ registered_process(Config) when is_list(Config) ->
 same_time_yielding(Config) when is_list(Config) ->
     Mem = mem(),
     SchdlrsOnln = erlang:system_info(schedulers_online),
-    Tmo = erlang:monotonic_time(milli_seconds) + 3000,
+    Tmo = erlang:monotonic_time(millisecond) + 3000,
     Tmrs = lists:map(fun (I) ->
                              process_flag(scheduler, (I rem SchdlrsOnln) + 1),
                              erlang:start_timer(Tmo, self(), hej, [{abs, true}])
@@ -497,7 +497,7 @@ same_time_yielding(Config) when is_list(Config) ->
                      lists:seq(1, (?TIMEOUT_YIELD_LIMIT*3+1)*SchdlrsOnln)),
     true = mem_larger_than(Mem),
     lists:foreach(fun (Tmr) -> receive {timeout, Tmr, hej} -> ok end end, Tmrs),
-    Done = erlang:monotonic_time(milli_seconds),
+    Done = erlang:monotonic_time(millisecond),
     true = Done >= Tmo,
     case erlang:system_info(build_type) of
         opt -> true = Done < Tmo + 200;
@@ -517,10 +517,10 @@ same_time_yielding_with_cancel_other(Config) when is_list(Config) ->
 
 do_cancel_tmrs(Tmo, Tmrs, Tester) ->
     BeginCancel = erlang:convert_time_unit(Tmo,
-                                           milli_seconds,
-                                           micro_seconds) - 100,
+                                           millisecond,
+                                           microsecond) - 100,
     busy_wait_until(fun () ->
-                            erlang:monotonic_time(micro_seconds) >= BeginCancel
+                            erlang:monotonic_time(microsecond) >= BeginCancel
                     end),
     lists:foreach(fun (Tmr) ->
                           erlang:cancel_timer(Tmr,
@@ -535,7 +535,7 @@ do_cancel_tmrs(Tmo, Tmrs, Tester) ->
 same_time_yielding_with_cancel_test(Other, Accessor) ->
     Mem = mem(),
     SchdlrsOnln = erlang:system_info(schedulers_online),
-    Tmo = erlang:monotonic_time(milli_seconds) + 3000,
+    Tmo = erlang:monotonic_time(millisecond) + 3000,
     Tester = self(),
     Cancelor = case Other of
                    false ->
@@ -656,7 +656,7 @@ get_msg() ->
 start_slave() ->
     Pa = filename:dirname(code:which(?MODULE)),
     Name = atom_to_list(?MODULE)
-    ++ "-" ++ integer_to_list(erlang:system_time(seconds))
+    ++ "-" ++ integer_to_list(erlang:system_time(second))
     ++ "-" ++ integer_to_list(erlang:unique_integer([positive])),
     {ok, Node} = test_server:start_node(Name, slave, [{args, "-pa " ++ Pa}]),
     Node.
diff --git a/erts/emulator/test/trace_bif_SUITE.erl b/erts/emulator/test/trace_bif_SUITE.erl
index 491b37ae46..f60c777ba1 100644
--- a/erts/emulator/test/trace_bif_SUITE.erl
+++ b/erts/emulator/test/trace_bif_SUITE.erl
@@ -289,9 +289,9 @@ receive_trace_msg_ts_return_to({trace_ts, Pid, return_to, {M,F,A}}, PrevTs, TsTy
 make_ts(timestamp) ->
     erlang:now();
 make_ts(monotonic_timestamp) ->
-    erlang:monotonic_time(nano_seconds);
+    erlang:monotonic_time(nanosecond);
 make_ts(strict_monotonic_timestamp) ->
-    MT = erlang:monotonic_time(nano_seconds),
+    MT = erlang:monotonic_time(nanosecond),
     UMI = erlang:unique_integer([monotonic]),
     {MT, UMI}.
 
diff --git a/erts/emulator/test/trace_call_time_SUITE.erl b/erts/emulator/test/trace_call_time_SUITE.erl
index 6582ad134b..26f96a1766 100644
--- a/erts/emulator/test/trace_call_time_SUITE.erl
+++ b/erts/emulator/test/trace_call_time_SUITE.erl
@@ -294,7 +294,7 @@ combo(Config) when is_list(Config) ->
     T0 = erlang:monotonic_time(),
     with_bif(Nbc),
     T1 = erlang:monotonic_time(),
-    TimeB = erlang:convert_time_unit(T1-T0, native, micro_seconds),
+    TimeB = erlang:convert_time_unit(T1-T0, native, microsecond),
     %%
 
     List = collect(100),
@@ -655,13 +655,13 @@ execute(Pids, Mfa) when is_list(Pids) ->
     [P  ! {self(), execute, Mfa} || P <- Pids],
     As = [receive {P, answer, Answer} -> Answer end || P <- Pids],
     T1 = erlang:monotonic_time(),
-    {As, erlang:convert_time_unit(T1-T0, native, micro_seconds)};
+    {As, erlang:convert_time_unit(T1-T0, native, microsecond)};
 execute(P, Mfa) ->
     T0 = erlang:monotonic_time(),
     P  ! {self(), execute, Mfa},
     A  = receive {P, answer, Answer} -> Answer end,
     T1 = erlang:monotonic_time(),
-    {A, erlang:convert_time_unit(T1-T0, native, micro_seconds)}.
+    {A, erlang:convert_time_unit(T1-T0, native, microsecond)}.