Simplify naming in tests.

test/syn_create_mnesia_SUITE.erl

@@ -127,10 +127,10 @@ end_per_suite(_Config) -> ok.
 init_per_group(two_nodes_mnesia_creation, Config) ->
     %% start slave
     SlaveNodeShortName = proplists:get_value(slave_node_short_name, Config),
-    {ok, SlaveNodeName} = syn_test_suite_helper:start_slave(SlaveNodeShortName),
+    {ok, SlaveNode} = syn_test_suite_helper:start_slave(SlaveNodeShortName),
     %% config
     [
-        {slave_node_name, SlaveNodeName}
+        {slave_node, SlaveNode}
         | Config
     ];
 init_per_group(_GroupName, Config) -> Config.
@@ -168,8 +168,8 @@ init_per_testcase(_TestCase, Config) ->
 % ----------------------------------------------------------------------------------------------------------
 end_per_testcase(_TestCase, Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
-    syn_test_suite_helper:clean_after_test(SlaveNodeName).
+    SlaveNode = proplists:get_value(slave_node, Config),
+    syn_test_suite_helper:clean_after_test(SlaveNode).
 
 %% ===================================================================
 %% Tests
@@ -212,68 +212,68 @@ single_node_when_mnesia_is_disc(_Config) ->
 
 two_nodes_when_mnesia_is_ram(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     %% set schema location
     application:set_env(mnesia, schema_location, ram),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [ram]),
+    rpc:call(SlaveNode, mnesia, schema_location, [ram]),
     %% start
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
     %% check table exists on local
     true = lists:member(syn_processes_table, mnesia:system_info(tables)),
     %% check table exists on remote
-    SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNodeName, mnesia, system_info, [tables]),
-    true = rpc:call(SlaveNodeName, lists, member, [syn_processes_table, SlaveNodeMnesiaSystemInfo]).
+    SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNode, mnesia, system_info, [tables]),
+    true = rpc:call(SlaveNode, lists, member, [syn_processes_table, SlaveNodeMnesiaSystemInfo]).
 
 two_nodes_when_mnesia_is_opt_disc_no_schema_exists(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     %% set schema location
     application:set_env(mnesia, schema_location, opt_disc),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [opt_disc]),
+    rpc:call(SlaveNode, mnesia, schema_location, [opt_disc]),
     %% start
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
     %% check table exists on local
     true = lists:member(syn_processes_table, mnesia:system_info(tables)),
     %% check table exists on remote
-    SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNodeName, mnesia, system_info, [tables]),
-    true = rpc:call(SlaveNodeName, lists, member, [syn_processes_table, SlaveNodeMnesiaSystemInfo]).
+    SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNode, mnesia, system_info, [tables]),
+    true = rpc:call(SlaveNode, lists, member, [syn_processes_table, SlaveNodeMnesiaSystemInfo]).
 
 two_nodes_when_mnesia_is_opt_disc_schema_exists(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     %% set schema location
     application:set_env(mnesia, schema_location, opt_disc),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [opt_disc]),
+    rpc:call(SlaveNode, mnesia, schema_location, [opt_disc]),
     %% create schema
-    mnesia:create_schema([node(), SlaveNodeName]),
+    mnesia:create_schema([node(), SlaveNode]),
     %% start
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
     %% check table exists on local
     true = lists:member(syn_processes_table, mnesia:system_info(tables)),
     %% check table exists on remote
-    SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNodeName, mnesia, system_info, [tables]),
-    true = rpc:call(SlaveNodeName, lists, member, [syn_processes_table, SlaveNodeMnesiaSystemInfo]).
+    SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNode, mnesia, system_info, [tables]),
+    true = rpc:call(SlaveNode, lists, member, [syn_processes_table, SlaveNodeMnesiaSystemInfo]).
 
 two_nodes_when_mnesia_is_disc(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     %% set schema location
     application:set_env(mnesia, schema_location, disc),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [disc]),
+    rpc:call(SlaveNode, mnesia, schema_location, [disc]),
     %% create schema
-    mnesia:create_schema([node(), SlaveNodeName]),
+    mnesia:create_schema([node(), SlaveNode]),
     %% start
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
     %% check table exists on local
     true = lists:member(syn_processes_table, mnesia:system_info(tables)),
     %% check table exists on remote
