Merge branch 'master' of ssh://git.samba.org/data/git/samba into regsrv
[kai/samba.git] / pidl / tests / wireshark-ndr.pl
1 #!/usr/bin/perl
2 # (C) 2007 Jelmer Vernooij <jelmer@samba.org>
3 # Published under the GNU General Public License
4 # test parsing wireshark conformance files
5 use strict;
6 use warnings;
7
8 use Test::More tests => 40;
9 use FindBin qw($RealBin);
10 use lib "$RealBin";
11 use Util;
12 use Parse::Pidl::Util qw(MyDumper);
13 use strict;
14 use Parse::Pidl::Wireshark::NDR qw(field2name %res PrintIdl StripPrefixes RegisterInterfaceHandoff register_hf_field ProcessImport ProcessInclude find_type DumpEttList DumpEttDeclaration DumpHfList DumpHfDeclaration DumpFunctionTable register_type register_ett);
15
16 is("Access Mask", field2name("access_mask"));
17 is("Accessmask", field2name("AccessMask"));
18
19 my $x = new Parse::Pidl::Wireshark::NDR();
20 $x->PrintIdl("foo\nbar\n");
21 is("/* IDL: foo */
22 /* IDL: bar */
23
24 ", $x->{res}->{code});
25
26 is("bla_foo", StripPrefixes("bla_foo", []));
27 is("foo", StripPrefixes("bla_foo", ["bla"]));
28 is("foo_bla", StripPrefixes("foo_bla", ["bla"]));
29
30 $x = new Parse::Pidl::Wireshark::NDR();
31 $x->RegisterInterfaceHandoff({});
32 is($x->{res}->{code}, "");
33 ok(not defined($x->{hf_used}->{hf_bla_opnum}));
34
35 $x = new Parse::Pidl::Wireshark::NDR();
36 $x->{res}->{code} = "";
37 $x->RegisterInterfaceHandoff({UUID => "uuid", NAME => "bla"});
38 is($x->{res}->{code}, 'void proto_reg_handoff_dcerpc_bla(void)
39 {
40         dcerpc_init_uuid(proto_dcerpc_bla, ett_dcerpc_bla,
41                 &uuid_dcerpc_bla, ver_dcerpc_bla,
42                 bla_dissectors, hf_bla_opnum);
43 }
44 ');
45 is($x->{hf_used}->{hf_bla_opnum}, 1);
46
47 $x->{conformance} = {};
48 is("hf_bla_idx", 
49         $x->register_hf_field("hf_bla_idx", "bla", "my.filter", "FT_UINT32", "BASE_HEX", "NULL", 0xF, undef));
50 is_deeply($x->{conformance}, {
51                 header_fields => {
52                         "hf_bla_idx" => {
53                                 INDEX => "hf_bla_idx",
54                                 NAME => "bla",
55                                 FILTER => "my.filter",
56                                 BASE_TYPE => "BASE_HEX",
57                                 FT_TYPE => "FT_UINT32",
58                                 VALSSTRING => "NULL",
59                                 BLURB => undef,
60                                 MASK => 0xF
61                         }
62                 },
63                 hf_renames => {},
64                 fielddescription => {}
65 });
66
67 $x->{conformance} = { fielddescription => { hf_bla_idx => { DESCRIPTION => "Some Description" }}};
68 is("hf_bla_idx",
69         $x->register_hf_field("hf_bla_idx", "bla", "my.filter", "FT_UINT32", "BASE_HEX", "NULL", 0xF, undef));
70 is_deeply($x->{conformance}, {
71                 fielddescription => { 
72                         hf_bla_idx => {
73                                 DESCRIPTION => "Some Description",
74                                 USED => 1
75                         }
76                 },
77                 header_fields => {
78                         "hf_bla_idx" => {
79                                 INDEX => "hf_bla_idx",
80                                 NAME => "bla",
81                                 FILTER => "my.filter",
82                                 BASE_TYPE => "BASE_HEX",
83                                 FT_TYPE => "FT_UINT32",
84                                 VALSSTRING => "NULL",
85                                 BLURB => "Some Description",
86                                 MASK => 0xF
87                         }
88                 },
89                 hf_renames => {},
90 });
91
92 $x->{conformance} = { fielddescription => { hf_bla_idx => { DESCRIPTION => "Some Description" }}};
93 is("hf_bla_idx",
94         $x->register_hf_field("hf_bla_idx", "bla", "my.filter", "FT_UINT32", "BASE_HEX", "NULL", 0xF, 
95                 "Actual Description"));
96 is_deeply($x->{conformance}, {
97                 fielddescription => { 
98                         hf_bla_idx => { DESCRIPTION => "Some Description" }
99                 },
100                 header_fields => {
101                         "hf_bla_idx" => {
102                                 INDEX => "hf_bla_idx",
103                                 NAME => "bla",
104                                 FILTER => "my.filter",
105                                 BASE_TYPE => "BASE_HEX",
106                                 FT_TYPE => "FT_UINT32",
107                                 VALSSTRING => "NULL",
108                                 BLURB => "Actual Description",
109                                 MASK => 0xF
110                         }
111                 },
112                 hf_renames => {},
113 });
114
115
116
117 $x->{conformance} = { hf_renames => { "hf_bla_idx" => { NEWNAME => "hf_bloe_idx" } } };
118 $x->register_hf_field("hf_bla_idx", "bla", "my.filter", "FT_UINT32", "BASE_HEX", "NULL", 0xF, undef);
119 is_deeply($x->{conformance}, {
120                 hf_renames => { hf_bla_idx => { USED => 1, NEWNAME => "hf_bloe_idx" } } });
121
122 $x->{hf_used} = { hf_bla => 1 };
123 test_warnings("", sub { 
124                 $x->CheckUsed({ header_fields => { foo => { INDEX => "hf_bla" }}})});
125
126 $x->{hf_used} = { };
127 test_warnings("hf field `hf_bla' not used\n", sub { 
128                 $x->CheckUsed({ header_fields => { foo => { INDEX => "hf_bla" }}})});
129
130 test_warnings("hf field `hf_id' not used\n", 
131         sub { $x->CheckUsed({
132         hf_renames => {
133                 hf_id => {
134                         OLDNAME => "hf_id",
135                         NEWNAME => "hf_newid",
136                         USED => 0
137                 }
138         }
139 }); } );
140
141 test_warnings("dissector param never used\n",
142         sub { $x->CheckUsed({
143         dissectorparams => {
144                 dissect_foo => {
145                         PARAM => 42,
146                         USED => 0
147                 }
148         }
149 }); } );
150
151 test_warnings("description never used\n",
152         sub { $x->CheckUsed({
153         fielddescription => {
154                 hf_bla => {
155                         USED => 0
156                 }
157         }
158 }); } );
159
160 test_warnings("import never used\n",
161         sub { $x->CheckUsed({
162         imports => {
163                 bla => {
164                         USED => 0
165                 }
166         }
167 }); } );
168
169 test_warnings("nofile:1: type never used\n",
170         sub { $x->CheckUsed({
171         types => {
172                 bla => {
173                         USED => 0,
174                         POS => { FILE => "nofile", LINE => 1 } 
175                 }
176         }
177 }); } );
178
179 test_warnings("True/False description never used\n",
180         sub { $x->CheckUsed({
181         tfs => {
182                 hf_bloe => {
183                         USED => 0
184                 }
185         }
186 }); } );
187
188 $x = new Parse::Pidl::Wireshark::NDR();
189 $x->ProcessImport("security", "bla");
190 is($x->{res}->{hdr}, "#include \"packet-dcerpc-bla.h\"\n\n");
191
192 $x = new Parse::Pidl::Wireshark::NDR();
193 $x->ProcessImport("\"bla.idl\"", "\"foo.idl\"");
194 is($x->{res}->{hdr}, "#include \"packet-dcerpc-bla.h\"\n" . 
195               "#include \"packet-dcerpc-foo.h\"\n\n");
196
197 $x = new Parse::Pidl::Wireshark::NDR();
198 $x->ProcessInclude("foo.h", "bla.h", "bar.h");
199 is($x->{res}->{hdr}, "#include \"foo.h\"\n" . 
200                   "#include \"bla.h\"\n" . 
201                           "#include \"bar.h\"\n\n");
202         
203 $x->{conformance} = {types => { bla => "brainslug" } };
204 is("brainslug", $x->find_type("bla"));
205
206 is(DumpEttList(["ett_t1", "ett_bla"]), 
207         "\tstatic gint *ett[] = {\n" . 
208         "\t\t&ett_t1,\n" .
209         "\t\t&ett_bla,\n" .
210         "\t};\n");
211
212 is(DumpEttList(), "\tstatic gint *ett[] = {\n\t};\n");
213 is(DumpEttList(["bla"]), "\tstatic gint *ett[] = {\n\t\t&bla,\n\t};\n");
214
215 is(DumpEttDeclaration(["void", "zoid"]), 
216         "\n/* Ett declarations */\n" . 
217         "static gint void = -1;\n" .
218         "static gint zoid = -1;\n" .
219         "\n");
220
221 is(DumpEttDeclaration(), "\n/* Ett declarations */\n\n");
222
223 $x->{conformance} = {
224         header_fields => {
225                 hf_bla => { INDEX => "hf_bla", NAME => "Bla", FILTER => "bla.field", FT_TYPE => "FT_UINT32", BASE_TYPE => "BASE_DEC", VALSSTRING => "NULL", MASK => 0xFF, BLURB => "NULL" } 
226         } 
227 };
228
229 is($x->DumpHfList(), "\tstatic hf_register_info hf[] = {
230         { &hf_bla, 
231           { \"Bla\", \"bla.field\", FT_UINT32, BASE_DEC, NULL, 255, \"NULL\", HFILL }},
232         };
233 ");
234
235 is($x->DumpHfDeclaration(), "
236 /* Header field declarations */
237 static gint hf_bla = -1;
238
239 ");
240
241 is(DumpFunctionTable({
242                         NAME => "someif",
243                         FUNCTIONS => [ { NAME => "fn1", OPNUM => 3 }, { NAME => "someif_fn2", OPNUM => 2 } ] }),
244 'static dcerpc_sub_dissector someif_dissectors[] = {
245         { 3, "fn1",
246            someif_dissect_fn1_request, someif_dissect_fn1_response},
247         { 2, "fn2",
248            someif_dissect_fn2_request, someif_dissect_fn2_response},
249         { 0, NULL, NULL, NULL }
250 };
251 ');
252
253 $x->{conformance} = {};
254 $x->register_type("bla_type", "dissect_bla", "FT_UINT32", "BASE_HEX", 0xFF, "NULL", 4);
255 is_deeply($x->{conformance}, {
256                 types => {
257                         bla_type => {
258                                 NAME => "bla_type",
259                                 DISSECTOR_NAME => "dissect_bla",
260                                 FT_TYPE => "FT_UINT32",
261                                 BASE_TYPE => "BASE_HEX",
262                                 MASK => 255,
263                                 VALSSTRING => "NULL",
264                                 ALIGNMENT => 4
265                         }
266                 }
267         }
268 );
269
270 $x->{ett} = [];
271 $x->register_ett("name");
272 is_deeply($x->{ett}, ["name"]);
273 $x->register_ett("leela");
274 is_deeply($x->{ett}, ["name", "leela"]);