← Back to branch summary

~statik/ubuntu/maverick/erlang/erlang-merge-testing

« back to all changes in this revision

Viewing changes to lib/snmp/test/snmp_manager_config_test.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-05-01 10:14:38 UTC
  • mfrom: (3.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090501101438-6qlr6rsdxgyzrg2z
Tags: 1:13.b-dfsg-2
* Cleaned up patches: removed unneeded patch which helped to support
  different SCTP library versions, made sure that changes for m68k
  architecture applied only when building on this architecture.
* Removed duplicated information from binary packages descriptions.
* Don't require libsctp-dev build-dependency on solaris-i386 architecture
  which allows to build Erlang on Nexenta (thanks to Tim Spriggs for
  the suggestion).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/snmp/test/snmp_manager_config_test.erl
1
 
%%<copyright>
2
 
%% <year>2004-2008</year>
3
 
%% <holder>Ericsson AB, All Rights Reserved</holder>
4
 
%%</copyright>
5
 
%%<legalnotice>
 
1
%% 
 
2
%% %CopyrightBegin%
 
3
%% 
 
4
%% Copyright Ericsson AB 2004-2009. All Rights Reserved.
 
5
%% 
6
6
%% The contents of this file are subject to the Erlang Public License,
7
7
%% Version 1.1, (the "License"); you may not use this file except in
8
8
%% compliance with the License. You should have received a copy of the
9
9
%% Erlang Public License along with this software. If not, it can be
10
10
%% retrieved online at http://www.erlang.org/.
11
 
%%
 
11
%% 
12
12
%% Software distributed under the License is distributed on an "AS IS"
13
13
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
14
14
%% the License for the specific language governing rights and limitations
15
15
%% under the License.
16
 
%%
17
 
%% The Initial Developer of the Original Code is Ericsson AB.
18
 
%%</legalnotice>
19
 
%%
 
16
%% 
 
17
%% %CopyrightEnd%
 
18
%% 
 
19
 
20
20
%%----------------------------------------------------------------------
21
21
%% Purpose:
22
22
%% 
830
830
 
831
831
    %% --
832
832
    p("write users config file with invalid user tuple (2)"),
833
 
    write_users_conf2(ConfDir, "{kalle, snmpm_user_default, kalle, olle}."),
 
833
    write_users_conf2(ConfDir, "{kalle, snmpm_user_default, kalle, [], olle}."),
834
834
    ?line {error, Reason22} = config_start(Opts),
835
835
    p("start failed (as expected): ~p", [Reason22]),
836
836
    ?line {failed_check, _, _, _, {bad_user_config, _}} = Reason22,
852
852
    ?line {failed_check, _, _, _, {bad_user_config, _}} = Reason24,
853
853
    await_config_not_running(),
854
854
 
 
855
    %% --
 
856
    p("write users config file with invalid user agent default config (1)"),
 
857
    write_users_conf2(ConfDir, "{kalle, snmpm_user_default, kalle, olle}."),
 
858
    ?line {error, Reason31} = config_start(Opts),
 
859
    p("start failed (as expected): ~p", [Reason31]),
 
860
    ?line {failed_check, _, _, _, {bad_default_agent_config, _}} = Reason31,
 
861
    await_config_not_running(),
 
862
 
 
863
    %% --
 
864
    p("write users config file with invalid user agent default config (2)"),
 
865
    write_users_conf2(ConfDir, "{kalle, snmpm_user_default, kalle, [olle]}."),
 
866
    ?line {error, Reason32} = config_start(Opts),
 
867
    p("start failed (as expected): ~p", [Reason32]),
 
868
    %% ?line {failed_check, _, _, _, {bad_default_agent_config, _}} = Reason32,
 
869
    case Reason32 of
 
870
        {failed_check, _, _, _, {bad_default_agent_config, _}} ->
 
871
            ok;
 
872
        {A, B, C, D} ->
 
873
            exit({bad_error, A, B, C, D})
 
874
    end,
 
875
    await_config_not_running(),
 
876
 
855
877
    p("done"),
856
878
    ok.
857
879
 
863
885
start_with_invalid_agents_conf_file1(suite) -> [];
864
886
start_with_invalid_agents_conf_file1(doc) ->
865
887
    "Start with invalid agents config file.";
866
 
start_with_invalid_agents_conf_file1(Conf) when list(Conf) -> 
867
 
    put(tname,swiacf),
 
888
start_with_invalid_agents_conf_file1(Conf) when is_list(Conf) -> 
 
889
    put(tname, swiacf),
868
890
    p("start"),
869
891
    process_flag(trap_exit, true),
870
892
    ConfDir = ?config(manager_conf_dir, Conf),
882
904
              "any", "\"initial\"", "noAuthNoPriv"},
883
905
 
884
906
    %% --
885
 
    p("write agents config file with invalid user (1)"),
 
907
    p("[test 11] write agents config file with invalid user (1)"),
886
908
    Agent11 = setelement(1, Agent0, "kalle-anka"),
887
909
    write_agents_conf(ConfDir, [Agent11]),
888
 
    ?line {error, Reason11} = config_start(Opts),
889
 
    p("start failed (as expected): ~p", [Reason11]),
890
 
    ?line {failed_reading, _, _, _, {parse_error, _}} = Reason11,
891
 
    await_config_not_running(),
 
910
    case config_start(Opts) of
 
911
        {error, Reason11} ->
 
912
            p("start failed (as expected): ~p", [Reason11]),
 
913
            ?line {failed_reading, _, _, _, {parse_error, _}} = Reason11,
 
914
            await_config_not_running();
 
915
        OK_11 ->
 
916
            exit({error, {unexpected_success, "11", OK_11}})
 
917
    end,
892
918
 
893
919
    %% --
894
 
    p("write agents config file with invalid target name (1)"),
 
920
    p("[test 21] write agents config file with invalid target name (1)"),