-    SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNodeName, mnesia, system_info, [tables]),
-    true = rpc:call(SlaveNodeName, lists, member, [syn_processes_table, SlaveNodeMnesiaSystemInfo]).
+    SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNode, mnesia, system_info, [tables]),
+    true = rpc:call(SlaveNode, lists, member, [syn_processes_table, SlaveNodeMnesiaSystemInfo]).

test/syn_netsplits_SUITE.erl

@@ -94,11 +94,11 @@ init_per_suite(Config) ->
     %% init
     SlaveNodeShortName = syn_slave,
     %% start slave
-    {ok, SlaveNodeName} = syn_test_suite_helper:start_slave(SlaveNodeShortName),
+    {ok, SlaveNode} = syn_test_suite_helper:start_slave(SlaveNodeShortName),
     %% config
     [
         {slave_node_short_name, SlaveNodeShortName},
-        {slave_node_name, SlaveNodeName}
+        {slave_node, SlaveNode}
         | Config
     ].
 
@@ -139,10 +139,10 @@ end_per_group(_GroupName, _Config) -> ok.
 % ----------------------------------------------------------------------------------------------------------
 init_per_testcase(_TestCase, Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     %% set schema location
     application:set_env(mnesia, schema_location, ram),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [ram]),
+    rpc:call(SlaveNode, mnesia, schema_location, [ram]),
     %% return
     Config.
 
@@ -155,49 +155,49 @@ init_per_testcase(_TestCase, Config) ->
 % ----------------------------------------------------------------------------------------------------------
 end_per_testcase(_TestCase, Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
-    syn_test_suite_helper:clean_after_test(SlaveNodeName).
+    SlaveNode = proplists:get_value(slave_node, Config),
+    syn_test_suite_helper:clean_after_test(SlaveNode).
 
 %% ===================================================================
 %% Tests
 %% ===================================================================
 two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     CurrentNode = node(),
 
     %% start syn
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
 
     %% start processes
     LocalPid = syn_test_suite_helper:start_process(),
-    SlavePidLocal = syn_test_suite_helper:start_process(SlaveNodeName),
-    SlavePidSlave = syn_test_suite_helper:start_process(SlaveNodeName),
+    SlavePidLocal = syn_test_suite_helper:start_process(SlaveNode),
+    SlavePidSlave = syn_test_suite_helper:start_process(SlaveNode),
 
     %% register
     ok = syn:register(local_pid, LocalPid),
     ok = syn:register(slave_pid_local, SlavePidLocal),    %% slave registered on local node
-    ok = rpc:call(SlaveNodeName, syn, register, [slave_pid_slave, SlavePidSlave]),    %% slave registered on slave node
+    ok = rpc:call(SlaveNode, syn, register, [slave_pid_slave, SlavePidSlave]),    %% slave registered on slave node
     timer:sleep(100),
 
     %% check tables
     3 = mnesia:table_info(syn_processes_table, size),
-    3 = rpc:call(SlaveNodeName, mnesia, table_info, [syn_processes_table, size]),
+    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
 
     LocalActiveReplicas = mnesia:table_info(syn_processes_table, active_replicas),
     2 = length(LocalActiveReplicas),
-    true = lists:member(SlaveNodeName, LocalActiveReplicas),
+    true = lists:member(SlaveNode, LocalActiveReplicas),
     true = lists:member(CurrentNode, LocalActiveReplicas),
 
-    SlaveActiveReplicas = rpc:call(SlaveNodeName, mnesia, table_info, [syn_processes_table, active_replicas]),
+    SlaveActiveReplicas = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, active_replicas]),
     2 = length(SlaveActiveReplicas),
-    true = lists:member(SlaveNodeName, SlaveActiveReplicas),
+    true = lists:member(SlaveNode, SlaveActiveReplicas),
     true = lists:member(CurrentNode, SlaveActiveReplicas),
 
     %% simulate net split
-    syn_test_suite_helper:disconnect_node(SlaveNodeName),
+    syn_test_suite_helper:disconnect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
@@ -205,21 +205,21 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     [CurrentNode] = mnesia:table_info(syn_processes_table, active_replicas),
 
     %% reconnect
