Merge branch 'spelling' of https://github.com/jsoref/rabbitmq-server into jsoref-spelling

15 files changed, 25 insertions, 25 deletions

diff --git a/test/channel_operation_timeout_SUITE.erl b/test/channel_operation_timeout_SUITE.erl
index 77da6133d8..47907d09f4 100644
--- a/test/channel_operation_timeout_SUITE.erl
+++ b/test/channel_operation_timeout_SUITE.erl
@@ -87,7 +87,7 @@ notify_down_all(Config) ->
     declare(QCfg0),
     %% Testing rabbit_amqqueue:notify_down_all via rabbit_channel.
     %% Consumer count = 0 after correct channel termination and
-    %% notification of queues via delagate:call/3
+    %% notification of queues via delegate:call/3
     true = (0 =/= length(get_consumers(Config, Rabbit, ?DEFAULT_VHOST))),
     rabbit_ct_client_helpers:close_channel(RabbitCh),
     0 = length(get_consumers(Config, Rabbit, ?DEFAULT_VHOST)),
diff --git a/test/clustering_management_SUITE.erl b/test/clustering_management_SUITE.erl
index 5ae2fb687c..a4fd63ba04 100644
--- a/test/clustering_management_SUITE.erl
+++ b/test/clustering_management_SUITE.erl
@@ -153,9 +153,9 @@ join_and_part_cluster(Config) ->
 join_cluster_bad_operations(Config) ->
     [Rabbit, Hare, Bunny] = cluster_members(Config),
 
-    %% Non-existant node
+    %% Nonexistent node
     ok = stop_app(Rabbit),
-    assert_failure(fun () -> join_cluster(Rabbit, non@existant) end),
+    assert_failure(fun () -> join_cluster(Rabbit, non@existent) end),
     ok = start_app(Rabbit),
     assert_not_clustered(Rabbit),
 
@@ -217,8 +217,8 @@ forget_cluster_node(Config) ->
     ok = stop_app(Rabbit),
     %% We're passing the --offline flag, but Hare is online
     assert_failure(fun () -> forget_cluster_node(Hare, Rabbit, true) end),