895
921
    Agent21 = setelement(2, Agent0, "targ-hobbes"),
896
922
    write_agents_conf(ConfDir, [Agent21]),
897
 
    ?line {error, Reason21} = config_start(Opts),
898
 
    p("start failed (as expected): ~p", [Reason21]),
899
 
    ?line {failed_reading, _, _, _, {parse_error, _}} = Reason21,
900
 
    await_config_not_running(),
 
923
    case config_start(Opts) of
 
924
        {error, Reason21} ->
 
925
            p("start failed (as expected): ~p", [Reason21]),
 
926
            ?line {failed_reading, _, _, _, {parse_error, _}} = Reason21,
 
927
            await_config_not_running();
 
928
        OK_21 ->
 
929
            exit({error, {unexpected_success, "21", OK_21}})
 
930
    end,
901
931
 
902
932
    %% --
903
 
    p("write agents config file with invalid target name (2)"),
 
933
    p("[test 22] write agents config file with invalid target name (2)"),
904
934
    Agent22 = setelement(2, Agent0, "targ_hobbes"),
905
935
    write_agents_conf(ConfDir, [Agent22]),
906
 
    ?line {error, Reason22} = config_start(Opts),
907
 
    p("start failed (as expected): ~p", [Reason22]),
908
 
    ?line {failed_check, _, _, _, {invalid_string, _}} = Reason22,
909
 
    await_config_not_running(),
 
936
    case config_start(Opts) of
 
937
        {error, Reason22} ->
 
938
            p("start failed (as expected): ~p", [Reason22]),
 
939
            ?line {failed_check, _, _, _, {invalid_string, _}} = Reason22,
 
940
            await_config_not_running();
 
941
        OK_22 ->
 
942
            exit({error, {unexpected_success, "22", OK_22}})
 
943
    end,
910
944
 
911
945
    %% --
912
 
    p("write agents config file with invalid target name (3)"),
 
946
    p("[test 23] write agents config file with invalid target name (3)"),
913
947
    Agent23 = setelement(2, Agent0, "10101"),
914
948
    write_agents_conf(ConfDir, [Agent23]),
915
 
    ?line {error, Reason23} = config_start(Opts),
916
 
    p("start failed (as expected): ~p", [Reason23]),
917
 
    ?line {failed_check, _, _, _, {invalid_string, _}} = Reason23,
918
 
    await_config_not_running(),
 
949
    case config_start(Opts) of
 
950
        {error, Reason23} ->
 
951
            p("start failed (as expected): ~p", [Reason23]),
 
952
            ?line {failed_check, _, _, _, {invalid_string, _}} = Reason23,
 
953
            await_config_not_running();
 
954
        OK_23 ->
 
955
            exit({error, {unexpected_success, "23", OK_23}})
 
956
    end,
919
957
 
920
958
    %% --
921
 
    p("write agents config file with invalid community (1)"),
 
959
    p("[test 31] write agents config file with invalid community (1)"),
922
960
    Agent31 = setelement(3, Agent0, "targ-hobbes"),
923
961
    write_agents_conf(ConfDir, [Agent31]),
924
 
    ?line {error, Reason31} = config_start(Opts),
925
 
    p("start failed (as expected): ~p", [Reason31]),
926
 
    ?line {failed_reading, _, _, _, {parse_error, _}} = Reason31,
927
 
    await_config_not_running(),
 
962
    case config_start(Opts) of
 
963
        {error, Reason31} ->
 
964
            p("start failed (as expected): ~p", [Reason31]),
 
965
            ?line {failed_reading, _, _, _, {parse_error, _}} = Reason31,
 
966
            await_config_not_running();
 
967
        OK_31 ->
 
968
            exit({error, {unexpected_success, "31", OK_31}})
 
969
    end,
928
970
 
929
971
    %% --
930
 
    p("write agents config file with invalid community (2)"),
 
972
    p("[test 32] write agents config file with invalid community (2)"),
931
973
    Agent32 = setelement(3, Agent0, "targ_hobbes"),
932
974
    write_agents_conf(ConfDir, [Agent32]),
933
 
    ?line {error, Reason32} = config_start(Opts),
934
 
    p("start failed (as expected): ~p", [Reason32]),
935
 
    ?line {failed_check, _, _, _, {invalid_string, _}} = Reason32,
936
 
    await_config_not_running(),
 
975
    case config_start(Opts) of
 
976
        {error, Reason32} ->
 
977
            p("start failed (as expected): ~p", [Reason32]),
 
978
            ?line {failed_check, _, _, _, {invalid_string, _}} = Reason32,
 
979
            await_config_not_running();
 
980
        OK_32 ->
 
981
            exit({error, {unexpected_success, "32", OK_32}})
 
982
    end,
937
983
 
938
984
    %% --
939
 
    p("write agents config file with invalid community (3)"),
 
985
    p("[test 33] write agents config file with invalid community (3)"),
940
986
    Agent33 = setelement(3, Agent0, "10101"),
941
987
    write_agents_conf(ConfDir, [Agent33]),
942
 
    ?line {error, Reason43} = config_start(Opts),
943
 
    p("start failed (as expected): ~p", [Reason43]),
944
 
    ?line {failed_check, _, _, _, {invalid_string, _}} = Reason43,
945
 
    await_config_not_running(),
 
988
    case config_start(Opts) of
 
989
        {error, Reason33} ->
 
990
            p("start failed (as expected): ~p", [Reason33]),
 
991
            ?line {failed_check, _, _, _, {invalid_string, _}} = Reason33,
 
992
            await_config_not_running();
 
993
        OK_33 ->
 
994
            exit({error, {unexpected_success, "33", OK_33}})
 
995
    end,
946
996
 
947
997
    %% --
948
 
    p("write agents config file with invalid ip (1)"),
 
998
    p("[test 51] write agents config file with invalid ip (1)"),
949
999
    Agent51 = setelement(4, Agent0, "kalle_anka"),
