1 krisbash 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the ZT("License")); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 krisbash 1.1 **==============================================================================
23 */
24
25 #include <iostream>
26 #include <string>
27 #include <vector>
28 #include <cstdio>
29 #include <ut/ut.h>
30 #include <common.h>
31 #include <base/paths.h>
32 #include <base/log.h>
33 #include <pal/file.h>
34
35 #include "OIParser.h"
36 #include "FileGen.h"
37 #if defined(CONFIG_OS_WINDOWS)
38 #include "EtwGen.h"
39 #include "ManifestGen.h"
40 #endif
41 #include "Syslog.h"
42
43 krisbash 1.1 #if defined(CONFIG_ENABLE_WCHAR)
44 typedef std::wstring String;
45 #else
46 typedef std::string String;
47 #endif
48
49 using namespace std;
50
51 NitsSetup(TestOiSetup)
52 NitsEndSetup
53
54 NitsCleanup(TestOiSetup)
55 NitsEndCleanup
56
57 NitsTestWithSetup(Test_SingleEvent, TestOiSetup)
58 {
59 OIParser parser;
60 OIEvent * events = 0;
61 int count = 0;
62 char path[PAL_MAX_PATH_SIZE];
63
64 krisbash 1.1 Strlcpy(path, OMI_GetPath(ID_PREFIX), sizeof(path));
65 Strlcat(path, "/tests/oi/", sizeof(path));
66 Strlcat(path, "test1.txt", sizeof(path));
67
68 memset(&parser, 0, sizeof(OIParser));
69 UT_ASSERT_EQUAL(Parser_Init(&parser, path), MI_TRUE);
70 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
71
72 UT_ASSERT_EQUAL(count, 1);
73 if (count > 0)
74 {
75 UT_ASSERT_EQUAL(Strcmp(events->Name, "FrogEvents_JumpEvent"), 0);
76 UT_ASSERT_EQUAL(Strcmp(events->Format, "\"I have jumped %d feet\""), 0);
77 UT_ASSERT_EQUAL(events->next, 0);
78
79 UT_ASSERT(events->Argument != NULL);
80 if (events->Argument)
81 {
82 UT_ASSERT_EQUAL(Strcmp(events->Argument->Name, "number"), 0);
83 UT_ASSERT_EQUAL(Strcmp(events->Argument->Type, "int"), 0);
84 UT_ASSERT_EQUAL(events->Argument->next, 0);
85 krisbash 1.1 }
86 }
87
88 Parser_Destroy(&parser);
89 }
90 NitsEndTest
91
92 NitsTestWithSetup(Test_MultipleEvents, TestOiSetup)
93 {
94 OIParser parser;
95 OIEvent * events = 0;
96 int count = 0;
97 char path[PAL_MAX_PATH_SIZE];
98
99 Strlcpy(path, OMI_GetPath(ID_PREFIX), sizeof(path));
100 Strlcat(path, "/tests/oi/", sizeof(path));
101 Strlcat(path, "test2.txt", sizeof(path));
102
103 memset(&parser, 0, sizeof(OIParser));
104 UT_ASSERT_EQUAL(Parser_Init(&parser, path), MI_TRUE);
105 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
106 krisbash 1.1
107 UT_ASSERT_EQUAL(count, 3);
108 if (count > 0)
109 {
110 UT_ASSERT_EQUAL(Strcmp(events->Name, "FrogEvents_JumpEvent"), 0);
111 UT_ASSERT_EQUAL(Strcmp(events->Format, "\"I have jumped %d feet\""), 0);
112
113 OIArgument * arg = events->Argument;
114 UT_ASSERT(arg != NULL);
115 if (arg)
116 {
117 UT_ASSERT_EQUAL(Strcmp(arg->Name, "number"), 0);
118 UT_ASSERT_EQUAL(Strcmp(arg->Type, "int"), 0);
119 UT_ASSERT_EQUAL(arg->next, 0);
120 }
121
122 UT_ASSERT(events->next != 0);
123 OIEvent * e = events->next;
124 if (e)
125 {
126 UT_ASSERT_EQUAL(Strcmp(e->Name, "FrogEvents_EatFlysEvent"), 0);
127 krisbash 1.1 UT_ASSERT_EQUAL(Strcmp(e->Format, "\"I have eaten %d flys\""), 0);
128
129 OIArgument * arg = e->Argument;
130 UT_ASSERT(arg != NULL);
131 if (arg)
132 {
133 UT_ASSERT_EQUAL(Strcmp(arg->Name, "number"), 0);
134 UT_ASSERT_EQUAL(Strcmp(arg->Type, "int"), 0);
135 UT_ASSERT_EQUAL(arg->next, 0);
136 }
137 }
138
139 UT_ASSERT(e->next != 0);
140 e = e->next;
141 if (e)
142 {
143 UT_ASSERT_EQUAL(Strcmp(e->Name, "FrogEvents_DiveEvent"), 0);
144 UT_ASSERT_EQUAL(Strcmp(e->Format, "\"I have dived %d feet for %d seconds\""), 0);
145
146 OIArgument * arg = e->Argument;
147 UT_ASSERT(arg != NULL);
148 krisbash 1.1 if (arg)
149 {
150 UT_ASSERT_EQUAL(Strcmp(arg->Name, "depth"), 0);
151 UT_ASSERT_EQUAL(Strcmp(arg->Type, "int"), 0);
152 UT_ASSERT(arg->next != 0);
153 }
154
155 arg = arg->next;
156 UT_ASSERT(arg != NULL);
157 if (arg)
158 {
159 UT_ASSERT_EQUAL(Strcmp(arg->Name, "time"), 0);
160 UT_ASSERT_EQUAL(Strcmp(arg->Type, "int"), 0);
161 UT_ASSERT_EQUAL(arg->next, 0);
162 }
163 }
164 }
165
166 Parser_Destroy(&parser);
167 }
168 NitsEndTest
169 krisbash 1.1
170 static bool Inhale(const char* path, string& strOut, bool baseline)
171 {
172 char buf[1024];
173 string str;
174
175 /* Open file */
176 FILE* is = File_Open(path, "rb");
177 if (!is)
178 return false;
179
180 /* Read file into str parameter */
181 for (;;)
182 {
183 #if defined(CONFIG_OS_WINDOWS)
184 long n = fread(buf, 1, sizeof(buf)-2, is);
185 #else
186 ssize_t n = fread(buf, 1, sizeof(buf)-1, is);
187 #endif
188 if (n <= 0)
189 break;
190 krisbash 1.1 _Analysis_assume_(n<1023);
191 buf[n] = '\0';
192 #if defined(CONFIG_OS_WINDOWS)
193 // convert buf to ansi string
194 if (!baseline)
195 {
196 size_t len = n / 2 + 1;
197 char* cpBuf = (char*)PAL_Malloc(len);
198 buf[n + 1] = '\0';
199 if (cpBuf == NULL) return false;
200 StrWcslcpy(cpBuf, (ZChar*)buf, len);
201 str += cpBuf;
202 PAL_Free(cpBuf);
203 }
204 else
205 str += buf;
206 #else
207 str += buf;
208 #endif
209 }
210
211 krisbash 1.1 fclose(is);
212
213 // Remove carriage-returns (Ctrl-M) characters:
214
215 strOut.clear();
216
217 for (size_t i = 0; i < str.size(); i++)
218 {
219 if (str[i] != '\r' && str[i] != '\n')
220 strOut += str[i];
221 }
222
223 return true;
224 }
225
226 static bool InhaleTestFile(const char* file, string& str)
227 {
228 char path[PAL_MAX_PATH_SIZE];
229
230 Strlcpy(path, OMI_GetPath(ID_PREFIX), sizeof(path));
231 Strlcat(path, "/tests/oi/", sizeof(path));
232 krisbash 1.1 Strlcat(path, file, sizeof(path));
233
234 return Inhale(path, str, true);
235 }
236
237 #if defined(CONFIG_OS_WINDOWS)
238
239 NitsTestWithSetup(Test_SingleEvent_ETW, TestOiSetup)
240 {
241 OIParser parser;
242 OIEvent * events = 0;
243 int count = 0;
244 char in[PAL_MAX_PATH_SIZE];
245 char out[PAL_MAX_PATH_SIZE];
246 char providerId[] = "{F93D404F-F291-496E-9D8D-56D8C6F8F650}";
247
248 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
249 Strlcat(in, "/tests/oi/", sizeof(in));
250 Strlcat(in, "test1.txt", sizeof(in));
251
252 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
253 krisbash 1.1 Strlcat(out, "/tests/oi/", sizeof(out));
254 Strlcat(out, "out.c.txt", sizeof(out));
255
256 memset(&parser, 0, sizeof(OIParser));
257 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
258 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
259
260 UT_ASSERT_EQUAL(count, 1);
261
262 Buckets set;
263 memset(&set, 0, sizeof(Buckets));
264 MI_Boolean ret = GenerateTaskOpcodeKeywords(events, &set);
265 UT_ASSERT_EQUAL(ret, MI_TRUE);
266
267 ret = GenerateEtw(events, &set, providerId, out);
268 UT_ASSERT_EQUAL(ret, MI_TRUE);
269
270 string gen, expected;
271 UT_ASSERT_EQUAL(InhaleTestFile("out.c.txt", gen), true);
272 UT_ASSERT_EQUAL(InhaleTestFile("expected1.etw.txt", expected), true);
273
274 krisbash 1.1 UT_ASSERT(gen == expected);
275
276 Parser_Destroy(&parser);
277 CleanupBuckets(&set);
278 }
279 NitsEndTest
280
281 NitsTestWithSetup(Test_ETWTaskOpcodesKeywords, TestOiSetup)
282 {
283 OIParser parser;
284 OIEvent * events = 0;
285 int count = 0;
286 char in[PAL_MAX_PATH_SIZE];
287 char out[PAL_MAX_PATH_SIZE];
288 char providerId[] = "{F93D404F-F291-496E-9D8D-56D8C6F8F650}";
289
290 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
291 Strlcat(in, "/tests/oi/", sizeof(in));
292 Strlcat(in, "test2.txt", sizeof(in));
293
294 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
295 krisbash 1.1 Strlcat(out, "/tests/oi/", sizeof(out));
296 Strlcat(out, "out.c.txt", sizeof(out));
297
298 memset(&parser, 0, sizeof(OIParser));
299 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
300 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
301
302 UT_ASSERT_EQUAL(count, 3);
303
304 Buckets set;
305 memset(&set, 0, sizeof(Buckets));
306 MI_Boolean ret = GenerateTaskOpcodeKeywords(events, &set);
307 UT_ASSERT_EQUAL(ret, MI_TRUE);
308
309 ret = GenerateEtw(events, &set, providerId, out);
310 UT_ASSERT_EQUAL(ret, MI_TRUE);
311
312 string gen, expected;
313 UT_ASSERT_EQUAL(InhaleTestFile("out.c.txt", gen), true);
314 UT_ASSERT_EQUAL(InhaleTestFile("expected2.etw.txt", expected), true);
315
316 krisbash 1.1 UT_ASSERT(gen == expected);
317
318 Parser_Destroy(&parser);
319 CleanupBuckets(&set);
320 }
321 NitsEndTest
322
323 NitsTestWithSetup(Test_ETWMultipleTasksEtc, TestOiSetup)
324 {
325 OIParser parser;
326 OIEvent * events = 0;
327 int count = 0;
328 char in[PAL_MAX_PATH_SIZE];
329 char out[PAL_MAX_PATH_SIZE];
330 char providerId[] = "{F93D404F-F291-496E-9D8D-56D8C6F8F650}";
331
332 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
333 Strlcat(in, "/tests/oi/", sizeof(in));
334 Strlcat(in, "test4.txt", sizeof(in));
335
336 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
337 krisbash 1.1 Strlcat(out, "/tests/oi/", sizeof(out));
338 Strlcat(out, "out.c.txt", sizeof(out));
339
340 memset(&parser, 0, sizeof(OIParser));
341 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
342 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
343
344 UT_ASSERT_EQUAL(count, 7);
345
346 Buckets set;
347 memset(&set, 0, sizeof(Buckets));
348 MI_Boolean ret = GenerateTaskOpcodeKeywords(events, &set);
349 UT_ASSERT_EQUAL(ret, MI_TRUE);
350
351 ret = GenerateEtw(events, &set, providerId, out);
352 UT_ASSERT_EQUAL(ret, MI_TRUE);
353
354 string gen, expected;
355 UT_ASSERT_EQUAL(InhaleTestFile("out.c.txt", gen), true);
356 UT_ASSERT_EQUAL(InhaleTestFile("expected4.etw.txt", expected), true);
357
358 krisbash 1.1 UT_ASSERT(gen == expected);
359
360 Parser_Destroy(&parser);
361 CleanupBuckets(&set);
362 }
363 NitsEndTest
364
365 NitsTestWithSetup(Test_Manifest, TestOiSetup)
366 {
367 OIParser parser;
368 OIEvent * events = 0;
369 int count = 0;
370 char in[PAL_MAX_PATH_SIZE];
371 char out[PAL_MAX_PATH_SIZE];
372 char providerId[] = "{d2c91d76-d9a9-46bb-b080-efc944c3ba2d}";
373
374 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
375 Strlcat(in, "/tests/oi/", sizeof(in));
376 Strlcat(in, "test2.txt", sizeof(in));
377
378 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
379 krisbash 1.1 Strlcat(out, "/tests/oi/", sizeof(out));
380 Strlcat(out, "man2.txt", sizeof(out));
381
382 memset(&parser, 0, sizeof(OIParser));
383 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
384 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
385
386 UT_ASSERT_EQUAL(count, 3);
387
388 Buckets set;
389 memset(&set, 0, sizeof(Buckets));
390 MI_Boolean ret = GenerateTaskOpcodeKeywords(events, &set);
391 UT_ASSERT_EQUAL(ret, MI_TRUE);
392
393 ret = GenerateManifest(events, &set, "FrogProvider", providerId, "FrogProvider.exe", out);
394 UT_ASSERT_EQUAL(ret, MI_TRUE);
395
396 string gen, expected;
397 UT_ASSERT_EQUAL(InhaleTestFile("man2.txt", gen), true);
398 UT_ASSERT_EQUAL(InhaleTestFile("manifest2.man.txt", expected), true);
399
400 krisbash 1.1 UT_ASSERT(gen == expected);
401
402 Parser_Destroy(&parser);
403 CleanupBuckets(&set);
404 }
405 NitsEndTest
406
407 NitsTestWithSetup(Test_Manifest_KeywordsOpcodesTasks, TestOiSetup)
408 {
409 OIParser parser;
410 OIEvent * events = 0;
411 int count = 0;
412 char in[PAL_MAX_PATH_SIZE];
413 char out[PAL_MAX_PATH_SIZE];
414 char providerId[] = "{d2c91d76-d9a9-46bb-b080-efc944c3ba2d}";
415
416 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
417 Strlcat(in, "/tests/oi/", sizeof(in));
418 Strlcat(in, "test4.txt", sizeof(in));
419
420 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
421 krisbash 1.1 Strlcat(out, "/tests/oi/", sizeof(out));
422 Strlcat(out, "man4.txt", sizeof(out));
423
424 memset(&parser, 0, sizeof(OIParser));
425 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
426 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
427
428 UT_ASSERT_EQUAL(count, 7);
429
430 Buckets set;
431 memset(&set, 0, sizeof(Buckets));
432 MI_Boolean ret = GenerateTaskOpcodeKeywords(events, &set);
433 UT_ASSERT_EQUAL(ret, MI_TRUE);
434
435 ret = GenerateManifest(events, &set, "FrogProvider", providerId, "FrogProvider.exe", out);
436 UT_ASSERT_EQUAL(ret, MI_TRUE);
437
438 string gen, expected;
439 UT_ASSERT_EQUAL(InhaleTestFile("man4.txt", gen), true);
440 UT_ASSERT_EQUAL(InhaleTestFile("manifest4.man.txt", expected), true);
441
442 krisbash 1.1 UT_ASSERT(gen == expected);
443
444 Parser_Destroy(&parser);
445 CleanupBuckets(&set);
446 }
447 NitsEndTest
448 #endif
449
450 NitsTestWithSetup(Test_Parser_SyslogPriority, TestOiSetup)
451 {
452 OIParser parser;
453 OIEvent * events = 0;
454 int count = 0;
455 char in[PAL_MAX_PATH_SIZE];
456 char out[PAL_MAX_PATH_SIZE];
457
458 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
459 Strlcat(in, "/tests/oi/", sizeof(in));
460 Strlcat(in, "syslog1.txt", sizeof(in));
461
462 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
463 krisbash 1.1 Strlcat(out, "/tests/oi/", sizeof(out));
464 Strlcat(out, "out.c.txt", sizeof(out));
465
466 memset(&parser, 0, sizeof(OIParser));
467 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
468 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
469
470 UT_ASSERT_EQUAL(count, 1);
471 if (count > 0)
472 {
473 UT_ASSERT_EQUAL(Strcmp(events->Name, "FrogEvents_JumpEvent"), 0);
474 UT_ASSERT_EQUAL(Strcmp(events->Format, "\"I have jumped %d feet\""), 0);
475 UT_ASSERT_EQUAL(Strcmp(events->Priority, "LOG_NOTICE"), 0);
476 UT_ASSERT_EQUAL(events->next, 0);
477
478 UT_ASSERT(events->Argument != NULL);
479 if (events->Argument)
480 {
481 UT_ASSERT_EQUAL(Strcmp(events->Argument->Name, "number"), 0);
482 UT_ASSERT_EQUAL(Strcmp(events->Argument->Type, "int"), 0);
483 UT_ASSERT_EQUAL(events->Argument->next, 0);
484 krisbash 1.1 }
485 }
486
487 Parser_Destroy(&parser);
488 }
489 NitsEndTest
490
491 NitsTestWithSetup(Test_Parser_SyslogPriorities, TestOiSetup)
492 {
493 OIParser parser;
494 OIEvent * events = 0;
495 int count = 0;
496 char in[PAL_MAX_PATH_SIZE];
497 char out[PAL_MAX_PATH_SIZE];
498
499 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
500 Strlcat(in, "/tests/oi/", sizeof(in));
501 Strlcat(in, "syslog2.txt", sizeof(in));
502
503 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
504 Strlcat(out, "/tests/oi/", sizeof(out));
505 krisbash 1.1 Strlcat(out, "out.c.txt", sizeof(out));
506
507 memset(&parser, 0, sizeof(OIParser));
508 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
509 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
510
511 UT_ASSERT_EQUAL(count, 2);
512 if (count > 0)
513 {
514 UT_ASSERT_EQUAL(Strcmp(events->Name, "FrogEvents_JumpEvent"), 0);
515 UT_ASSERT_EQUAL(Strcmp(events->Format, "\"I have jumped %d feet\""), 0);
516 UT_ASSERT_EQUAL(Strcmp(events->Priority, "LOG_NOTICE"), 0);
517 UT_ASSERT(events->Argument != NULL);
518 if (events->Argument)
519 {
520 UT_ASSERT_EQUAL(Strcmp(events->Argument->Name, "number"), 0);
521 UT_ASSERT_EQUAL(Strcmp(events->Argument->Type, "int"), 0);
522 UT_ASSERT_EQUAL(events->Argument->next, 0);
523 }
524
525 UT_ASSERT(events->next != NULL);
526 krisbash 1.1 if (events->next)
527 {
528 OIEvent * second = events->next;
529 UT_ASSERT_EQUAL(Strcmp(second->Priority, "LOG_WARNING"), 0);
530 UT_ASSERT(second->next == NULL);
531 }
532 }
533
534 Parser_Destroy(&parser);
535 }
536 NitsEndTest
537
538 NitsTestWithSetup(Test_SingleEvent_Syslog, TestOiSetup)
539 {
540 OIParser parser;
541 OIEvent * events = 0;
542 int count = 0;
543 char in[PAL_MAX_PATH_SIZE];
544 char out[PAL_MAX_PATH_SIZE];
545
546 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
547 krisbash 1.1 Strlcat(in, "/tests/oi/", sizeof(in));
548 Strlcat(in, "syslog1.txt", sizeof(in));
549
550 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
551 Strlcat(out, "/tests/oi/", sizeof(out));
552 Strlcat(out, "out.c.txt", sizeof(out));
553
554 memset(&parser, 0, sizeof(OIParser));
555 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
556 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
557
558 UT_ASSERT_EQUAL(count, 1);
559
560 MI_Boolean ret = GenerateSyslog(events, "examplelog", "LOG_CONS | LOG_PID | LOG_NDELAY", "LOG_LOCAL1", out);
561 UT_ASSERT_EQUAL(ret, MI_TRUE);
562
563 string gen, expected;
564 UT_ASSERT_EQUAL(InhaleTestFile("out.c.txt", gen), true);
565 UT_ASSERT_EQUAL(InhaleTestFile("expected1.syslog.txt", expected), true);
566
567 UT_ASSERT(gen == expected);
568 krisbash 1.1
569 Parser_Destroy(&parser);
570 }
571 NitsEndTest
572
573 NitsTestWithSetup(Test_Parser_AutoID, TestOiSetup)
574 {
575 OIParser parser;
576 OIEvent * events = 0;
577 int count = 0;
578 char in[PAL_MAX_PATH_SIZE];
579 char out[PAL_MAX_PATH_SIZE];
580
581 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
582 Strlcat(in, "/tests/oi/", sizeof(in));
583 Strlcat(in, "syslog3.txt", sizeof(in));
584
585 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
586 Strlcat(out, "/tests/oi/", sizeof(out));
587 Strlcat(out, "out.c.txt", sizeof(out));
588
589 krisbash 1.1 memset(&parser, 0, sizeof(OIParser));
590 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
591 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
592
593 UT_ASSERT_EQUAL(count, 5);
594 if (count > 0)
595 {
596 // first event
597 UT_ASSERT_EQUAL(Strcmp(events->Name, "trace_1"), 0);
598 UT_ASSERT_EQUAL(Strcmp(events->EventId, "1000"), 0);
599
600 // second event
601 OIEvent * second = events->next;
602 UT_ASSERT(second != NULL);
603 if (second)
604 {
605 UT_ASSERT_EQUAL(Strcmp(second->EventId, "1001"), 0);
606 UT_ASSERT(second->next != NULL);
607
608 // third event
609 OIEvent * third = second->next;
610 krisbash 1.1 UT_ASSERT(third != NULL);
611 if (third)
612 {
613 UT_ASSERT_EQUAL(Strcmp(third->EventId, "2001"), 0);
614 UT_ASSERT(third->next != NULL);
615
616 // forth event
617 OIEvent * forth = third->next;
618 UT_ASSERT(forth != NULL);
619 if (forth)
620 {
621 UT_ASSERT_EQUAL(Strcmp(forth->EventId, "2002"), 0);
622 UT_ASSERT(forth->next != NULL);
623
624 // last event
625 OIEvent * last = forth->next;
626 UT_ASSERT(last != NULL);
627 if (last)
628 {
629 UT_ASSERT_EQUAL(Strcmp(last->EventId, "3000"), 0);
630 UT_ASSERT(last->next == NULL);
631 krisbash 1.1 }
632 }
633 }
634 }
635 }
636
637 Parser_Destroy(&parser);
638 }
639 NitsEndTest
640
641 NitsTestWithSetup(Test_AutoID_Syslog, TestOiSetup)
642 {
643 OIParser parser;
644 OIEvent * events = 0;
645 int count = 0;
646 char in[PAL_MAX_PATH_SIZE];
647 char out[PAL_MAX_PATH_SIZE];
648
649 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
650 Strlcat(in, "/tests/oi/", sizeof(in));
651 Strlcat(in, "syslog3.txt", sizeof(in));
652 krisbash 1.1
653 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
654 Strlcat(out, "/tests/oi/", sizeof(out));
655 Strlcat(out, "out.c.txt", sizeof(out));
656
657 memset(&parser, 0, sizeof(OIParser));
658 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
659 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
660
661 UT_ASSERT_EQUAL(count, 5);
662
663 MI_Boolean ret = GenerateSyslog(events, "examplelog", "LOG_CONS | LOG_PID | LOG_NDELAY", "LOG_LOCAL1", out);
664 UT_ASSERT_EQUAL(ret, MI_TRUE);
665
666 string gen, expected;
667 UT_ASSERT_EQUAL(InhaleTestFile("out.c.txt", gen), true);
668 UT_ASSERT_EQUAL(InhaleTestFile("expected3.syslog.txt", expected), true);
669
670 UT_ASSERT(gen == expected);
671
672 Parser_Destroy(&parser);
673 krisbash 1.1 }
674 NitsEndTest
675
676 NitsTestWithSetup(Test_SingleEvent_FileGen, TestOiSetup)
677 {
678 OIParser parser;
679 OIEvent * events = 0;
680 int count = 0;
681 char in[PAL_MAX_PATH_SIZE];
682 char out[PAL_MAX_PATH_SIZE];
683
684 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
685 Strlcat(in, "/tests/oi/", sizeof(in));
686 Strlcat(in, "syslog1.txt", sizeof(in));
687
688 Strlcpy(out, OMI_GetPath(ID_PREFIX), sizeof(out));
689 Strlcat(out, "/tests/oi/", sizeof(out));
690 Strlcat(out, "out.c.txt", sizeof(out));
691
692 memset(&parser, 0, sizeof(OIParser));
693 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
694 krisbash 1.1 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
695
696 UT_ASSERT_EQUAL(count, 1);
697
698 MI_Boolean ret = GenerateFile(events, out);
699 UT_ASSERT_EQUAL(ret, MI_TRUE);
700
701 string gen, expected;
702 UT_ASSERT_EQUAL(InhaleTestFile("out.c.txt", gen), true);
703 UT_ASSERT_EQUAL(InhaleTestFile("expected1.filegen.txt", expected), true);
704
705 UT_ASSERT(gen == expected);
706
707 Parser_Destroy(&parser);
708 }
709 NitsEndTest
710
711 NitsTestWithSetup(Test_Parser_Parsing, TestOiSetup)
712 {
713 OIParser parser;
714 OIEvent * events = 0;
715 krisbash 1.1 int count = 0;
716 char in[PAL_MAX_PATH_SIZE];
717
718 Strlcpy(in, OMI_GetPath(ID_PREFIX), sizeof(in));
719 Strlcat(in, "/tests/oi/", sizeof(in));
720 Strlcat(in, "test3.txt", sizeof(in));
721
722 memset(&parser, 0, sizeof(OIParser));
723 UT_ASSERT_EQUAL(Parser_Init(&parser, in), MI_TRUE);
724 UT_ASSERT_EQUAL(Parser_Parse(&parser, &events, &count), MI_TRUE);
725
726 UT_ASSERT_EQUAL(count, 1);
727 if (count > 0)
728 {
729 // first event
730 UT_ASSERT_EQUAL(Strcmp(events->Name, "trace_Me"), 0);
731 UT_ASSERT_EQUAL(Strcmp(events->EventId, "1"), 0);
732 UT_ASSERT_EQUAL(Strcmp(events->Format, "\", testing commas , , , \""), 0);
733 }
734
735 Parser_Destroy(&parser);
736 krisbash 1.1 }
737 NitsEndTest
738
739 #if 0
740 /*
741 This test should only work when the code is built for ETW logging
742 */
743 NitsTestWithSetup(Test_ETWActivityID, TestOiSetup)
744 {
745 OIGUID test, newone;
746 memset(&test, 0, sizeof(OIGUID));
747 memset(&newone, 0, sizeof(OIGUID));
748 UT_ASSERT_EQUAL(test.Data1, 0);
749
750 OIActivityId(OI_CTRL_CREATE_ID, &test);
751 OIActivityId(OI_CTRL_SET_ID, &test);
752 OIActivityId(OI_CTRL_GET_ID, &newone);
753
754 trace_EventTransfer(&test, &newone);
755 trace_EventTransfer(NULL, &newone);
756
757 krisbash 1.1 UT_ASSERT_EQUAL(test.Data1, newone.Data1);
758 }
759 NitsEndTest
760 #endif
761
762
|
Return to
test_oi.cpp
CVS log
Up to [OMI] / omi / tests / oi