Lines Matching full:parser
17 """Unittests for the parser module."""
30 import parser # pylint: disable=wrong-import-order
42 parser_state = parser.ParserState('<memory>')
102 with self.assertRaisesRegex(parser.ParseException,
114 self.parser = parser.PolicyParser(
119 return list(self.parser._parser_state.tokenize([line]))[0]
124 self.parser.parse_value(self._tokenize('0x80000000')), 0x80000000)
127 self.parser.parse_value(self._tokenize('0x8000000000000000')),
133 with self.assertRaisesRegex(parser.ParseException,
135 self.parser.parse_value(self._tokenize('0x100000000'))
136 with self.assertRaisesRegex(parser.ParseException,
138 self.parser.parse_value(self._tokenize('0x10000000000000000'))
143 self.parser.parse_value(self._tokenize('-1')),
149 with self.assertRaisesRegex(parser.ParseException,
151 self.parser.parse_value(self._tokenize('-0x800000001'))
152 with self.assertRaisesRegex(parser.ParseException, 'signed underflow'):
153 self.parser.parse_value(self._tokenize('-0x8000000000000001'))
158 self.parser.parse_value(self._tokenize('0x1|0x2|0x4|0x8')), 0xf)
173 with self.assertRaises(parser.ParseException, msg=expression):
174 self.parser.parse_value(self._tokenize(expression))
183 self.parser.parse_value(tokens)
197 self.parser.parse_value(self._tokenize(expression)), 3)
202 self.parser.parse_value(self._tokenize('~0')),
205 self.parser.parse_value(self._tokenize('~0|~0')),
209 self.parser.parse_value(
212 self.parser.parse_value(
217 self.parser.parse_value(
221 self.parser.parse_value(
228 with self.assertRaisesRegex(parser.ParseException,
230 self.parser.parse_value(self._tokenize('~~0'))
234 with self.assertRaisesRegex(parser.ParseException, 'empty complement'):
235 self.parser.parse_value(self._tokenize('0|~'))
240 self.parser.parse_value(self._tokenize('O_RDONLY')), 0)
244 with self.assertRaisesRegex(parser.ParseException, 'empty constant'):
245 self.parser.parse_value([])
246 with self.assertRaisesRegex(parser.ParseException, 'empty constant'):
247 self.parser.parse_value(self._tokenize('0|'))
251 with self.assertRaisesRegex(parser.ParseException, 'invalid constant'):
252 self.parser.parse_value(self._tokenize('foo'))
260 self.parser = parser.PolicyParser(
265 return list(self.parser._parser_state.tokenize([line]))[0]
270 self.parser.parse_argument_expression(
274 [parser.Atom(0, 'in', 0xffff)],
275 [parser.Atom(0, '==', 4),
276 parser.Atom(1, '==', 2)],
283 self.parser.parse_argument_expression(
285 [parser.Atom(0, 'in', 4607)],
289 self.parser.parse_argument_expression(
291 [parser.Atom(0, 'in', 4607)],
295 self.parser.parse_argument_expression(
297 [parser.Atom(0, 'in', 4607)],
302 with self.assertRaisesRegex(parser.ParseException,
304 self.parser.parse_argument_expression(
309 with self.assertRaisesRegex(parser.ParseException, 'empty clause'):
310 self.parser.parse_argument_expression(
315 with self.assertRaisesRegex(parser.ParseException, 'invalid argument'):
316 self.parser.parse_argument_expression(
321 with self.assertRaisesRegex(parser.ParseException, 'invalid operator'):
322 self.parser.parse_argument_expression(
327 with self.assertRaisesRegex(parser.ParseException, 'missing operator'):
328 self.parser.parse_argument_expression(self._tokenize('arg0'))
332 with self.assertRaisesRegex(parser.ParseException, 'empty constant'):
333 self.parser.parse_argument_expression(self._tokenize('arg0 =='))
341 self.parser = parser.PolicyParser(
346 return list(self.parser._parser_state.tokenize([line]))[0]
351 self.parser.parse_filter(self._tokenize('arg0 == 0')), [
352 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
355 self.parser.parse_filter(self._tokenize('kill-process')), [
356 parser.Filter(None, bpf.KillProcess()),
359 self.parser.parse_filter(self._tokenize('kill-thread')), [
360 parser.Filter(None, bpf.KillThread()),
363 self.parser.parse_filter(self._tokenize('trap')), [
364 parser.Filter(None, bpf.Trap()),
367 self.parser.parse_filter(self._tokenize('return ENOSYS')), [
368 parser.Filter(None,
372 self.parser.parse_filter(self._tokenize('trace')), [
373 parser.Filter(None, bpf.Trace()),
376 self.parser.parse_filter(self._tokenize('user-notify')), [
377 parser.Filter(None, bpf.UserNotify()),
380 self.parser.parse_filter(self._tokenize('log')), [
381 parser.Filter(None, bpf.Log()),
384 self.parser.parse_filter(self._tokenize('allow')), [
385 parser.Filter(None, bpf.Allow()),
388 self.parser.parse_filter(self._tokenize('1')), [
389 parser.Filter(None, bpf.Allow()),
392 self.parser.parse_filter(
396 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
397 parser.Filter([[parser.Atom(0, '==', 1)]],
399 parser.Filter(None, bpf.Trap()),
404 with self.assertRaisesRegex(parser.ParseException,
406 self.parser.parse_filter(self._tokenize('return'))
410 with self.assertRaisesRegex(parser.ParseException, 'invalid constant'):
411 self.parser.parse_filter(self._tokenize('return arg0'))
415 with self.assertRaisesRegex(parser.ParseException, 'unclosed brace'):
416 self.parser.parse_filter(self._tokenize('{ allow'))
425 self.parser = parser.PolicyParser(
430 return list(self.parser._parser_state.tokenize([line]))[0]
435 self.parser.parse_filter(self._tokenize('arg0 == 0; return ENOSYS')),
437 parser.Filter([[parser.Atom(0, '==', 0)]],
447 self.parser = parser.PolicyParser(
452 return list(self.parser._parser_state.tokenize([line]))[0]
463 self.parser.parse_filter_statement(
465 parser.ParsedFilterStatement(
466 syscalls=(parser.Syscall('read', 0), ),
468 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
472 self.parser.parse_filter_statement(
474 parser.ParsedFilterStatement(
476 parser.Syscall('read', 0),
477 parser.Syscall('write', 1),
480 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
484 self.parser.parse_filter_statement(
486 parser.ParsedFilterStatement(
488 parser.Syscall('read', 0),
489 parser.Syscall('write', 1),
492 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
496 self.parser.parse_filter_statement(
498 parser.ParsedFilterStatement(
500 parser.Syscall('read', 0),
501 parser.Syscall('write', 1),
504 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
508 self.parser.parse_filter_statement(
510 parser.ParsedFilterStatement(
512 parser.Syscall('kill', 62),
515 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
522 self.parser.parse_filter_statement(
524 parser.ParsedFilterStatement(
526 parser.Syscall('read', 0),
529 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
533 self.parser.parse_filter_statement(
536 parser.ParsedFilterStatement(
538 parser.Syscall('read', 0),
541 parser.Filter([[parser.Atom(0, '==', 0)]], bpf.Allow()),
547 with self.assertRaisesRegex(parser.ParseException, 'unclosed brace'):
548 self.parser.parse_filter(self._tokenize('{ allow'))
552 with self.assertRaisesRegex(parser.ParseException, 'unclosed brace'):
553 self.parser.parse_filter_statement(
558 with self.assertRaisesRegex(parser.ParseException, 'missing colon'):
559 self.parser.parse_filter_statement(self._tokenize('read'))
563 with self.assertRaisesRegex(parser.ParseException, 'invalid colon'):
564 self.parser.parse_filter_statement(self._tokenize('read arg0'))
568 with self.assertRaisesRegex(parser.ParseException, 'missing filter'):
569 self.parser.parse_filter_statement(self._tokenize('read:'))
577 self.parser = parser.PolicyParser(
601 self.parser.parse_file(path),
602 parser.ParsedPolicy(
605 parser.FilterStatement(
606 syscall=parser.Syscall('read', 0),
609 parser.Filter(None, bpf.Allow()),
611 parser.FilterStatement(
612 syscall=parser.Syscall('write', 1),
615 parser.Filter(None, bpf.Allow()),
630 self.parser.parse_file(path),
631 parser.ParsedPolicy(
634 parser.FilterStatement(
635 syscall=parser.Syscall('read', 0),
638 parser.Filter(None, bpf.Allow()),
640 parser.FilterStatement(
641 syscall=parser.Syscall('write', 1),
644 parser.Filter(None, bpf.Allow()),
657 self.parser.parse_file(path),
658 parser.ParsedPolicy(
661 parser.FilterStatement(
662 syscall=parser.Syscall('read', 0),
665 parser.Filter(None, bpf.Allow()),
677 with self.assertRaisesRegex(parser.ParseException,
679 self.parser.parse_file(path)
690 self.parser.parse_file(path),
691 parser.ParsedPolicy(
694 parser.FilterStatement(
695 syscall=parser.Syscall('read', 0),
698 parser.Filter(None, bpf.Allow()),
700 parser.FilterStatement(
701 syscall=parser.Syscall('write', 1),
704 parser.Filter(None, bpf.Allow()),
718 self.parser.parse_file(path),
719 parser.ParsedPolicy(
722 parser.FilterStatement(
723 syscall=parser.Syscall('write', 1),
726 parser.Filter(None, bpf.Allow()),
743 self.parser.parse_file(path),
744 parser.ParsedPolicy(
747 parser.FilterStatement(
748 syscall=parser.Syscall('read', 0),
751 parser.Filter([[parser.Atom(0, '==', 0)]],
753 parser.Filter(
758 parser.FilterStatement(
759 syscall=parser.Syscall('write', 1),
762 parser.Filter([[parser.Atom(0, '==', 0)]],
764 parser.Filter(None, bpf.KillProcess()),
770 with self.assertRaisesRegex(parser.ParseException,
776 self.parser.parse_file(path)
778 with self.assertRaisesRegex(parser.ParseException,
784 self.parser.parse_file(path)
786 with self.assertRaisesRegex(parser.ParseException,
792 self.parser.parse_file(path)
794 with self.assertRaisesRegex(parser.ParseException,
800 self.parser.parse_file(path)
816 self.parser.parse_file(path),
817 parser.ParsedPolicy(
820 parser.FilterStatement(
821 syscall=parser.Syscall('read', 0),
824 parser.Filter(None, bpf.Allow()),
833 with self.assertRaisesRegex(parser.ParseException, r'missing colon'):
837 self.parser.parse_file(path)
839 with self.assertRaisesRegex(parser.ParseException, r'invalid colon'):
843 self.parser.parse_file(path)
845 with self.assertRaisesRegex(parser.ParseException, r'missing number'):
849 self.parser.parse_file(path)
851 with self.assertRaisesRegex(parser.ParseException, r'invalid number'):
855 self.parser.parse_file(path)
857 with self.assertRaisesRegex(parser.ParseException, r'invalid number'):
861 self.parser.parse_file(path)
863 with self.assertRaisesRegex(parser.ParseException,
869 self.parser.parse_file(path)
871 with self.assertRaisesRegex(parser.ParseException,
877 self.parser.parse_file(path)
879 with self.assertRaisesRegex(parser.ParseException,
885 self.parser.parse_file(path)
896 parser.ParseException,
900 self.parser.parse_file(path)
909 parser.ParseException,
913 self.parser.parse_file(path)
917 with self.assertRaisesRegex(parser.ParseException,
924 self.parser.parse_file(path)
933 self.parser = parser.PolicyParser(
958 self.parser.parse_file(path),
959 parser.ParsedPolicy(
962 parser.FilterStatement(
963 syscall=parser.Syscall('read', 0),
966 parser.Filter(None, bpf.ReturnErrno(
969 parser.FilterStatement(
970 syscall=parser.Syscall('write', 1),
973 parser.Filter(None, bpf.ReturnErrno(
989 self.parser.parse_file(path),
990 parser.ParsedPolicy(
993 parser.FilterStatement(
994 syscall=parser.Syscall('read', 0),
997 parser.Filter(None, bpf.ReturnErrno(
1000 parser.FilterStatement(
1001 syscall=parser.Syscall('write', 1),
1004 parser.Filter([[parser.Atom(0, '==', 0)]],
1006 parser.Filter(None, bpf.Allow()),
1013 with self.assertRaisesRegex(parser.ParseException,
1020 self.parser.parse_file(path)