950
1000
    write_agents_conf(ConfDir, [Agent51]),
951
 
    ?line {error, Reason51} = config_start(Opts),
952
 
    p("start failed (as expected): ~p", [Reason51]),
953
 
    ?line {failed_check, _, _, _, {bad_address, _}} = Reason51,
954
 
    await_config_not_running(),
 
1001
    case config_start(Opts) of
 
1002
        {error, Reason51} ->
 
1003
            p("start failed (as expected): ~p", [Reason51]),
 
1004
            ?line {failed_check, _, _, _, {bad_address, _}} = Reason51,
 
1005
            await_config_not_running();
 
1006
        OK_51 ->
 
1007
            exit({error, {unexpected_success, "51", OK_51}})
 
1008
    end,
955
1009
 
956
1010
    %% --
957
 
    p("write agents config file with invalid ip (2)"),
 
1011
    p("[test 52] write agents config file with invalid ip (2)"),
958
1012
    Agent52 = setelement(4, Agent0, "10101"),
959
1013
    write_agents_conf(ConfDir, [Agent52]),
960
 
    ?line {error, Reason52} = config_start(Opts),
961
 
    p("start failed (as expected): ~p", [Reason52]),
962
 
    ?line {failed_check, _, _, _, {bad_address, _}} = Reason52,
963
 
    await_config_not_running(),
 
1014
    case config_start(Opts) of
 
1015
        {error, Reason52} ->
 
1016
            p("start failed (as expected): ~p", [Reason52]),
 
1017
            ?line {failed_check, _, _, _, {bad_address, _}} = Reason52,
 
1018
            await_config_not_running();
 
1019
        OK_52 ->
 
1020
            exit({error, {unexpected_success, "52", OK_52}})
 
1021
    end,
964
1022
 
965
1023
    %% --
966
 
    p("write agents config file with invalid ip (3)"),
 
1024
    p("[test 53] write agents config file with invalid ip (3)"),
967
1025
    Agent53 = setelement(4, Agent0, "[192,168,0]"),
968
1026
    write_agents_conf(ConfDir, [Agent53]),
969
 
    ?line {error, Reason53} = config_start(Opts),
970
 
    p("start failed (as expected): ~p", [Reason53]),
971
 
    ?line {failed_check, _, _, _, {invalid_ip_address, _}} = Reason53,
972
 
    await_config_not_running(),
 
1027
    case config_start(Opts) of
 
1028
        {error, Reason53} ->
 
1029
            p("start failed (as expected): ~p", [Reason53]),
 
1030
            ?line {failed_check, _, _, _, {invalid_ip_address, _}} = Reason53,
 
1031
            await_config_not_running();
 
1032
        OK_53 ->
 
1033
            exit({error, {unexpected_success, "53", OK_53}})
 
1034
    end,
973
1035
 
974
1036
    %% --
975
 
    p("write agents config file with invalid ip (4)"),
 
1037
    p("[test 54] write agents config file with invalid ip (4)"),
976
1038
    Agent54 = setelement(4, Agent0, "[192,168,0,100,99]"),
977
1039
    write_agents_conf(ConfDir, [Agent54]),
978
 
    ?line {error, Reason54} = config_start(Opts),
979
 
    p("start failed (as expected): ~p", [Reason54]),
980
 
    ?line {failed_check, _, _, _, {invalid_ip_address, _}} = Reason54,
981
 
    await_config_not_running(),
 
1040
    case config_start(Opts) of
 
1041
        {error, Reason54} ->
 
1042
            p("start failed (as expected): ~p", [Reason54]),
 
1043
            ?line {failed_check, _, _, _, {invalid_ip_address, _}} = Reason54,
 
1044
            await_config_not_running();
 
1045
        OK_54 ->
 
1046
            exit({error, {unexpected_success, "54", OK_54}})
 
1047
    end,
982
1048
 
983
1049
    %% --
984
 
    p("write agents config file with invalid ip (5)"),
 
1050
    p("[test 55] write agents config file with invalid ip (5)"),
985
1051
    Agent55 = setelement(4, Agent0, "[192,168,0,arne]"),
986
1052
    write_agents_conf(ConfDir, [Agent55]),
987
1053
    ?line {error, Reason55} = config_start(Opts),
990
1056
    await_config_not_running(),
991
1057
 
992
1058
    %% --
993
 
    p("write agents config file with invalid port (1)"),
 
1059
    p("[test 61] write agents config file with invalid port (1)"),
994
1060
    Agent61 = setelement(5, Agent0, "kalle_anka"),
995
1061
    write_agents_conf(ConfDir, [Agent61]),
996
1062
    ?line {error, Reason61} = config_start(Opts),
999
1065
    await_config_not_running(),
1000
1066
 
1001
1067
    %% --
1002
 
    p("write agents config file with invalid port (2)"),
 
1068
    p("[test 62] write agents config file with invalid port (2)"),
1003
1069
    Agent62 = setelement(5, Agent0, "-1"),
1004
1070
    write_agents_conf(ConfDir, [Agent62]),
1005
1071
    ?line {error, Reason62} = config_start(Opts),
1008
1074
    await_config_not_running(),
1009
1075
 
1010
1076
    %% --
1011
 
    p("write agents config file with invalid port (3)"),
 
1077
    p("[test 63] write agents config file with invalid port (3)"),
1012
1078
    Agent63 = setelement(5, Agent0, "\"100\""),
1013
1079
    write_agents_conf(ConfDir, [Agent63]),
1014
1080
    ?line {error, Reason63} = config_start(Opts),
1017
1083
    await_config_not_running(),
1018
1084
 
1019
1085
    %% --
1020
 
    p("write agents config file with invalid engine-id (1)"),
 
1086
    p("[test 71] write agents config file with invalid engine-id (1)"),
1021
1087
    Agent71 = setelement(6, Agent0, "kalle_anka"),
