Lines Matching full:parser
17 """Unittests for the parser module."""
31 import parser # pylint: disable=wrong-import-order
43 parser_state = parser.ParserState('<memory>')
103 with self.assertRaisesRegex(parser.ParseException,
115 self.parser = parser.PolicyParser(
120 return list(self.parser._parser_state.tokenize([line]))[0]
125 self.parser.parse_value(self._tokenize('0x80000000')), 0x80000000)
128 self.parser.parse_value(self._tokenize('0x8000000000000000')),
134 with self.assertRaisesRegex(parser.ParseException,
136 self.parser.parse_value(self._tokenize('0x100000000'))
137 with self.assertRaisesRegex(parser.ParseException,
139 self.parser.parse_value(self._tokenize('0x10000000000000000'))
144 self.parser.parse_value(self._tokenize('-1')),
150 with self.assertRaisesRegex(parser.ParseException,
152 self.parser.parse_value(self._tokenize('-0x800000001'))
153 with self.assertRaisesRegex(parser.ParseException, 'signed underflow'):
154 self.parser.parse_value(self._tokenize('-0x8000000000000001'))
159 self.parser.parse_value(self._tokenize('0x1|0x2|0x4|0x8')), 0xf)
174 with self.assertRaises(parser.ParseException, msg=expression):
175 self.parser.parse_value(self._tokenize(expression))
184 self.parser.parse_value(tokens)
198 self.parser.parse_value(self._tokenize(expression)), 3)
203 self.parser.parse_value(self._tokenize('~0')),
206 self.parser.parse_value(self._tokenize('~0|~0')),
210 self.parser.parse_value(
213 self.parser.parse_value(
218 self.parser.parse_value(
222 self.parser.parse_value(
229 with self.assertRaisesRegex(parser.ParseException,
231 self.parser.parse_value(self._tokenize('~~0'))
235 with self.assertRaisesRegex(parser.ParseException, 'empty complement'):
236 self.parser.parse_value(self._tokenize('0|~'))
241 self.parser.parse_value(self._tokenize('O_RDONLY')), 0)
245 with self.assertRaisesRegex(parser.ParseException, 'empty constant'):
246 self.parser.parse_value([])
247 with self.assertRaisesRegex(parser.ParseException, 'empty constant'):
248 self.parser.parse_value(self._tokenize('0|'))
252 with self.assertRaisesRegex(parser.ParseException, 'invalid constant'):
253 self.parser.parse_value(self._tokenize('foo'))
261 self.parser = parser.PolicyParser(
266 return list(self.parser._parser_state.tokenize([line]))[0]
271 self.parser.parse_argument_expression(
275 [parser.Atom(0, 'in', 0xffff)],
276 [parser.Atom(0, '==', 4),
277 parser.Atom(1, '==', 2)],
284 self.parser.parse_argument_expression(
286 [parser.Atom(0, 'in', 4607)],
290 self.parser.parse_argument_expression(
292 [parser.Atom(0, 'in', 4607)],
296 self.parser.parse_argument_expression(
298 [parser.Atom(0, 'in', 4607)],
303 with self.assertRaisesRegex(parser.ParseException,
305 self.parser.parse_argument_expression(
310 with self.assertRaisesRegex(parser.ParseException, 'empty clause'):
311 self.parser.parse_argument_expression(
316 with self.assertRaisesRegex(parser.ParseException, 'invalid argument'):
317 self.parser.parse_argument_expression(
322 with self.assertRaisesRegex(parser.ParseException, 'invalid operator'):
323 self.parser.parse_argument_expression(
328 with self.assertRaisesRegex(parser.ParseException, 'missing operator'):
329 self.parser.parse_argument_expression(self._tokenize('arg0'))
333 with self.assertRaisesRegex(parser.ParseException, 'empty constant'):
334 self.parser.parse_argument_expression(self._tokenize('arg0 =='))
342 self.parser = parser.PolicyParser(
347 return list(self.parser._parser_state.tokenize([line]))[0]
352 self.parser.parse_filter(self._tokenize('arg0 == 0')), [
353 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
356 self.parser.parse_filter(self._tokenize('kill-process')), [
357 parser.Filter(None, bpf.KillProcess()),
360 self.parser.parse_filter(self._tokenize('kill-thread')), [
361 parser.Filter(None, bpf.KillThread()),
364 self.parser.parse_filter(self._tokenize('trap')), [
365 parser.Filter(None, bpf.Trap()),
368 self.parser.parse_filter(self._tokenize('return ENOSYS')), [
369 parser.Filter(None,
373 self.parser.parse_filter(self._tokenize('trace')), [
374 parser.Filter(None, bpf.Trace()),
377 self.parser.parse_filter(self._tokenize('user-notify')), [
378 parser.Filter(None, bpf.UserNotify()),
381 self.parser.parse_filter(self._tokenize('log')), [
382 parser.Filter(None, bpf.Log()),
385 self.parser.parse_filter(self._tokenize('allow')), [
386 parser.Filter(None, bpf.Allow()),
389 self.parser.parse_filter(self._tokenize('1')), [
390 parser.Filter(None, bpf.Allow()),
393 self.parser.parse_filter(
397 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
398 parser.Filter([[parser.Atom(0, '==', 1)]],
400 parser.Filter(None, bpf.Trap()),
405 with self.assertRaisesRegex(parser.ParseException,
407 self.parser.parse_filter(self._tokenize('return'))
411 with self.assertRaisesRegex(parser.ParseException, 'invalid constant'):
412 self.parser.parse_filter(self._tokenize('return arg0'))
416 with self.assertRaisesRegex(parser.ParseException, 'unclosed brace'):
417 self.parser.parse_filter(self._tokenize('{ allow'))
426 self.parser = parser.PolicyParser(
431 return list(self.parser._parser_state.tokenize([line]))[0]
436 self.parser.parse_filter(self._tokenize('arg0 == 0; return ENOSYS')),
438 parser.Filter([[parser.Atom(0, '==', 0)]],
448 self.parser = parser.PolicyParser(
453 return list(self.parser._parser_state.tokenize([line]))[0]
464 self.parser.parse_filter_statement(
466 parser.ParsedFilterStatement(
467 syscalls=(parser.Syscall('read', 0), ),
469 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
473 self.parser.parse_filter_statement(
475 parser.ParsedFilterStatement(
477 parser.Syscall('read', 0),
478 parser.Syscall('write', 1),
481 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
485 self.parser.parse_filter_statement(
487 parser.ParsedFilterStatement(
489 parser.Syscall('read', 0),
490 parser.Syscall('write', 1),
493 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
497 self.parser.parse_filter_statement(
499 parser.ParsedFilterStatement(
501 parser.Syscall('read', 0),
502 parser.Syscall('write', 1),
505 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
509 self.parser.parse_filter_statement(
511 parser.ParsedFilterStatement(
513 parser.Syscall('kill', 62),
516 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
523 self.parser.parse_filter_statement(
525 parser.ParsedFilterStatement(
527 parser.Syscall('read', 0),
530 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
534 self.parser.parse_filter_statement(
537 parser.ParsedFilterStatement(
539 parser.Syscall('read', 0),
542 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
548 with self.assertRaisesRegex(parser.ParseException, 'unclosed brace'):
549 self.parser.parse_filter(self._tokenize('{ allow'))
553 with self.assertRaisesRegex(parser.ParseException, 'unclosed brace'):
554 self.parser.parse_filter_statement(
559 with self.assertRaisesRegex(parser.ParseException, 'missing colon'):
560 self.parser.parse_filter_statement(self._tokenize('read'))
564 with self.assertRaisesRegex(parser.ParseException, 'invalid colon'):
565 self.parser.parse_filter_statement(self._tokenize('read arg0'))
569 with self.assertRaisesRegex(parser.ParseException, 'missing filter'):
570 self.parser.parse_filter_statement(self._tokenize('read:'))
578 self.parser = parser.PolicyParser(
602 self.parser.parse_file(path),
603 parser.ParsedPolicy(
606 parser.FilterStatement(
607 syscall=parser.Syscall('read', 0),
610 parser.Filter(None, bpf.Allow()),
612 parser.FilterStatement(
613 syscall=parser.Syscall('write', 1),
616 parser.Filter(None, bpf.Allow()),
631 self.parser.parse_file(path),
632 parser.ParsedPolicy(
635 parser.FilterStatement(
636 syscall=parser.Syscall('read', 0),
639 parser.Filter(None, bpf.Allow()),
641 parser.FilterStatement(
642 syscall=parser.Syscall('write', 1),
645 parser.Filter(None, bpf.Allow()),
658 self.parser.parse_file(path),
659 parser.ParsedPolicy(
662 parser.FilterStatement(
663 syscall=parser.Syscall('read', 0),
666 parser.Filter(None, bpf.Allow()),
678 with self.assertRaisesRegex(parser.ParseException,
680 self.parser.parse_file(path)
691 self.parser.parse_file(path),
692 parser.ParsedPolicy(
695 parser.FilterStatement(
696 syscall=parser.Syscall('read', 0),
699 parser.Filter(None, bpf.Allow()),
701 parser.FilterStatement(
702 syscall=parser.Syscall('write', 1),
705 parser.Filter(None, bpf.Allow()),
719 self.parser.parse_file(path),
720 parser.ParsedPolicy(
723 parser.FilterStatement(
724 syscall=parser.Syscall('write', 1),
727 parser.Filter(None, bpf.Allow()),
744 self.parser.parse_file(path),
745 parser.ParsedPolicy(
748 parser.FilterStatement(
749 syscall=parser.Syscall('read', 0),
752 parser.Filter([[parser.Atom(0, '==', 0)]],
754 parser.Filter(
759 parser.FilterStatement(
760 syscall=parser.Syscall('write', 1),
763 parser.Filter([[parser.Atom(0, '==', 0)]],
765 parser.Filter(None, bpf.KillProcess()),
771 with self.assertRaisesRegex(parser.ParseException,
777 self.parser.parse_file(path)
779 with self.assertRaisesRegex(parser.ParseException,
785 self.parser.parse_file(path)
787 with self.assertRaisesRegex(parser.ParseException,
793 self.parser.parse_file(path)
795 with self.assertRaisesRegex(parser.ParseException,
801 self.parser.parse_file(path)
817 self.parser.parse_file(path),
818 parser.ParsedPolicy(
821 parser.FilterStatement(
822 syscall=parser.Syscall('read', 0),
825 parser.Filter(None, bpf.Allow()),
834 with self.assertRaisesRegex(parser.ParseException, r'missing colon'):
838 self.parser.parse_file(path)
840 with self.assertRaisesRegex(parser.ParseException, r'invalid colon'):
844 self.parser.parse_file(path)
846 with self.assertRaisesRegex(parser.ParseException, r'missing number'):
850 self.parser.parse_file(path)
852 with self.assertRaisesRegex(parser.ParseException, r'invalid number'):
856 self.parser.parse_file(path)
858 with self.assertRaisesRegex(parser.ParseException, r'invalid number'):
862 self.parser.parse_file(path)
864 with self.assertRaisesRegex(parser.ParseException,
870 self.parser.parse_file(path)
872 with self.assertRaisesRegex(parser.ParseException,
878 self.parser.parse_file(path)
880 with self.assertRaisesRegex(parser.ParseException,
886 self.parser.parse_file(path)
897 parser.ParseException,
901 self.parser.parse_file(path)
910 parser.ParseException,
914 self.parser.parse_file(path)
918 with self.assertRaisesRegex(parser.ParseException,
925 self.parser.parse_file(path)
934 self.parser = parser.PolicyParser(
959 self.parser.parse_file(path),
960 parser.ParsedPolicy(
963 parser.FilterStatement(
964 syscall=parser.Syscall('read', 0),
967 parser.Filter(None, bpf.ReturnErrno(
970 parser.FilterStatement(
971 syscall=parser.Syscall('write', 1),
974 parser.Filter(None, bpf.ReturnErrno(
990 self.parser.parse_file(path),
991 parser.ParsedPolicy(
994 parser.FilterStatement(
995 syscall=parser.Syscall('read', 0),
998 parser.Filter(None, bpf.ReturnErrno(
1001 parser.FilterStatement(
1002 syscall=parser.Syscall('write', 1),
1005 parser.Filter([[parser.Atom(0, '==', 0)]],
1007 parser.Filter(None, bpf.Allow()),
1014 with self.assertRaisesRegex(parser.ParseException,
1021 self.parser.parse_file(path)