Lines Matching full:parser
6 """Unittests for the parser module."""
9 import parser # pylint: disable=wrong-import-order
29 parser_state = parser.ParserState("<memory>")
110 parser.ParseException,
125 self.parser = parser.PolicyParser(
131 return list(self.parser._parser_state.tokenize([line]))[0]
136 self.parser.parse_value(self._tokenize("0x80000000")), 0x80000000
140 self.parser.parse_value(self._tokenize("0x8000000000000000")),
148 parser.ParseException, "unsigned overflow"
150 self.parser.parse_value(self._tokenize("0x100000000"))
151 with self.assertRaisesRegex(parser.ParseException, "unsigned overflow"):
152 self.parser.parse_value(self._tokenize("0x10000000000000000"))
157 self.parser.parse_value(self._tokenize("-1")),
165 parser.ParseException, "signed underflow"
167 self.parser.parse_value(self._tokenize("-0x800000001"))
168 with self.assertRaisesRegex(parser.ParseException, "signed underflow"):
169 self.parser.parse_value(self._tokenize("-0x8000000000000001"))
174 self.parser.parse_value(self._tokenize("0x1|0x2|0x4|0x8")), 0xF
190 with self.assertRaises(parser.ParseException, msg=expression):
191 self.parser.parse_value(self._tokenize(expression))
200 self.parser.parse_value(tokens)
214 self.parser.parse_value(self._tokenize(expression)), 3
220 self.parser.parse_value(self._tokenize("~0")),
224 self.parser.parse_value(self._tokenize("~0|~0")),
229 self.parser.parse_value(
235 self.parser.parse_value(
242 self.parser.parse_value(
248 self.parser.parse_value(
258 with self.assertRaisesRegex(parser.ParseException, "double complement"):
259 self.parser.parse_value(self._tokenize("~~0"))
263 with self.assertRaisesRegex(parser.ParseException, "empty complement"):
264 self.parser.parse_value(self._tokenize("0|~"))
268 self.assertEqual(self.parser.parse_value(self._tokenize("O_RDONLY")), 0)
272 with self.assertRaisesRegex(parser.ParseException, "empty constant"):
273 self.parser.parse_value([])
274 with self.assertRaisesRegex(parser.ParseException, "empty constant"):
275 self.parser.parse_value(self._tokenize("0|"))
279 with self.assertRaisesRegex(parser.ParseException, "invalid constant"):
280 self.parser.parse_value(self._tokenize("foo"))
288 self.parser = parser.PolicyParser(
294 return list(self.parser._parser_state.tokenize([line]))[0]
299 self.parser.parse_argument_expression(
305 [parser.Atom(0, "in", 0xFFFF)],
306 [parser.Atom(0, "==", 4), parser.Atom(1, "==", 2)],
314 self.parser.parse_argument_expression(
318 [parser.Atom(0, "in", 4607)],
323 self.parser.parse_argument_expression(
327 [parser.Atom(0, "in", 4607)],
332 self.parser.parse_argument_expression(
336 [parser.Atom(0, "in", 4607)],
343 parser.ParseException, "empty argument expression"
345 self.parser.parse_argument_expression(
351 with self.assertRaisesRegex(parser.ParseException, "empty clause"):
352 self.parser.parse_argument_expression(
358 with self.assertRaisesRegex(parser.ParseException, "invalid argument"):
359 self.parser.parse_argument_expression(
365 with self.assertRaisesRegex(parser.ParseException, "invalid operator"):
366 self.parser.parse_argument_expression(
372 with self.assertRaisesRegex(parser.ParseException, "missing operator"):
373 self.parser.parse_argument_expression(self._tokenize("arg0"))
377 with self.assertRaisesRegex(parser.ParseException, "empty constant"):
378 self.parser.parse_argument_expression(self._tokenize("arg0 =="))
386 self.parser = parser.PolicyParser(
392 return list(self.parser._parser_state.tokenize([line]))[0]
397 self.parser.parse_filter(self._tokenize("arg0 == 0")),
399 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
403 self.parser.parse_filter(self._tokenize("kill-process")),
405 parser.Filter(None, bpf.KillProcess()),
409 self.parser.parse_filter(self._tokenize("kill-thread")),
411 parser.Filter(None, bpf.KillThread()),
415 self.parser.parse_filter(self._tokenize("trap")),
417 parser.Filter(None, bpf.Trap()),
421 self.parser.parse_filter(self._tokenize("return ENOSYS")),
423 parser.Filter(
429 self.parser.parse_filter(self._tokenize("trace")),
431 parser.Filter(None, bpf.Trace()),
435 self.parser.parse_filter(self._tokenize("user-notify")),
437 parser.Filter(None, bpf.UserNotify()),
441 self.parser.parse_filter(self._tokenize("log")),
443 parser.Filter(None, bpf.Log()),
447 self.parser.parse_filter(self._tokenize("allow")),
449 parser.Filter(None, bpf.Allow()),
453 self.parser.parse_filter(self._tokenize("1")),
455 parser.Filter(None, bpf.Allow()),
459 self.parser.parse_filter(
463 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
464 parser.Filter(
465 [[parser.Atom(0, "==", 1)]],
468 parser.Filter(None, bpf.Trap()),
475 parser.ParseException, "missing return value"
477 self.parser.parse_filter(self._tokenize("return"))
481 with self.assertRaisesRegex(parser.ParseException, "invalid constant"):
482 self.parser.parse_filter(self._tokenize("return arg0"))
486 with self.assertRaisesRegex(parser.ParseException, "unclosed brace"):
487 self.parser.parse_filter(self._tokenize("{ allow"))
496 self.parser = parser.PolicyParser(
502 return list(self.parser._parser_state.tokenize([line]))[0]
507 self.parser.parse_filter(
511 parser.Filter(
512 [[parser.Atom(0, "==", 0)]],
524 self.parser = parser.PolicyParser(
530 return list(self.parser._parser_state.tokenize([line]))[0]
543 self.parser.parse_filter_statement(
546 parser.ParsedFilterStatement(
547 syscalls=(parser.Syscall("read", 0),),
549 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
555 self.parser.parse_filter_statement(
558 parser.ParsedFilterStatement(
560 parser.Syscall("read", 0),
561 parser.Syscall("write", 1),
564 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
570 self.parser.parse_filter_statement(
573 parser.ParsedFilterStatement(
575 parser.Syscall("read", 0),
576 parser.Syscall("write", 1),
579 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
585 self.parser.parse_filter_statement(
588 parser.ParsedFilterStatement(
590 parser.Syscall("read", 0),
591 parser.Syscall("write", 1),
594 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
600 self.parser.parse_filter_statement(
603 parser.ParsedFilterStatement(
604 syscalls=(parser.Syscall("kill", 62),),
606 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
615 self.parser.parse_filter_statement(
618 parser.ParsedFilterStatement(
619 syscalls=(parser.Syscall("read", 0),),
621 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
627 self.parser.parse_filter_statement(
632 parser.ParsedFilterStatement(
633 syscalls=(parser.Syscall("read", 0),),
635 parser.Filter([[parser.Atom(0, "==", 0)]], bpf.Allow()),
643 with self.assertRaisesRegex(parser.ParseException, "unclosed brace"):
644 self.parser.parse_filter(self._tokenize("{ allow"))
648 with self.assertRaisesRegex(parser.ParseException, "unclosed brace"):
649 self.parser.parse_filter_statement(
655 with self.assertRaisesRegex(parser.ParseException, "missing colon"):
656 self.parser.parse_filter_statement(self._tokenize("read"))
660 with self.assertRaisesRegex(parser.ParseException, "invalid colon"):
661 self.parser.parse_filter_statement(self._tokenize("read arg0"))
665 with self.assertRaisesRegex(parser.ParseException, "missing filter"):
666 self.parser.parse_filter_statement(self._tokenize("read:"))
674 self.parser = parser.PolicyParser(
701 self.parser.parse_file(path),
702 parser.ParsedPolicy(
705 parser.FilterStatement(
706 syscall=parser.Syscall("read", 0),
709 parser.Filter(None, bpf.Allow()),
712 parser.FilterStatement(
713 syscall=parser.Syscall("write", 1),
716 parser.Filter(None, bpf.Allow()),
736 self.parser.parse_file(path),
737 parser.ParsedPolicy(
740 parser.FilterStatement(
741 syscall=parser.Syscall("read", 0),
744 parser.Filter(None, bpf.Allow()),
747 parser.FilterStatement(
748 syscall=parser.Syscall("write", 1),
751 parser.Filter(None, bpf.Allow()),
769 self.parser.parse_file(path),
770 parser.ParsedPolicy(
773 parser.FilterStatement(
774 syscall=parser.Syscall("read", 0),
777 parser.Filter(None, bpf.Allow()),
795 parser.ParseException, r"invalid permissive default action"
797 self.parser.parse_file(path)
810 self.parser.parse_file(path),
811 parser.ParsedPolicy(
814 parser.FilterStatement(
815 syscall=parser.Syscall("read", 0),
818 parser.Filter(None, bpf.Allow()),
821 parser.FilterStatement(
822 syscall=parser.Syscall("write", 1),
825 parser.Filter(None, bpf.Allow()),
844 self.parser.parse_file(path),
845 parser.ParsedPolicy(
848 parser.FilterStatement(
849 syscall=parser.Syscall("write", 1),
852 parser.Filter(None, bpf.Allow()),
876 self.parser.parse_file(path),
877 parser.ParsedPolicy(
880 parser.FilterStatement(
881 syscall=parser.Syscall("read", 0),
884 parser.Filter(
885 [[parser.Atom(0, "==", 0)]], bpf.Allow()
887 parser.Filter(
893 parser.FilterStatement(
894 syscall=parser.Syscall("write", 1),
897 parser.Filter(
898 [[parser.Atom(0, "==", 0)]], bpf.Allow()
900 parser.Filter(None, bpf.KillProcess()),
910 parser.ParseException, r"empty include path"
918 self.parser.parse_file(path)
921 parser.ParseException, r"invalid include path"
929 self.parser.parse_file(path)
932 parser.ParseException, r"@include statement nested too deep"
940 self.parser.parse_file(path)
943 parser.ParseException, r"Could not @include .*"
951 self.parser.parse_file(path)
971 self.parser.parse_file(path),
972 parser.ParsedPolicy(
975 parser.FilterStatement(
976 syscall=parser.Syscall("read", 0),
979 parser.Filter(None, bpf.Allow()),
992 with self.assertRaisesRegex(parser.ParseException, r"missing colon"):
999 self.parser.parse_file(path)
1001 with self.assertRaisesRegex(parser.ParseException, r"invalid colon"):
1008 self.parser.parse_file(path)
1010 with self.assertRaisesRegex(parser.ParseException, r"missing number"):
1017 self.parser.parse_file(path)
1019 with self.assertRaisesRegex(parser.ParseException, r"invalid number"):
1026 self.parser.parse_file(path)
1028 with self.assertRaisesRegex(parser.ParseException, r"invalid number"):
1035 self.parser.parse_file(path)
1038 parser.ParseException, r"empty frequency path"
1046 self.parser.parse_file(path)
1049 parser.ParseException, r"invalid frequency path"
1057 self.parser.parse_file(path)
1060 parser.ParseException, r"Could not open frequency file.*"
1068 self.parser.parse_file(path)
1081 parser.ParseException,
1088 self.parser.parse_file(path)
1099 parser.ParseException,
1106 self.parser.parse_file(path)
1111 parser.ParseException,
1120 self.parser.parse_file(path)
1129 self.parser = parser.PolicyParser(
1157 self.parser.parse_file(path),
1158 parser.ParsedPolicy(
1161 parser.FilterStatement(
1162 syscall=parser.Syscall("read", 0),
1165 parser.Filter(
1171 parser.FilterStatement(
1172 syscall=parser.Syscall("write", 1),
1175 parser.Filter(
1198 self.parser.parse_file(path),
1199 parser.ParsedPolicy(
1202 parser.FilterStatement(
1203 syscall=parser.Syscall("read", 0),
1206 parser.Filter(
1212 parser.FilterStatement(
1213 syscall=parser.Syscall("write", 1),
1216 parser.Filter(
1217 [[parser.Atom(0, "==", 0)]],
1220 parser.Filter(None, bpf.Allow()),
1230 parser.ParseException,
1240 self.parser.parse_file(path)