1022
1088
    write_agents_conf(ConfDir, [Agent71]),
1023
1089
    ?line {error, Reason71} = config_start(Opts),
1026
1092
    await_config_not_running(),
1027
1093
 
1028
1094
    %% --
1029
 
    p("write agents config file with invalid engine-id (2)"),
 
1095
    p("[test 72] write agents config file with invalid engine-id (2)"),
1030
1096
    Agent72 = setelement(6, Agent0, "10101"),
1031
1097
    write_agents_conf(ConfDir, [Agent72]),
1032
1098
    ?line {error, Reason72} = config_start(Opts),
1035
1101
    await_config_not_running(),
1036
1102
 
1037
1103
    %% --
1038
 
    p("write agents config file with invalid timeout (1)"),
 
1104
    p("[test 81] write agents config file with invalid timeout (1)"),
1039
1105
    Agent81 = setelement(7, Agent0, "kalle_anka"),
1040
1106
    write_agents_conf(ConfDir, [Agent81]),
1041
1107
    ?line {error, Reason81} = config_start(Opts),
1044
1110
    await_config_not_running(),
1045
1111
 
1046
1112
    %% --
1047
 
    p("write agents config file with invalid timeout (2)"),
 
1113
    p("[test 82] write agents config file with invalid timeout (2)"),
1048
1114
    Agent82 = setelement(7, Agent0, "-1"),
1049
1115
    write_agents_conf(ConfDir, [Agent82]),
1050
1116
    ?line {error, Reason82} = config_start(Opts),
1053
1119
    await_config_not_running(),
1054
1120
 
1055
1121
    %% --
1056
 
    p("write agents config file with invalid timeout (3)"),
 
1122
    p("[test 83] write agents config file with invalid timeout (3)"),
1057
1123
    Agent83 = setelement(7, Agent0, "{1000, 1, 10, kalle}"),
1058
1124
    write_agents_conf(ConfDir, [Agent83]),
1059
1125
    ?line {error, Reason83} = config_start(Opts),
1062
1128
    await_config_not_running(),
1063
1129
 
1064
1130
    %% --
1065
 
    p("write agents config file with invalid timeout (4)"),
 
1131
    p("[test 84] write agents config file with invalid timeout (4)"),
1066
1132
    Agent84 = setelement(7, Agent0, "{1000, -1, 10, 10}"),
1067
1133
    write_agents_conf(ConfDir, [Agent84]),
1068
1134
    ?line {error, Reason84} = config_start(Opts),
1071
1137
    await_config_not_running(),
1072
1138
 
1073
1139
    %% --
1074
 
    p("write agents config file with invalid timeout (5)"),
 
1140
    p("[test 85] write agents config file with invalid timeout (5)"),
1075
1141
    Agent85 = setelement(7, Agent0, "{1000, 1, -100, 10}"),
1076
1142
    write_agents_conf(ConfDir, [Agent85]),
1077
1143
    ?line {error, Reason85} = config_start(Opts),
1080
1146
    await_config_not_running(),
1081
1147
 
1082
1148
    %% --
1083
 
    p("write agents config file with invalid timeout (6)"),
 
1149
    p("[test 86] write agents config file with invalid timeout (6)"),
1084
1150
    Agent86 = setelement(7, Agent0, "{1000, 1, 100, -1}"),
1085
1151
    write_agents_conf(ConfDir, [Agent86]),
1086
1152
    ?line {error, Reason86} = config_start(Opts),
1089
1155
    await_config_not_running(),
1090
1156
 
1091
1157
    %% --
1092
 
    p("write agents config file with invalid max-message-size (1)"),
 
1158
    p("[test 91] write agents config file with invalid max-message-size (1)"),
1093
1159
    Agent91 = setelement(8, Agent0, "483"),
1094
1160
    write_agents_conf(ConfDir, [Agent91]),
1095
1161
    ?line {error, Reason91} = config_start(Opts),
1098
1164
    await_config_not_running(),
1099
1165
 
1100
1166
    %% --
1101
 
    p("write agents config file with invalid max-message-size (2)"),
 
1167
    p("[test 92] write agents config file with invalid max-message-size (2)"),
1102
1168
    Agent92 = setelement(8, Agent0, "kalle_anka"),
1103
1169
    write_agents_conf(ConfDir, [Agent92]),
1104
1170
    ?line {error, Reason92} = config_start(Opts),
1107
1173
    await_config_not_running(),
1108
1174
 
1109
1175
    %% --
1110
 
    p("write agents config file with invalid version (1)"),
 
1176
    p("[test A1] write agents config file with invalid version (1)"),
1111
1177
    AgentA1 = setelement(9, Agent0, "1"),
1112
1178
    write_agents_conf(ConfDir, [AgentA1]),
1113
1179
    ?line {error, ReasonA1} = config_start(Opts),
1116
1182
    await_config_not_running(),
1117
1183
 
1118
1184
    %% --
1119
 
    p("write agents config file with invalid version (2)"),
 
1185
    p("[test A2] write agents config file with invalid version (2)"),
1120
1186
    AgentA2 = setelement(9, Agent0, "v30"),
1121
1187
    write_agents_conf(ConfDir, [AgentA2]),
1122
1188
    ?line {error, ReasonA2} = config_start(Opts),
1125
1191
    await_config_not_running(),
1126
1192
 
1127
1193
    %% --
1128
 
    p("write agents config file with invalid sec-model (1)"),
 
1194
    p("[test B1] write agents config file with invalid sec-model (1)"),
1129
1195
    AgentB1 = setelement(10, Agent0, "\"any\""),
1130
1196
    write_agents_conf(ConfDir, [AgentB1]),
1131
1197
    ?line {error, ReasonB1} = config_start(Opts),
1134
1200
    await_config_not_running(),
1135
1201
 
1136
1202
    %% --
1137
 
    p("write agents config file with invalid sec-model (2)"),
 
