]>
git.proxmox.com Git - mirror_frr.git/blob - tests/topotests/bgp_prefix_list_topo1/test_prefix_lists.py
2 # SPDX-License-Identifier: ISC
5 # Copyright (c) 2019 by VMware, Inc. ("VMware")
6 # Used Copyright (c) 2018 by Network Device Education Foundation,
7 # Inc. ("NetDEF") in this file.
11 Following tests are covered to test prefix-list functionality:
14 - Create topology (setup module)
15 Creating 4 routers topology, r1, r2, r3 are in IBGP and
18 - Verify for bgp to converge
21 - Test ip prefix-lists IN permit
22 - Test ip prefix-lists OUT permit
23 - Test ip prefix-lists IN deny and permit any
24 - Test delete ip prefix-lists
25 - Test ip prefix-lists OUT deny and permit any
26 - Test modify ip prefix-lists IN permit to deny
27 - Test modify ip prefix-lists IN deny to permit
28 - Test modify ip prefix-lists OUT permit to deny
29 - Test modify prefix-lists OUT deny to permit
30 - Test ip prefix-lists implicit deny
38 # Save the Current Working Directory to find configuration files.
39 CWD
= os
.path
.dirname(os
.path
.realpath(__file__
))
40 sys
.path
.append(os
.path
.join(CWD
, "../"))
42 # pylint: disable=C0413
43 # Import topogen and topotest helpers
44 from lib
.topogen
import Topogen
, get_topogen
46 # Import topoJson from lib, to create topology and initial configuration
47 from lib
.common_config
import (
51 reset_config_on_routers
,
57 from lib
.topolog
import logger
58 from lib
.bgp
import verify_bgp_convergence
, create_router_bgp
, clear_bgp_and_verify
59 from lib
.topojson
import build_config_from_json
62 pytestmark
= [pytest
.mark
.bgpd
]
66 bgp_convergence
= False
69 def setup_module(mod
):
71 Sets up the pytest environment
76 testsuite_run_time
= time
.asctime(time
.localtime(time
.time()))
77 logger
.info("Testsuite start time: {}".format(testsuite_run_time
))
80 logger
.info("Running setup_module to create topology")
82 # This function initiates the topology build with Topogen...
83 json_file
= "{}/prefix_lists.json".format(CWD
)
84 tgen
= Topogen(json_file
, mod
.__name
__)
87 # ... and here it calls Mininet initialization functions.
89 # Starting topology, create tmp files which are loaded to routers
90 # to start daemons and then start routers
93 # Creating configuration from JSON
94 build_config_from_json(tgen
, topo
)
96 # Checking BGP convergence
97 global BGP_CONVERGENCE
99 # Don't run this test if we have any failure.
100 if tgen
.routers_have_failure():
101 pytest
.skip(tgen
.errors
)
103 # Api call verify whether BGP is converged
104 BGP_CONVERGENCE
= verify_bgp_convergence(tgen
, topo
)
105 assert BGP_CONVERGENCE
is True, "setup_module :Failed \n Error:" " {}".format(
109 logger
.info("Running setup_module() done")
112 def teardown_module(mod
):
114 Teardown the pytest environment
119 logger
.info("Running teardown_module to delete topology")
123 # Stop toplogy and Remove tmp files
127 "Testsuite end time: {}".format(time
.asctime(time
.localtime(time
.time())))
129 logger
.info("=" * 40)
132 #####################################################
136 #####################################################
139 def test_ip_prefix_lists_in_permit(request
):
141 Create ip prefix list and test permit prefixes IN direction
145 if BGP_CONVERGENCE
is not True:
146 pytest
.skip("skipped because of BGP Convergence failure")
149 tc_name
= request
.node
.name
150 write_test_header(tc_name
)
152 # Create Static routes
156 {"network": "20.0.20.1/32", "no_of_ip": 1, "next_hop": "10.0.0.2"}
160 result
= create_static_routes(tgen
, input_dict
)
161 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
163 # Create ip prefix list
168 "pf_list_1": [{"seqid": 10, "network": "any", "action": "permit"}]
173 result
= create_prefix_lists(tgen
, input_dict_2
)
174 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
176 # Configure bgp neighbor with prefix list
184 {"redist_type": "static"},
185 {"redist_type": "connected"},
202 {"name": "pf_list_1", "direction": "in"}
214 result
= create_router_bgp(tgen
, topo
, input_dict_3
)
215 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
217 # Verifying RIB routes
220 result
= verify_rib(tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
)
221 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
223 write_test_footer(tc_name
)
226 def test_ip_prefix_lists_out_permit(request
):
228 Create ip prefix list and test permit prefixes out direction
232 if BGP_CONVERGENCE
is not True:
233 pytest
.skip("skipped because of BGP Convergence failure")
236 tc_name
= request
.node
.name
237 write_test_header(tc_name
)
239 # Creating configuration from JSON
240 reset_config_on_routers(tgen
)
242 # Create Static routes
246 {"network": "10.0.20.1/32", "no_of_ip": 1, "next_hop": "10.0.0.2"}
250 result
= create_static_routes(tgen
, input_dict
)
251 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
253 # Create Static routes
257 {"network": "20.0.20.1/32", "no_of_ip": 1, "next_hop": "10.0.0.2"}
261 result
= create_static_routes(tgen
, input_dict_1
)
262 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
267 {"network": "10.0.0.2/30", "no_of_ip": 1, "next_hop": "10.0.0.9"}
271 result
= create_static_routes(tgen
, input_dict_5
)
272 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
274 # Api call to redistribute static routes
276 # Create ip prefix list
282 {"seqid": 10, "network": "20.0.20.1/32", "action": "permit"}
288 result
= create_prefix_lists(tgen
, input_dict_2
)
289 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
291 # Configure prefix list to bgp neighbor
292 # Configure bgp neighbor with prefix list
314 {"redist_type": "static"},
315 {"redist_type": "connected"},
324 result
= create_router_bgp(tgen
, topo
, input_dict_3
)
325 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
327 # Verifying RIB routes
330 result
= verify_rib(tgen
, "ipv4", dut
, input_dict_1
, protocol
=protocol
)
331 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
334 tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
, expected
=False
336 assert result
is not True, (
337 "Testcase {} : Failed \n "
338 "Expected: Routes should not be present in {} FIB \n "
339 "Found: {}".format(tc_name
, dut
, result
)
342 write_test_footer(tc_name
)
345 def test_ip_prefix_lists_in_deny_and_permit_any(request
):
347 Create ip prefix list and test permit/deny prefixes IN direction
351 if BGP_CONVERGENCE
is not True:
352 pytest
.skip("skipped because of BGP Convergence failure")
355 tc_name
= request
.node
.name
356 write_test_header(tc_name
)
358 # Creating configuration from JSON
359 reset_config_on_routers(tgen
)
361 # Create Static Routes
365 {"network": "10.0.20.1/32", "no_of_ip": 1, "next_hop": "10.0.0.2"}
369 result
= create_static_routes(tgen
, input_dict
)
370 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
372 # Api call to redistribute static routes
373 # Create ip prefix list
379 {"seqid": "10", "network": "10.0.20.1/32", "action": "deny"},
380 {"seqid": "11", "network": "any", "action": "permit"},
386 result
= create_prefix_lists(tgen
, input_dict_2
)
387 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
389 # Configure bgp neighbor with prefix list
397 {"redist_type": "static"},
398 {"redist_type": "connected"},
415 {"name": "pf_list_1", "direction": "in"}
427 # Configure prefix list to bgp neighbor
428 result
= create_router_bgp(tgen
, topo
, input_dict_3
)
429 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
431 # Verifying RIB routes
435 tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
, expected
=False
437 assert result
is not True, (
438 "Testcase {} : Failed \n "
439 "Expected: Routes should not be present in {} BGP RIB \n "
440 "Found: {}".format(tc_name
, dut
, result
)
443 write_test_footer(tc_name
)
446 def test_delete_prefix_lists(request
):
448 Delete ip prefix list
452 if BGP_CONVERGENCE
is not True:
453 pytest
.skip("skipped because of BGP Convergence failure")
456 tc_name
= request
.node
.name
457 write_test_header(tc_name
)
459 # Creating configuration from JSON
460 reset_config_on_routers(tgen
)
462 # Create ip prefix list
468 {"seqid": "10", "network": "10.0.20.1/32", "action": "deny"}
474 result
= create_prefix_lists(tgen
, input_dict_2
)
475 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
477 result
= verify_prefix_lists(tgen
, input_dict_2
)
478 assert result
is not True, "Testcase {} : Failed \n Error: {}".format(
490 "network": "10.0.20.1/32",
499 result
= create_prefix_lists(tgen
, input_dict_2
)
500 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
502 result
= verify_prefix_lists(tgen
, input_dict_2
)
503 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
505 write_test_footer(tc_name
)
508 def test_ip_prefix_lists_out_deny_and_permit_any(request
):
510 Create ip prefix list and test deny/permit any prefixes OUT direction
514 if BGP_CONVERGENCE
is not True:
515 pytest
.skip("skipped because of BGP Convergence failure")
518 tc_name
= request
.node
.name
519 write_test_header(tc_name
)
521 # Creating configuration from JSON
522 reset_config_on_routers(tgen
)
524 # Create Static Routes
528 {"network": "10.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.2"}
532 result
= create_static_routes(tgen
, input_dict
)
533 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
535 # Create Static Routes
539 {"network": "20.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.1"}
543 result
= create_static_routes(tgen
, input_dict_1
)
544 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
546 # Api call to redistribute static routes
548 # Create ip prefix list
556 "network": "10.0.0.0/8",
560 {"seqid": "11", "network": "any", "action": "permit"},
566 result
= create_prefix_lists(tgen
, input_dict_3
)
567 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
569 # Configure prefix list to bgp neighbor
577 {"redist_type": "static"},
578 {"redist_type": "connected"},
591 {"redist_type": "static"},
592 {"redist_type": "connected"},
624 result
= create_router_bgp(tgen
, topo
, input_dict_4
)
625 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
627 # Verifying RIB routes
630 result
= verify_rib(tgen
, "ipv4", dut
, input_dict_1
, protocol
=protocol
)
631 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
633 # Verifying RIB routes
637 tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
, expected
=False
639 assert result
is not True, (
640 "Testcase {} : Failed \n "
641 "Expected: Routes should not be present in {} BGP RIB \n "
642 "Found: {}".format(tc_name
, dut
, result
)
645 write_test_footer(tc_name
)
648 def test_modify_prefix_lists_in_permit_to_deny(request
):
650 Modify ip prefix list and test permit to deny prefixes IN direction
654 if BGP_CONVERGENCE
is not True:
655 pytest
.skip("skipped because of BGP Convergence failure")
658 tc_name
= request
.node
.name
659 write_test_header(tc_name
)
661 # Creating configuration from JSON
662 reset_config_on_routers(tgen
)
664 # Create Static Routes
668 {"network": "10.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.2"}
672 result
= create_static_routes(tgen
, input_dict
)
673 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
675 # Api call to redistribute static routes
677 # Create ip prefix list
685 "network": "10.0.0.0/8",
694 result
= create_prefix_lists(tgen
, input_dict_2
)
695 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
697 # Configure prefix list to bgp neighbor
705 {"redist_type": "static"},
706 {"redist_type": "connected"},
723 {"name": "pf_list_1", "direction": "in"}
735 result
= create_router_bgp(tgen
, topo
, input_dict_3
)
736 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
738 # Verifying RIB routes
741 result
= verify_rib(tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
)
742 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
752 "network": "10.0.0.0/8",
756 {"seqid": "11", "network": "any", "action": "permit"},
762 result
= create_prefix_lists(tgen
, input_dict_1
)
763 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
765 # Api call to clear bgp, so config changes would be reflected
767 result
= clear_bgp_and_verify(tgen
, topo
, dut
)
768 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
770 # Verifying RIB routes
774 tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
, expected
=False
776 assert result
is not True, (
777 "Testcase {} : Failed \n "
778 "Expected: Routes should not be present in {} BGP RIB \n "
779 "Found: {}".format(tc_name
, dut
, result
)
782 write_test_footer(tc_name
)
785 def test_modify_prefix_lists_in_deny_to_permit(request
):
787 Modify ip prefix list and test deny to permit prefixes IN direction
791 if BGP_CONVERGENCE
is not True:
792 pytest
.skip("skipped because of BGP Convergence failure")
795 tc_name
= request
.node
.name
796 write_test_header(tc_name
)
798 # Creating configuration from JSON
799 reset_config_on_routers(tgen
)
801 # Create Static Routes
805 {"network": "10.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.2"}
809 result
= create_static_routes(tgen
, input_dict
)
810 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
812 # Api call to redistribute static routes
814 # Create ip prefix list
822 "network": "10.0.0.0/8",
826 {"seqid": "11", "network": "any", "action": "permit"},
832 result
= create_prefix_lists(tgen
, input_dict_1
)
833 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
835 # Configure prefix list to bgp neighbor
843 {"redist_type": "static"},
844 {"redist_type": "connected"},
861 {"name": "pf_list_1", "direction": "in"}
873 result
= create_router_bgp(tgen
, topo
, input_dict_2
)
874 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
876 # Verifying RIB routes
880 tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
, expected
=False
882 assert result
is not True, (
883 "Testcase {} : Failed \n "
884 "Expected: Routes should not be present in {} BGP RIB \n "
885 "Found: {}".format(tc_name
, dut
, result
)
888 # Modify ip prefix list
896 "network": "10.0.0.0/8",
905 result
= create_prefix_lists(tgen
, input_dict_1
)
906 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
908 # Api call to clear bgp, so config changes would be reflected
910 result
= clear_bgp_and_verify(tgen
, topo
, dut
)
911 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
913 # Verifying RIB routes
916 result
= verify_rib(tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
)
917 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
919 write_test_footer(tc_name
)
922 def test_modify_prefix_lists_out_permit_to_deny(request
):
924 Modify ip prefix list and test permit to deny prefixes OUT direction
928 if BGP_CONVERGENCE
is not True:
929 pytest
.skip("skipped because of BGP Convergence failure")
932 tc_name
= request
.node
.name
933 write_test_header(tc_name
)
935 # Creating configuration from JSON
936 reset_config_on_routers(tgen
)
938 # Create Static Routes
942 {"network": "10.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.2"}
946 result
= create_static_routes(tgen
, input_dict
)
947 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
949 # Api call to redistribute static routes
951 # Create ip prefix list
959 "network": "10.0.0.0/8",
968 result
= create_prefix_lists(tgen
, input_dict_1
)
969 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
971 # Configure prefix list to bgp neighbor
979 {"redist_type": "static"},
980 {"redist_type": "connected"},
1012 result
= create_router_bgp(tgen
, topo
, input_dict_2
)
1013 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1015 # Verifying RIB routes
1018 result
= verify_rib(tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
)
1019 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1021 # Modify ip prefix list
1029 "network": "10.0.0.0/8",
1033 {"seqid": "11", "network": "any", "action": "permit"},
1039 result
= create_prefix_lists(tgen
, input_dict_1
)
1040 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1042 # Api call to clear bgp, so config changes would be reflected
1044 result
= clear_bgp_and_verify(tgen
, topo
, dut
)
1045 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1047 # Verifying RIB routes
1050 result
= verify_rib(
1051 tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
, expected
=False
1053 assert result
is not True, (
1054 "Testcase {} : Failed \n "
1055 "Expected: Routes should not be present in {} BGP RIB \n "
1056 "Found: {}".format(tc_name
, dut
, result
)
1059 write_test_footer(tc_name
)
1062 def test_modify_prefix_lists_out_deny_to_permit(request
):
1064 Modify ip prefix list and test deny to permit prefixes OUT direction
1067 tgen
= get_topogen()
1068 if BGP_CONVERGENCE
is not True:
1069 pytest
.skip("skipped because of BGP Convergence failure")
1072 tc_name
= request
.node
.name
1073 write_test_header(tc_name
)
1075 # Creating configuration from JSON
1076 reset_config_on_routers(tgen
)
1078 # Create Static Routes
1082 {"network": "10.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.2"}
1086 result
= create_static_routes(tgen
, input_dict
)
1087 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1089 # Api call to redistribute static routes
1090 # Create ip prefix list
1098 "network": "10.0.0.0/8",
1102 {"seqid": "11", "network": "any", "action": "permit"},
1108 result
= create_prefix_lists(tgen
, input_dict_1
)
1109 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1111 # Configure prefix list to bgp neighbor
1119 {"redist_type": "static"},
1120 {"redist_type": "connected"},
1138 "name": "pf_list_1",
1152 result
= create_router_bgp(tgen
, topo
, input_dict_2
)
1153 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1155 # Verifying RIB routes
1158 result
= verify_rib(
1159 tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
, expected
=False
1161 assert result
is not True, (
1162 "Testcase {} : Failed \n "
1163 "Expected: Routes should not be present in {} BGP RIB \n "
1164 "Found: {}".format(tc_name
, dut
, result
)
1167 # Modify ip prefix list
1175 "network": "10.0.0.0/8",
1184 result
= create_prefix_lists(tgen
, input_dict_1
)
1185 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1187 # Api call to clear bgp, so config changes would be reflected
1189 result
= clear_bgp_and_verify(tgen
, topo
, dut
)
1190 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1192 # Verifying RIB routes
1195 result
= verify_rib(tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
)
1196 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1198 write_test_footer(tc_name
)
1201 def test_ip_prefix_lists_implicit_deny(request
):
1203 Create ip prefix list and test implicit deny
1206 tgen
= get_topogen()
1207 if BGP_CONVERGENCE
is not True:
1208 pytest
.skip("skipped because of BGP Convergence failure")
1211 tc_name
= request
.node
.name
1212 write_test_header(tc_name
)
1214 # Creating configuration from JSON
1215 reset_config_on_routers(tgen
)
1217 # Create Static Routes
1221 {"network": "10.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.2"}
1225 result
= create_static_routes(tgen
, input_dict
)
1226 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1228 # Create Static Routes
1232 {"network": "20.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.1"}
1236 result
= create_static_routes(tgen
, input_dict
)
1237 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1239 # Api call to redistribute static routes
1240 # Create ip prefix list
1248 "network": "10.0.0.0/8",
1257 result
= create_prefix_lists(tgen
, input_dict_3
)
1258 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1260 # Configure prefix list to bgp neighbor
1268 {"redist_type": "static"},
1269 {"redist_type": "connected"},
1282 {"redist_type": "static"},
1283 {"redist_type": "connected"},
1301 "name": "pf_list_1",
1315 result
= create_router_bgp(tgen
, topo
, input_dict_4
)
1316 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1318 # Verifying RIB routes
1321 result
= verify_rib(tgen
, "ipv4", dut
, input_dict
, protocol
=protocol
)
1322 assert result
is True, "Testcase {} : Failed \n Error: {}".format(tc_name
, result
)
1324 # Verifying RIB routes
1327 result
= verify_rib(
1328 tgen
, "ipv4", dut
, input_dict_1
, protocol
=protocol
, expected
=False
1330 assert result
is not True, (
1331 "Testcase {} : Failed \n "
1332 "Expected: Routes should not be present in {} BGP RIB \n "
1333 "Found: {}".format(tc_name
, dut
, result
)
1336 write_test_footer(tc_name
)
1339 if __name__
== "__main__":
1340 args
= ["-s"] + sys
.argv
[1:]
1341 sys
.exit(pytest
.main(args
))