-    syn_test_suite_helper:connect_node(SlaveNodeName),
+    syn_test_suite_helper:connect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
     3 = mnesia:table_info(syn_processes_table, size),
-    3 = rpc:call(SlaveNodeName, mnesia, table_info, [syn_processes_table, size]),
+    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
 
     LocalActiveReplicas2 = mnesia:table_info(syn_processes_table, active_replicas),
     2 = length(LocalActiveReplicas2),
-    true = lists:member(SlaveNodeName, LocalActiveReplicas2),
+    true = lists:member(SlaveNode, LocalActiveReplicas2),
     true = lists:member(CurrentNode, LocalActiveReplicas2),
 
-    SlaveActiveReplicas2 = rpc:call(SlaveNodeName, mnesia, table_info, [syn_processes_table, active_replicas]),
+    SlaveActiveReplicas2 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, active_replicas]),
     2 = length(SlaveActiveReplicas2),
-    true = lists:member(SlaveNodeName, SlaveActiveReplicas2),
+    true = lists:member(SlaveNode, SlaveActiveReplicas2),
     true = lists:member(CurrentNode, SlaveActiveReplicas2),
 
     %% check processes
@@ -227,9 +227,9 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     SlavePidLocal = syn:find_by_key(slave_pid_local),
     SlavePidSlave = syn:find_by_key(slave_pid_slave),
 
-    LocalPid = rpc:call(SlaveNodeName, syn, find_by_key, [local_pid]),
-    SlavePidLocal = rpc:call(SlaveNodeName, syn, find_by_key, [slave_pid_local]),
-    SlavePidSlave = rpc:call(SlaveNodeName, syn, find_by_key, [slave_pid_slave]),
+    LocalPid = rpc:call(SlaveNode, syn, find_by_key, [local_pid]),
+    SlavePidLocal = rpc:call(SlaveNode, syn, find_by_key, [slave_pid_local]),
+    SlavePidSlave = rpc:call(SlaveNode, syn, find_by_key, [slave_pid_slave]),
 
     %% kill processes
     syn_test_suite_helper:kill_process(LocalPid),
@@ -238,17 +238,17 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
 
 two_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     CurrentNode = node(),
 
     %% start syn
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
 
     %% start processes
     LocalPid = syn_test_suite_helper:start_process(),
-    SlavePid = syn_test_suite_helper:start_process(SlaveNodeName),
+    SlavePid = syn_test_suite_helper:start_process(SlaveNode),
 
     %% register
     ok = syn:register(conflicting_key, SlavePid),
@@ -256,13 +256,13 @@ two_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
 
     %% check tables
     1 = mnesia:table_info(syn_processes_table, size),
-    1 = rpc:call(SlaveNodeName, mnesia, table_info, [syn_processes_table, size]),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
 
     %% check process
     SlavePid = syn:find_by_key(conflicting_key),
 
     %% simulate net split
-    syn_test_suite_helper:disconnect_node(SlaveNodeName),
+    syn_test_suite_helper:disconnect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
@@ -276,12 +276,12 @@ two_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
     LocalPid = syn:find_by_key(conflicting_key),
 
     %% reconnect
-    syn_test_suite_helper:connect_node(SlaveNodeName),
+    syn_test_suite_helper:connect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
     1 = mnesia:table_info(syn_processes_table, size),
-    1 = rpc:call(SlaveNodeName, mnesia, table_info, [syn_processes_table, size]),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
 
     %% check process
     FoundPid = syn:find_by_key(conflicting_key),