1203
    p("[test B2] write agents config file with invalid sec-model (2)"),
1138
1204
    AgentB2 = setelement(10, Agent0, "v3"),
1139
1205
    write_agents_conf(ConfDir, [AgentB2]),
1140
1206
    ?line {error, ReasonB2} = config_start(Opts),
1143
1209
    await_config_not_running(),
1144
1210
 
1145
1211
    %% --
1146
 
    p("write agents config file with invalid sec-name (1)"),
 
1212
    p("[test C1] write agents config file with invalid sec-name (1)"),
1147
1213
    AgentC1 = setelement(11, Agent0, "initial"),
1148
1214
    write_agents_conf(ConfDir, [AgentC1]),
1149
 
    ?line {error, ReasonC1} = config_start(Opts),
1150
 
    p("start failed (as expected): ~p", [ReasonC1]),
1151
 
    ?line {failed_check, _, _, _, {bad_sec_name, _}} = ReasonC1,
1152
 
    await_config_not_running(),
 
1215
    case config_start(Opts) of
 
1216
        {error, ReasonC1} ->
 
1217
            p("start failed (as expected): ~p", [ReasonC1]),
 
1218
            ?line {failed_check, _, _, _, {bad_sec_name, _}} = ReasonC1,
 
1219
            await_config_not_running();
 
1220
        OK_C1 ->
 
1221
            exit({error, {unexpected_success, "C1", OK_C1}})
 
1222
    end,
1153
1223
 
1154
1224
    %% --
1155
 
    p("write agents config file with invalid sec-name (2)"),
 
1225
    p("[test C2] write agents config file with invalid sec-name (2)"),
1156
1226
    AgentC2 = setelement(11, Agent0, "10101"),
1157
1227
    write_agents_conf(ConfDir, [AgentC2]),
1158
 
    ?line {error, ReasonC2} = config_start(Opts),
1159
 
    p("start failed (as expected): ~p", [ReasonC2]),
1160
 
    ?line {failed_check, _, _, _, {bad_sec_name, _}} = ReasonC2,
1161
 
    await_config_not_running(),
 
1228
    case config_start(Opts) of
 
1229
        {error, ReasonC2} ->
 
1230
            p("start failed (as expected): ~p", [ReasonC2]),
 
1231
            ?line {failed_check, _, _, _, {bad_sec_name, _}} = ReasonC2,
 
1232
            await_config_not_running();
 
1233
        OK_C2 ->
 
1234
            exit({error, {unexpected_success, "C2", OK_C2}})
 
1235
    end,
1162
1236
 
1163
1237
    %% --
1164
 
    p("write agents config file with invalid sec-level (1)"),
 
1238
    p("[test D1] write agents config file with invalid sec-level (1)"),
1165
1239
    AgentD1 = setelement(12, Agent0, "\"noAuthNoPriv\""),
1166
1240
    write_agents_conf(ConfDir, [AgentD1]),
1167
 
    ?line {error, ReasonD1} = config_start(Opts),
1168
 
    p("start failed (as expected): ~p", [ReasonD1]),
1169
 
    ?line {failed_check, _, _, _, {invalid_sec_level, _}} = ReasonD1,
1170
 
    await_config_not_running(),
 
1241
    case config_start(Opts) of
 
1242
        {error, ReasonD1} ->
 
1243
            p("start failed (as expected): ~p", [ReasonD1]),
 
1244
            ?line {failed_check, _, _, _, {invalid_sec_level, _}} = ReasonD1,
 
1245
            await_config_not_running();
 
1246
        OK_D1 ->
 
1247
            exit({error, {unexpected_success, "D1", OK_D1}})
 
1248
    end,
1171
1249
 
1172
1250
    %% --
1173
 
    p("write agents config file with invalid sec-level (2)"),
 
1251
    p("[test D2] write agents config file with invalid sec-level (2)"),
1174
1252
    AgentD2 = setelement(12, Agent0, "99"),
1175
1253
    write_agents_conf(ConfDir, [AgentD2]),
1176
 
    ?line {error, ReasonD2} = config_start(Opts),
1177
 
    p("start failed (as expected): ~p", [ReasonD2]),
1178
 
    ?line {failed_check, _, _, _, {invalid_sec_level, _}} = ReasonD2,
1179
 
    await_config_not_running(),
 
1254
    case config_start(Opts) of
 
1255
        {error, ReasonD2} ->
 
1256
            p("start failed (as expected): ~p", [ReasonD2]),
 
1257
            ?line {failed_check, _, _, _, {invalid_sec_level, _}} = ReasonD2,
 
1258
            await_config_not_running();
 
1259
        OK_D2 ->
 
1260
            exit({error, {unexpected_success, "D2", OK_D2}})
 
1261
    end,
1180
1262
 
1181
1263
    %% --
1182
 
    p("write agents config file with invalid agent (1)"),
 
1264
    p("[test E1] write agents config file with invalid agent (1)"),
1183
1265
    write_agents_conf2(ConfDir, "{swiacf, \"targ-hobbes\"}."),
1184
 
    ?line {error, ReasonE1} = config_start(Opts),
1185
 
    p("start failed (as expected): ~p", [ReasonE1]),
1186
 
    ?line {failed_check, _, _, _, {bad_agent_config, _}} = ReasonE1,
1187
 
    await_config_not_running(),
 
1266
    case config_start(Opts) of
 
1267
        {error, ReasonE1} ->
 
1268
            p("start failed (as expected): ~p", [ReasonE1]),
 
1269
            ?line {failed_check, _, _, _, {bad_agent_config, _}} = ReasonE1,
 
1270
            await_config_not_running();
 
1271
        OK_E1 ->
 
1272
            exit({error, {unexpected_success, "E1", OK_E1}})
 
1273
    end,
1188
1274
 
1189
1275
    p("done"),
1190
1276
    ok.
1233
1319
            "usmNoPrivProtocol", "[]"},