-    %% Removing some non-existant node will fail
-    assert_failure(fun () -> forget_cluster_node(Hare, non@existant) end),
+    %% Removing some nonexistent node will fail
+    assert_failure(fun () -> forget_cluster_node(Hare, non@existent) end),
     ok = forget_cluster_node(Hare, Rabbit),
     assert_not_clustered(Hare),
     assert_cluster_status({[Rabbit, Hare], [Rabbit, Hare], [Hare]},
@@ -504,8 +504,8 @@ update_cluster_nodes(Config) ->
     stop_reset_start(Hare),
     assert_failure(fun () -> start_app(Rabbit) end),
     %% Bogus node
-    assert_failure(fun () -> update_cluster_nodes(Rabbit, non@existant) end),
-    %% Inconsisent node
+    assert_failure(fun () -> update_cluster_nodes(Rabbit, non@existent) end),
+    %% Inconsistent node
     assert_failure(fun () -> update_cluster_nodes(Rabbit, Hare) end),
     ok = update_cluster_nodes(Rabbit, Bunny),
     ok = start_app(Rabbit),
diff --git a/test/dead_lettering_SUITE.erl b/test/dead_lettering_SUITE.erl
index 72c72b096c..6722958973 100644
--- a/test/dead_lettering_SUITE.erl
+++ b/test/dead_lettering_SUITE.erl
@@ -577,7 +577,7 @@ dead_letter_routing_key_header_BCC(Config) ->
 
 %% It is possible to form a cycle of message dead-lettering. For instance,
 %% this can happen when a queue dead-letters messages to the default exchange without
-%% specifiying a dead-letter routing key (5). Messages in such cycles (i.e. messages that
+%% specifying a dead-letter routing key (5). Messages in such cycles (i.e. messages that
 %% reach the same queue twice) will be dropped if there was no rejections in the entire cycle.
 %% i.e. x-message-ttl (7), x-max-length (6)
 %%
@@ -741,7 +741,7 @@ dead_letter_override_policy(Config) ->
     [_] = consume(Ch, DLXQName, [P1]).
 
 %% 9) Policy is set after have declared a queue with dead letter arguments. Policy will be
-%%    overriden/ignored.
+%%    overridden/ignored.
 dead_letter_ignore_policy(Config) ->
     {_Conn, Ch} = rabbit_ct_client_helpers:open_connection_and_channel(Config, 0),
     QName = ?config(queue_name, Config),
diff --git a/test/dynamic_ha_SUITE.erl b/test/dynamic_ha_SUITE.erl
index 6ccf3a75c3..3bdf7bb009 100644
--- a/test/dynamic_ha_SUITE.erl
+++ b/test/dynamic_ha_SUITE.erl
@@ -484,7 +484,7 @@ failing_random_policies(Config) ->
     [A, B | _] = Nodes = rabbit_ct_broker_helpers:get_node_configs(Config,
       nodename),
     %% Those set of policies were found as failing by PropEr in the
-    %% `random_policy` test above. We add them explicitely here to make
+    %% `random_policy` test above. We add them explicitly here to make
     %% sure they get tested.
     ?assertEqual(true, test_random_policy(Config, Nodes,
         [{nodes, [A, B]}, {nodes, [A]}])),
diff --git a/test/metrics_SUITE.erl b/test/metrics_SUITE.erl
index 44368b643d..d00c01408e 100644
--- a/test/metrics_SUITE.erl
+++ b/test/metrics_SUITE.erl
@@ -144,7 +144,7 @@ connection_metric_idemp(Config, {N, R}) ->
                || _ <- lists:seq(1, N)],
     Table = [ Pid || {Pid, _} <- read_table_rpc(Config, connection_metrics)],
     Table2 = [ Pid || {Pid, _} <- read_table_rpc(Config, connection_coarse_metrics)],
-    % referesh stats 'R' times
+    % refresh stats 'R' times
     [[Pid ! emit_stats || Pid <- Table] || _ <- lists:seq(1, R)],
     force_metric_gc(Config),
     TableAfter = [ Pid || {Pid, _} <- read_table_rpc(Config, connection_metrics)],
@@ -158,7 +158,7 @@ channel_metric_idemp(Config, {N, R}) ->
     [amqp_connection:open_channel(Conn) || _ <- lists:seq(1, N)],
     Table = [ Pid || {Pid, _} <- read_table_rpc(Config, channel_metrics)],
     Table2 = [ Pid || {Pid, _} <- read_table_rpc(Config, channel_process_metrics)],
-    % referesh stats 'R' times
+    % refresh stats 'R' times
     [[Pid ! emit_stats || Pid <- Table] || _ <- lists:seq(1, R)],
     force_metric_gc(Config),
     TableAfter = [ Pid || {Pid, _} <- read_table_rpc(Config, channel_metrics)],
@@ -181,7 +181,7 @@ queue_metric_idemp(Config, {N, R}) ->
 
     Table = [ Pid || {Pid, _, _} <- read_table_rpc(Config, queue_metrics)],
     Table2 = [ Pid || {Pid, _, _} <- read_table_rpc(Config, queue_coarse_metrics)],
-    % referesh stats 'R' times
+    % refresh stats 'R' times
     ChanTable = read_table_rpc(Config, channel_created),
     [[Pid ! emit_stats || {Pid, _, _} <- ChanTable ] || _ <- lists:seq(1, R)],
     force_metric_gc(Config),
diff --git a/test/queue_master_location_SUITE.erl b/test/queue_master_location_SUITE.erl
index d4c8da2bcb..677355f5e8 100644
--- a/test/queue_master_location_SUITE.erl
+++ b/test/queue_master_location_SUITE.erl
@@ -22,7 +22,7 @@
 %% location strategies can be applied in the following ways;
 %%   1. As policy,
 %%   2. As config (in rabbitmq.config),