@@ -293,21 +293,21 @@ two_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
 
 two_nodes_netsplit_message_resolution_when_there_are_conflicts(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     CurrentNode = node(),
 
     %% load configuration variables from syn-test.config => this sets the netsplit_send_message_to_process option
     syn_test_suite_helper:set_environment_variables(),
-    syn_test_suite_helper:set_environment_variables(SlaveNodeName),
+    syn_test_suite_helper:set_environment_variables(SlaveNode),
 
     %% start syn
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
 
     %% start processes
     LocalPid = syn_test_suite_helper:start_process(fun process_reply_main/0),
-    SlavePid = syn_test_suite_helper:start_process(SlaveNodeName, fun process_reply_main/0),
+    SlavePid = syn_test_suite_helper:start_process(SlaveNode, fun process_reply_main/0),
 
     %% register global process
     ResultPid = self(),
@@ -319,13 +319,13 @@ two_nodes_netsplit_message_resolution_when_there_are_conflicts(Config) ->
 
     %% check tables
     1 = mnesia:table_info(syn_processes_table, size),
-    1 = rpc:call(SlaveNodeName, mnesia, table_info, [syn_processes_table, size]),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
 
     %% check process
     SlavePid = syn:find_by_key(conflicting_key),
 
     %% simulate net split
-    syn_test_suite_helper:disconnect_node(SlaveNodeName),
+    syn_test_suite_helper:disconnect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
@@ -339,12 +339,12 @@ two_nodes_netsplit_message_resolution_when_there_are_conflicts(Config) ->
     LocalPid = syn:find_by_key(conflicting_key),
 
     %% reconnect
-    syn_test_suite_helper:connect_node(SlaveNodeName),
+    syn_test_suite_helper:connect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
     1 = mnesia:table_info(syn_processes_table, size),
-    1 = rpc:call(SlaveNodeName, mnesia, table_info, [syn_processes_table, size]),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
 
     %% check process
     FoundPid = syn:find_by_key(conflicting_key),

test/syn_register_processes_SUITE.erl

@@ -136,10 +136,10 @@ end_per_suite(_Config) -> ok.
 init_per_group(two_nodes_process_registration, Config) ->
     %% start slave
     SlaveNodeShortName = proplists:get_value(slave_node_short_name, Config),
-    {ok, SlaveNodeName} = syn_test_suite_helper:start_slave(SlaveNodeShortName),
+    {ok, SlaveNode} = syn_test_suite_helper:start_slave(SlaveNodeShortName),
     %% config
     [
-        {slave_node_name, SlaveNodeName}
+        {slave_node, SlaveNode}
         | Config
     ];
 init_per_group(_GroupName, Config) -> Config.
@@ -177,8 +177,8 @@ init_per_testcase(_TestCase, Config) ->
 % ----------------------------------------------------------------------------------------------------------
 end_per_testcase(_TestCase, Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
-    syn_test_suite_helper:clean_after_test(SlaveNodeName).
+    SlaveNode = proplists:get_value(slave_node, Config),
+    syn_test_suite_helper:clean_after_test(SlaveNode).
 
 %% ===================================================================
 %% Tests
@@ -340,53 +340,53 @@ single_node_when_mnesia_is_disc_find_by_key(_Config) ->
 
 two_nodes_when_mnesia_is_ram_find_by_key(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     %% set schema location
     application:set_env(mnesia, schema_location, ram),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [ram]),
+    rpc:call(SlaveNode, mnesia, schema_location, [ram]),
     %% start
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
     %% start process
     Pid = syn_test_suite_helper:start_process(),
     %% retrieve
     undefined = syn:find_by_key(<<"my proc">>),
-    undefined = rpc:call(SlaveNodeName, syn, find_by_key, [<<"my proc">>]),
+    undefined = rpc:call(SlaveNode, syn, find_by_key, [<<"my proc">>]),
     %% register
     ok = syn:register(<<"my proc">>, Pid),
     %% retrieve
     Pid = syn:find_by_key(<<"my proc">>),
-    Pid = rpc:call(SlaveNodeName, syn, find_by_key, [<<"my proc">>]),
+    Pid = rpc:call(SlaveNode, syn, find_by_key, [<<"my proc">>]),
     %% kill process
     syn_test_suite_helper:kill_process(Pid),
     timer:sleep(100),
     %% retrieve
     undefined = syn:find_by_key(<<"my proc">>),
-    undefined = rpc:call(SlaveNodeName, syn, find_by_key, [<<"my proc">>]).
+    undefined = rpc:call(SlaveNode, syn, find_by_key, [<<"my proc">>]).
 
 two_nodes_when_mnesia_is_ram_process_count(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     CurrentNode = node(),
     %% set schema location
     application:set_env(mnesia, schema_location, ram),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [ram]),
+    rpc:call(SlaveNode, mnesia, schema_location, [ram]),
     %% start
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
     %% count
     0 = syn:count(),
-    0 = rpc:call(SlaveNodeName, syn, count, []),
+    0 = rpc:call(SlaveNode, syn, count, []),
     0 = syn:count(CurrentNode),
-    0 = syn:count(SlaveNodeName),
-    0 = rpc:call(SlaveNodeName, syn, count, [CurrentNode]),
-    0 = rpc:call(SlaveNodeName, syn, count, [SlaveNodeName]),
+    0 = syn:count(SlaveNode),
+    0 = rpc:call(SlaveNode, syn, count, [CurrentNode]),
+    0 = rpc:call(SlaveNode, syn, count, [SlaveNode]),
     %% start processes
     PidLocal1 = syn_test_suite_helper:start_process(),
     PidLocal2 = syn_test_suite_helper:start_process(),
-    PidSlave = syn_test_suite_helper:start_process(SlaveNodeName),
+    PidSlave = syn_test_suite_helper:start_process(SlaveNode),
     %% register
     ok = syn:register(1, PidLocal1),
     ok = syn:register(2, PidLocal2),
@@ -394,11 +394,11 @@ two_nodes_when_mnesia_is_ram_process_count(Config) ->
     timer:sleep(100),
     %% count
     3 = syn:count(),
-    3 = rpc:call(SlaveNodeName, syn, count, []),
+    3 = rpc:call(SlaveNode, syn, count, []),
     2 = syn:count(CurrentNode),
-    1 = syn:count(SlaveNodeName),
-    2 = rpc:call(SlaveNodeName, syn, count, [CurrentNode]),
-    1 = rpc:call(SlaveNodeName, syn, count, [SlaveNodeName]),
+    1 = syn:count(SlaveNode),
+    2 = rpc:call(SlaveNode, syn, count, [CurrentNode]),
+    1 = rpc:call(SlaveNode, syn, count, [SlaveNode]),
     %% kill processes
     syn_test_suite_helper:kill_process(PidLocal1),
     syn_test_suite_helper:kill_process(PidLocal2),
@@ -406,32 +406,32 @@ two_nodes_when_mnesia_is_ram_process_count(Config) ->
     timer:sleep(100),
     %% count
     0 = syn:count(),
-    0 = rpc:call(SlaveNodeName, syn, count, []),
+    0 = rpc:call(SlaveNode, syn, count, []),
     0 = syn:count(CurrentNode),
-    0 = syn:count(SlaveNodeName),
-    0 = rpc:call(SlaveNodeName, syn, count, [CurrentNode]),
-    0 = rpc:call(SlaveNodeName, syn, count, [SlaveNodeName]).
+    0 = syn:count(SlaveNode),
+    0 = rpc:call(SlaveNode, syn, count, [CurrentNode]),
+    0 = rpc:call(SlaveNode, syn, count, [SlaveNode]).
 
 two_nodes_when_mnesia_is_ram_callback_on_process_exit(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     CurrentNode = node(),
     %% set schema location
     application:set_env(mnesia, schema_location, ram),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [ram]),
+    rpc:call(SlaveNode, mnesia, schema_location, [ram]),
     %% load configuration variables from syn-test.config => this defines the callback
     syn_test_suite_helper:set_environment_variables(),
-    syn_test_suite_helper:set_environment_variables(SlaveNodeName),
+    syn_test_suite_helper:set_environment_variables(SlaveNode),
     %% start
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
     %% register global process
     ResultPid = self(),
     global:register_name(syn_register_process_SUITE_result, ResultPid),
     %% start processes
     PidLocal = syn_test_suite_helper:start_process(),
-    PidSlave = syn_test_suite_helper:start_process(SlaveNodeName),
+    PidSlave = syn_test_suite_helper:start_process(SlaveNode),
     %% register
     ok = syn:register(<<"local">>, PidLocal),
     ok = syn:register(<<"slave">>, PidSlave),
@@ -445,22 +445,22 @@ two_nodes_when_mnesia_is_ram_callback_on_process_exit(Config) ->
         ok = process_exit_callback_was_not_called_from_local_node
     end,
     receive
-        {exited, SlaveNodeName, <<"slave">>, PidSlave, killed} -> ok
+        {exited, SlaveNode, <<"slave">>, PidSlave, killed} -> ok
     after 2000 ->
         ok = process_exit_callback_was_not_called_from_slave_node
     end.
 
 two_nodes_when_mnesia_is_disc_find_by_pid(Config) ->
     %% get slave
-    SlaveNodeName = proplists:get_value(slave_node_name, Config),
+    SlaveNode = proplists:get_value(slave_node, Config),
     %% set schema location
     application:set_env(mnesia, schema_location, disc),
-    rpc:call(SlaveNodeName, mnesia, schema_location, [disc]),
+    rpc:call(SlaveNode, mnesia, schema_location, [disc]),
     %% create schema
-    mnesia:create_schema([node(), SlaveNodeName]),
+    mnesia:create_schema([node(), SlaveNode]),
     %% start
     ok = syn:start(),
-    ok = rpc:call(SlaveNodeName, syn, start, []),
+    ok = rpc:call(SlaveNode, syn, start, []),
     timer:sleep(100),
     %% start process
     Pid = syn_test_suite_helper:start_process(),
@@ -468,13 +468,13 @@ two_nodes_when_mnesia_is_disc_find_by_pid(Config) ->
     ok = syn:register(<<"my proc">>, Pid),
     %% retrieve
     <<"my proc">> = syn:find_by_pid(Pid),
-    <<"my proc">> = rpc:call(SlaveNodeName, syn, find_by_pid, [Pid]),
+    <<"my proc">> = rpc:call(SlaveNode, syn, find_by_pid, [Pid]),
     %% kill process
     syn_test_suite_helper:kill_process(Pid),
     timer:sleep(100),
     %% retrieve
     undefined = syn:find_by_pid(Pid),
-    undefined = rpc:call(SlaveNodeName, syn, find_by_pid, [Pid]).
+    undefined = rpc:call(SlaveNode, syn, find_by_pid, [Pid]).
 
 %% ===================================================================
 %% Internal

test/syn_test_suite_helper.erl

@@ -62,20 +62,20 @@ start_slave(NodeShortName) ->
     EbinFilePath = filename:join([filename:dirname(code:lib_dir(syn, ebin)), "ebin"]),
     TestFilePath = filename:join([filename:dirname(code:lib_dir(syn, ebin)), "test"]),
     %% start slave
-    {ok, NodeName} = ct_slave:start(NodeShortName, [
+    {ok, Node} = ct_slave:start(NodeShortName, [
         {boot_timeout, 10},
         {erl_flags, lists:concat(["-pa ", EbinFilePath, " ", TestFilePath])}
     ]),
-    {ok, NodeName}.
+    {ok, Node}.
 
 stop_slave(NodeShortName) ->
     {ok, _} = ct_slave:stop(NodeShortName).
 
-connect_node(NodeName) ->
-    net_kernel:connect_node(NodeName).
+connect_node(Node) ->
+    net_kernel:connect_node(Node).
 
-disconnect_node(NodeName) ->
-    erlang:disconnect_node(NodeName).
+disconnect_node(Node) ->
+    erlang:disconnect_node(Node).
 
 clean_after_test() ->
     %% delete table
@@ -89,29 +89,29 @@ clean_after_test() ->
 
 clean_after_test(undefined) ->
     clean_after_test();
-clean_after_test(NodeName) ->
+clean_after_test(Node) ->
     %% delete table
     {atomic, ok} = mnesia:delete_table(syn_processes_table),
     %% stop mnesia
     mnesia:stop(),
-    rpc:call(NodeName, mnesia, stop, []),
+    rpc:call(Node, mnesia, stop, []),
     %% delete schema
-    mnesia:delete_schema([node(), NodeName]),
+    mnesia:delete_schema([node(), Node]),
     %% stop syn
     syn:stop(),
-    rpc:call(NodeName, syn, stop, []).
+    rpc:call(Node, syn, stop, []).
 
 start_process() ->
     Pid = spawn(fun process_main/0),
     Pid.
-start_process(NodeName) when is_atom(NodeName) ->
-    Pid = spawn(NodeName, fun process_main/0),
+start_process(Node) when is_atom(Node) ->
+    Pid = spawn(Node, fun process_main/0),
     Pid;
 start_process(Loop) when is_function(Loop) ->
     Pid = spawn(Loop),
     Pid.
-start_process(NodeName, Loop)->
-    Pid = spawn(NodeName, Loop),
+start_process(Node, Loop)->
+    Pid = spawn(Node, Loop),
     Pid.
 
 kill_process(Pid) ->