1234
1320
 
1235
1321
    %% --
1236
 
    p("write usm config file with invalid engine-id (1)"),
 
1322
    p("[test 11] write usm config file with invalid engine-id (1)"),
1237
1323
    Usm11 = setelement(1, Usm0, "kalle-anka"),
1238
1324
    write_usm_conf(ConfDir, [Usm11]),
1239
1325
    ?line {error, Reason11} = config_start(Opts),
1242
1328
    await_config_not_running(),
1243
1329
 
1244
1330
    %% --
1245
 
    p("write usm config file with invalid engine-id (2)"),
 
1331
    p("[test 12] write usm config file with invalid engine-id (2)"),
1246
1332
    Usm12 = setelement(1, Usm0, "kalle_anka"),
1247
1333
    write_usm_conf(ConfDir, [Usm12]),
1248
1334
    ?line {error, Reason12} = config_start(Opts),
1251
1337
    await_config_not_running(),
1252
1338
 
1253
1339
    %% --
1254
 
    p("write usm config file with invalid engine-id (3)"),
 
1340
    p("[test 13] write usm config file with invalid engine-id (3)"),
1255
1341
    Usm13 = setelement(1, Usm1, "10101"),
1256
1342
    write_usm_conf(ConfDir, [Usm13]),
1257
1343
    ?line {error, Reason13} = config_start(Opts),
1260
1346
    await_config_not_running(),
1261
1347
 
1262
1348
    %% --
1263
 
    p("write usm config file with invalid user-name (1)"),
 
1349
    p("[test 21] write usm config file with invalid user-name (1)"),
1264
1350
    Usm21 = setelement(2, Usm0, "kalle_anka"),
1265
1351
    write_usm_conf(ConfDir, [Usm21]),
1266
1352
    ?line {error, Reason21} = config_start(Opts),
1269
1355
    await_config_not_running(),
1270
1356
 
1271
1357
    %% --
1272
 
    p("write usm config file with invalid user-name (1)"),
 
1358
    p("[test 22] write usm config file with invalid user-name (1)"),
1273
1359
    Usm22 = setelement(2, Usm1, "10101"),
1274
1360
    write_usm_conf(ConfDir, [Usm22]),
1275
1361
    ?line {error, Reason22} = config_start(Opts),
1278
1364
    await_config_not_running(),
1279
1365
 
1280
1366
    %% --
1281
 
    p("write usm config file with invalid sec-name (1)"),
 
1367
    p("[test 31] write usm config file with invalid sec-name (1)"),
1282
1368
    Usm31 = setelement(3, Usm1, "kalle_anka"),
1283
1369
    write_usm_conf(ConfDir, [Usm31]),
1284
1370
    ?line {error, Reason31} = config_start(Opts),
1287
1373
    await_config_not_running(),
1288
1374
 
1289
1375
    %% --
1290
 
    p("write usm config file with invalid sec-name (2)"),
 
1376
    p("[test 32] write usm config file with invalid sec-name (2)"),
1291
1377
    Usm32 = setelement(3, Usm1, "10101"),
1292
1378
    write_usm_conf(ConfDir, [Usm32]),
1293
1379
    ?line {error, Reason32} = config_start(Opts),
1296
1382
    await_config_not_running(),
1297
1383
 
1298
1384
    %% --
1299
 
    p("write usm config file with invalid auth-protocol (1)"),
 
1385
    p("[test 41] write usm config file with invalid auth-protocol (1)"),
1300
1386
    Usm41 = setelement(3, Usm0, "\"usmNoAuthProtocol\""),
1301
1387
    write_usm_conf(ConfDir, [Usm41]),
1302
1388
    ?line {error, Reason41} = config_start(Opts),
1305
1391
    await_config_not_running(),
1306
1392
 
1307
1393
    %% --
1308
 
    p("write usm config file with invalid auth-protocol (2)"),
 
1394
    p("[test 42] write usm config file with invalid auth-protocol (2)"),
1309
1395
    Usm42 = setelement(3, Usm0, "kalle"),
1310
1396
    write_usm_conf(ConfDir, [Usm42]),
1311
1397
    ?line {error, Reason42} = config_start(Opts),
1314
1400
    await_config_not_running(),
1315
1401
 
1316
1402
    %% --
1317
 
    p("write usm config file with invalid auth-protocol (3)"),
 
1403
    p("[test 43] write usm config file with invalid auth-protocol (3)"),
1318
1404
    Usm43 = setelement(3, Usm0, "10101"),
1319
1405
    write_usm_conf(ConfDir, [Usm43]),
1320
1406
    ?line {error, Reason43} = config_start(Opts),
1323
1409
    await_config_not_running(),
1324
1410
 
1325
1411
    %% --
1326
 
    p("write usm config file with invalid auth-key (1)"),
 
1412
    p("[test 51] write usm config file with invalid auth-key (1)"),
1327
1413
    Usm51 = setelement(3, Usm0, "usmHMACMD5AuthProtocol"),
1328
1414
    write_usm_conf(ConfDir, [Usm51]),
1329
1415
    ?line {error, Reason51} = config_start(Opts),
1332
1418
    await_config_not_running(),
1333
1419
 
1334
1420
    %% --
1335
 
    p("write usm config file with invalid auth-key (2)"),
 
1421
    p("[test 52] write usm config file with invalid auth-key (2)"),
1336
1422
    Usm52 = setelement(4, Usm51, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5]"),
1337
1423
    write_usm_conf(ConfDir, [Usm52]),
1338
1424
    ?line {error, Reason52} = config_start(Opts),
1341
1427
    await_config_not_running(),
1342
1428
 
1343
1429
    %% --
1344
 
    p("write usm config file with invalid auth-key (3)"),
 
1430
    p("[test 53] write usm config file with invalid auth-key (3)"),
1345
1431
    Usm53 = setelement(4, Usm51, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7]"),