-%%   3. or as part of the queue's declare arguements.
+%%   3. or as part of the queue's declare arguments.
 %%
 %% Currently supported strategies are;
 %%   min-masters : The queue master node is calculated as the one with the
diff --git a/test/quorum_queue_SUITE.erl b/test/quorum_queue_SUITE.erl
index 7d78558739..e9f49039ed 100644
--- a/test/quorum_queue_SUITE.erl
+++ b/test/quorum_queue_SUITE.erl
@@ -1503,7 +1503,7 @@ consume_redelivery_count(Config) ->
     amqp_channel:cast(Ch, #'basic.nack'{delivery_tag = DeliveryTag,
                                         multiple     = false,
                                         requeue      = true}),
-    %% wait for requeueing
+    %% wait for requeuing
     timer:sleep(500),
 
     {#'basic.get_ok'{delivery_tag = DeliveryTag1,
diff --git a/test/rabbit_fifo_SUITE.erl b/test/rabbit_fifo_SUITE.erl
index ab1f44ab27..60402b3a7b 100644
--- a/test/rabbit_fifo_SUITE.erl
+++ b/test/rabbit_fifo_SUITE.erl
@@ -104,7 +104,7 @@ basics(Config) ->
                         exit(await_msg_timeout)
               end,
 
-    % process settle applied notificaiton
+    % process settle applied notification
     FState5b = process_ra_event(FState5, 250),
     _ = ra:stop_server(ServerId),
     _ = ra:restart_server(ServerId),
diff --git a/test/rabbit_fifo_prop_SUITE.erl b/test/rabbit_fifo_prop_SUITE.erl
index c4f5690b72..437cd02e25 100644
--- a/test/rabbit_fifo_prop_SUITE.erl
+++ b/test/rabbit_fifo_prop_SUITE.erl
@@ -321,7 +321,7 @@ checkout_gen(Pid) ->
            }).
 
 expand(Ops) ->
-    %% execute each command against a rabbit_fifo state and capture all releavant
+    %% execute each command against a rabbit_fifo state and capture all relevant
     %% effects
     T = #t{},
     #t{effects = Effs} = T1 = lists:foldl(fun handle_op/2, T, Ops),
@@ -463,7 +463,7 @@ run_proper(Fun, Args, NumTests) ->
                       end}])).
 
 run_snapshot_test(Conf, Commands) ->
