diff --git a/tests/PythonTest.sh b/tests/PythonTest.sh
index ebe49bf..00772ea 100755
--- a/tests/PythonTest.sh
+++ b/tests/PythonTest.sh
@@ -21,6 +21,8 @@
 
 # Emit Python code for the example schema in the test dir:
 ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_test.fbs --gen-object-api
+${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_test.fbs --gen-object-api --gen-onefile
+${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_extra.fbs --gen-object-api
 
 # Syntax: run_tests <interpreter> <benchmark vtable dedupes>
 #                   <benchmark read count> <benchmark build count>
@@ -34,7 +36,7 @@
     JYTHONPATH=${runtime_library_dir}:${gen_code_path} \
     COMPARE_GENERATED_TO_GO=0 \
     COMPARE_GENERATED_TO_JAVA=0 \
-    $1 py_test.py $2 $3 $4
+    $1 py_test.py $2 $3 $4 $5
     if [ $1 = python3 ]; then
       PYTHONDONTWRITEBYTECODE=1 \
       PYTHONPATH=${runtime_library_dir}:${gen_code_path} \
@@ -46,10 +48,12 @@
 }
 
 # Run test suite with these interpreters. The arguments are benchmark counts.
-run_tests python2.6 100 100 100
-run_tests python2.7 100 100 100
-run_tests python3 100 100 100
-run_tests pypy 100 100 100
+run_tests python2.6 100 100 100 false
+run_tests python2.7 100 100 100 false
+run_tests python2.7 100 100 100 true
+run_tests python3 100 100 100 false
+run_tests python3 100 100 100 true
+run_tests pypy 100 100 100 false
 
 # NOTE: We'd like to support python2.5 in the future.
 