1346
1432
    write_usm_conf(ConfDir, [Usm53]),
1347
1433
    ?line {error, Reason53} = config_start(Opts),
1350
1436
    await_config_not_running(),
1351
1437
 
1352
1438
    %% --
1353
 
    p("write usm config file with invalid auth-key (4)"),
 
1439
    p("[test 54] write usm config file with invalid auth-key (4)"),
1354
1440
    Usm54 = setelement(4, Usm51, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,kalle]"),
1355
1441
    write_usm_conf(ConfDir, [Usm54]),
1356
1442
    %% ?line ok = crypto:start(),  %% Varf�r k�r den redan?
1362
1448
    await_config_not_running(),
1363
1449
 
1364
1450
    %% --
1365
 
    p("write usm config file with invalid auth-key (5)"),
 
1451
    p("[test 55] write usm config file with invalid auth-key (5)"),
1366
1452
    Usm55 = setelement(4, Usm51, "arne_anka"),
1367
1453
    write_usm_conf(ConfDir, [Usm55]),
1368
1454
    ?line {error, Reason55} = config_start(Opts),
1371
1457
    await_config_not_running(),
1372
1458
 
1373
1459
    %% --
1374
 
    p("write usm config file with invalid auth-key (6)"),
 
1460
    p("[test 56] write usm config file with invalid auth-key (6)"),
1375
1461
    Usm56 = setelement(4, Usm51, "10101"),
1376
1462
    write_usm_conf(ConfDir, [Usm56]),
1377
1463
    ?line {error, Reason56} = config_start(Opts),
1380
1466
    await_config_not_running(),
1381
1467
 
1382
1468
    %% --
1383
 
    p("write usm config file with invalid auth-key (7)"),
 
1469
    p("[test 57] write usm config file with invalid auth-key (7)"),
1384
1470
    Usm57 = setelement(3, Usm0, "usmHMACSHAAuthProtocol"),
1385
1471
    write_usm_conf(ConfDir, [Usm57]),
1386
1472
    ?line {error, Reason57} = config_start(Opts),
1389
1475
    await_config_not_running(),
1390
1476
 
1391
1477
    %% --
1392
 
    p("write usm config file with invalid auth-key (8)"),
 
1478
    p("[test 58] write usm config file with invalid auth-key (8)"),
1393
1479
    Usm58 = setelement(4, Usm57, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6]"),
1394
1480
    write_usm_conf(ConfDir, [Usm58]),
1395
1481
    ?line {error, Reason58} = config_start(Opts),
1398
1484
    await_config_not_running(),
1399
1485
 
1400
1486
    %% --
1401
 
    p("write usm config file with invalid auth-key (9)"),
 
1487
    p("[test 59] write usm config file with invalid auth-key (9)"),
1402
1488
    Usm59 = setelement(4, Usm57, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,ka]"),
1403
1489
    write_usm_conf(ConfDir, [Usm59]),
1404
1490
    ?line ok = crypto:start(),
1409
1495
    await_config_not_running(),
1410
1496
 
1411
1497
    %% --
1412
 
    p("write usm config file with valid auth-key when crypto not started (10)"),
 
1498
    p("[test 5A] write usm config file with valid auth-key when crypto not started (10)"),
1413
1499
    Usm5A = setelement(4, Usm57, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0]"),
1414
1500
    write_usm_conf(ConfDir, [Usm5A]),
1415
1501
    ?line {error, Reason5A} = config_start(Opts),
1418
1504
    await_config_not_running(),
1419
1505
 
1420
1506
    %% --
1421
 
    p("write usm config file with invalid priv-protocol (1)"),
 
1507
    p("[test 61] write usm config file with invalid priv-protocol (1)"),
1422
1508
    Usm61 = setelement(5, Usm0, "\"usmNoPrivProtocol\""),
1423
1509
    write_usm_conf(ConfDir, [Usm61]),
1424
1510
    ?line {error, Reason61} = config_start(Opts),
1427
1513
    await_config_not_running(),
1428
1514
 
1429
1515
    %% --
1430
 
    p("write usm config file with invalid priv-protocol (2)"),
 
1516
    p("[test 62] write usm config file with invalid priv-protocol (2)"),
1431
1517
    Usm62 = setelement(5, Usm0, "kalle"),
1432
1518
    write_usm_conf(ConfDir, [Usm62]),
1433
1519
    ?line {error, Reason62} = config_start(Opts),
1436
1522
    await_config_not_running(),
1437
1523
 
1438
1524
    %% --
1439
 
    p("write usm config file with invalid priv-protocol (3)"),
 
1525
    p("[test 63] write usm config file with invalid priv-protocol (3)"),
1440
1526
    Usm63 = setelement(5, Usm0, "10101"),
1441
1527
    write_usm_conf(ConfDir, [Usm63]),
1442
1528
    ?line {error, Reason63} = config_start(Opts),
1445
1531
    await_config_not_running(),
1446
1532
 
1447
1533
    %% --
1448
 
    p("write usm config file with invalid priv-key (1)"),
 
1534
    p("[test 71] write usm config file with invalid priv-key (1)"),
1449
1535
    Usm71 = setelement(5, Usm0, "usmDESPrivProtocol"),
1450
1536
    write_usm_conf(ConfDir, [Usm71]),
1451
1537
    ?line {error, Reason71} = config_start(Opts),
1454
1540
    await_config_not_running(),
1455
1541
 
1456
1542
    %% --
1457
 
    p("write usm config file with invalid priv-key (2)"),
 
1543
    p("[test 72] write usm config file with invalid priv-key (2)"),
1458
1544
    Usm72 = setelement(6, Usm71, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5]"),
1459
1545
    write_usm_conf(ConfDir, [Usm72]),
1460
1546
    ?line {error, Reason72} = config_start(Opts),
1463
1549
    await_config_not_running(),
1464
1550
 
1465
1551
    %% --