-    %% create every incremental permuation of the commands lists
+    %% create every incremental permutation of the commands lists
     %% and run the snapshot tests against that
     [begin
          % ?debugFmt("~w running command to ~w~n", [?FUNCTION_NAME, lists:last(C)]),
diff --git a/test/rabbit_ha_test_consumer.erl b/test/rabbit_ha_test_consumer.erl
index 8d61903308..85f0a17b2a 100644
--- a/test/rabbit_ha_test_consumer.erl
+++ b/test/rabbit_ha_test_consumer.erl
@@ -64,7 +64,7 @@ run(TestPid, Channel, Queue, CancelOnFailover, LowestSeen, MsgsToConsume) ->
                         CancelOnFailover, MsgNum, MsgsToConsume - 1);
                 MsgNum >= LowestSeen ->
                     error_logger:info_msg(
-                      "consumer ~p on ~p ignoring redeliverd msg ~p~n",
+                      "consumer ~p on ~p ignoring redelivered msg ~p~n",
                       [self(), Channel, MsgNum]),
                     true = Redelivered, %% ASSERTION
                     run(TestPid, Channel, Queue,
diff --git a/test/rabbitmqctl_shutdown_SUITE.erl b/test/rabbitmqctl_shutdown_SUITE.erl
index 0debfde2b6..b4279c6032 100644
--- a/test/rabbitmqctl_shutdown_SUITE.erl
+++ b/test/rabbitmqctl_shutdown_SUITE.erl
@@ -111,7 +111,7 @@ node_is_running(Node) ->
 shutdown_ok(Node) ->
     %% Start a command
     {stream, Stream} = rabbit_ct_broker_helpers:control_action(shutdown, Node, []),
-    %% Execute command steps. Each step will ouput a binary string
+    %% Execute command steps. Each step will output a binary string
     Lines = 'Elixir.Enum':to_list(Stream),
     ct:pal("Command output ~p ~n", [Lines]),
     [true = is_binary(Line) || Line <- Lines],
diff --git a/test/unit_inbroker_non_parallel_SUITE.erl b/test/unit_inbroker_non_parallel_SUITE.erl
index d2db382e30..aaded5fa99 100644
--- a/test/unit_inbroker_non_parallel_SUITE.erl
+++ b/test/unit_inbroker_non_parallel_SUITE.erl
@@ -338,7 +338,7 @@ log_management_during_startup1(_Config) ->
     application:unset_env(lager, extra_sinks),
     ok = try rabbit:start() of
         ok -> exit({got_success_but_expected_failure,
-                    log_rotatation_parent_dirs_test})
+                    log_rotation_parent_dirs_test})
     catch
         _:{error, {cannot_log_to_file, _, Reason2}}
             when Reason2 =:= enoent orelse Reason2 =:= eacces -> ok;
diff --git a/test/unit_inbroker_parallel_SUITE.erl b/test/unit_inbroker_parallel_SUITE.erl
index 364bd5aabb..9518e06196 100644
--- a/test/unit_inbroker_parallel_SUITE.erl
+++ b/test/unit_inbroker_parallel_SUITE.erl
@@ -1384,7 +1384,7 @@ max_message_size(Config) ->
 
     {_, Ch} = rabbit_ct_client_helpers:open_connection_and_channel(Config, 0),
 
-    %% Binary is whithin the max size limit
+    %% Binary is within the max size limit
     amqp_channel:call(Ch, #'basic.publish'{routing_key = <<"none">>}, #amqp_msg{payload = Binary2M}),
     %% The channel process is alive
     assert_channel_alive(Ch),
diff --git a/test/unit_log_config_SUITE.erl b/test/unit_log_config_SUITE.erl
index 584aa76760..07134f309a 100644
--- a/test/unit_log_config_SUITE.erl
+++ b/test/unit_log_config_SUITE.erl
@@ -660,7 +660,7 @@ env_var_tty(_) ->
     application:set_env(rabbit, lager_log_root, "/tmp/log_base"),
     application:set_env(rabbit, lager_default_file, tty),
     application:set_env(rabbit, lager_upgrade_file, tty),
-    %% tty can only be set explicitely
+    %% tty can only be set explicitly
     os:putenv("RABBITMQ_LOGS_source", "environment"),
 
     rabbit_lager:configure_lager(),
diff --git a/test/worker_pool_SUITE.erl b/test/worker_pool_SUITE.erl
index 8c9c5fa366..e53abdfa05 100644
--- a/test/worker_pool_SUITE.erl
+++ b/test/worker_pool_SUITE.erl
@@ -142,7 +142,7 @@ cancel_timeout(_) ->
         reuse),
 
     timer:sleep(1000),
-    receive {hello, Worker, Test} -> exit(timeout_is_not_canceleld)
+    receive {hello, Worker, Test} -> exit(timeout_is_not_cancelled)
     after 0 -> ok
     end.
 
@@ -179,7 +179,7 @@ cancel_timeout_by_setting(_) ->
         reuse),
 
     timer:sleep(1000),
-    receive {hello, Worker, Test} -> exit(timeout_is_not_canceleld)
+    receive {hello, Worker, Test} -> exit(timeout_is_not_cancelled)
     after 0 -> ok
     end,