1466
 
    p("write usm config file with invalid priv-key (3)"),
 
1552
    p("[test 73] write usm config file with invalid priv-key (3)"),
1467
1553
    Usm73 = setelement(6, Usm71, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7]"),
1468
1554
    write_usm_conf(ConfDir, [Usm73]),
1469
1555
    ?line {error, Reason73} = config_start(Opts),
1472
1558
    await_config_not_running(),
1473
1559
 
1474
1560
    %% --
1475
 
    p("write usm config file with invalid priv-key (4)"),
 
1561
    p("[test 74] write usm config file with invalid priv-key (4)"),
1476
1562
    Usm74 = setelement(6, Usm71, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,kalle]"),
1477
1563
    write_usm_conf(ConfDir, [Usm74]),
1478
1564
    ?line ok = crypto:start(),
1483
1569
    await_config_not_running(),
1484
1570
 
1485
1571
    %% --
1486
 
    p("write usm config file with invalid priv-key (5)"),
 
1572
    p("[test 75] write usm config file with invalid priv-key (5)"),
1487
1573
    Usm75 = setelement(6, Usm71, "arne_anka"),
1488
1574
    write_usm_conf(ConfDir, [Usm75]),
1489
1575
    ?line {error, Reason75} = config_start(Opts),
1492
1578
    await_config_not_running(),
1493
1579
 
1494
1580
    %% --
1495
 
    p("write usm config file with invalid priv-key (6)"),
 
1581
    p("[test 76] write usm config file with invalid priv-key (6)"),
1496
1582
    Usm76 = setelement(6, Usm71, "10101"),
1497
1583
    write_usm_conf(ConfDir, [Usm76]),
1498
1584
    ?line {error, Reason76} = config_start(Opts),
1501
1587
    await_config_not_running(),
1502
1588
 
1503
1589
    %% --
1504
 
    p("write usm config file with valid priv-key when crypto not started (7)"),
 
1590
    p("[test 77] write usm config file with valid priv-key when crypto not started (7)"),
1505
1591
    Usm77 = setelement(6, Usm71, "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6]"),
1506
1592
    write_usm_conf(ConfDir, [Usm77]),
1507
1593
    ?line {error, Reason77} = config_start(Opts),
1510
1596
    await_config_not_running(),
1511
1597
 
1512
1598
     %% --
1513
 
    p("write usm config file with invalid usm (1)"),
 
1599
    p("[test 78] write usm config file with invalid usm (1)"),
1514
1600
    write_usm_conf2(ConfDir, "{\"bmkEngine\", \"swiusmcf\"}."),
1515
1601
    ?line {error, Reason81} = config_start(Opts),
1516
1602
    p("start failed (as expected): ~p", [Reason81]),
1687
1773
    UserId2 = raufi2,
1688
1774
    UserId2Str = str(UserId2),
1689
1775
    User1 = {UserId1Str, "snmpm_user_default", "dummy1"},
1690
 
    User2 = {UserId2Str, "snmpm_user_default", "dummy2"},
 
1776
    User2 = {UserId2Str, "snmpm_user_default", "dummy2", "[{version, v1}]"},
1691
1777
    write_users_conf(ConfDir, [User1, User2]),
1692
1778
 
1693
1779
    %% --
1708
1794
    EngineID2Str = str(EngineID2),
1709
1795
    MMS2 = 512,
1710
1796
    MMS2Str = str(MMS2),
1711
 
    Agent1Str = {UserId1Str, "\"targ-hobbes\"", "\"comm\"", 
 
1797
    Agent1Str = {UserId1Str, "\"targ-hobbes1\"", "\"comm\"", 
1712
1798
                 AgentAddr1Str, AgentPort1Str, EngineID1Str, 
1713
1799
                 "1000", MMS1Str, "v1",
1714
1800
                 "any", "\"initial\"", "noAuthNoPriv"},
1715
 
    Agent2Str = {UserId2Str, "\"targ-hobbes\"", "\"comm\"", 
 
1801
    Agent2Str = {UserId2Str, "\"targ-hobbes2\"", "\"comm\"", 
1716
1802
                 AgentAddr2Str, AgentPort2Str, EngineID2Str, 
1717
1803
                 "1500", MMS2Str, "v1",
1718
1804
                 "any", "\"initial\"", "noAuthNoPriv"},
2346
2432
 
2347
2433
 
2348
2434
write_users_conf(Dir, Users) ->
2349
 
    F = fun({UserId, UserMod, UserData}) -> 
2350
 
                lists:flatten(
2351
 
                  io_lib:format("{~s, ~s, ~s}.~n", 
2352
 
                                [UserId, UserMod, UserData]))
 
2435
    F = fun({UserId, UserMod, UserData}) -> %% Old format
 
2436
                lists:flatten(
 
2437
                  io_lib:format("{~s, ~s, ~s, ~s}.~n", 
 
2438
                                [UserId, UserMod, UserData, "[]"]));
 
2439
           ({UserId, UserMod, UserData, DefaultAgentConfig}) -> %% New format
 
2440
                lists:flatten(
 
2441
                  io_lib:format("{~s, ~s, ~s, ~s}.~n", 
 
2442
                                [UserId, UserMod, UserData, DefaultAgentConfig]))
2353
2443
        end,
2354
2444
    Str = lists:flatten([F(User) || User <- Users]),
2355
2445
    write_conf_file(Dir, "users.conf", Str).
2432
2522
 
2433
2523
p(TName, F, A) ->
2434
2524
    io:format("*** [~s] ***"
2435
 
              "~w -> " ++ F ++ "~n", [format_timestamp(now()),TName|A]).
 
2525
              " ~w -> " ++ F ++ "~n", [format_timestamp(now()),TName|A]).
2436
2526
 
2437
2527
format_timestamp({_N1, _N2, N3}   = Now) ->
2438
2528
    {Date, Time}   = calendar:now_to_datetime(Now),