diff --git a/unit_tests/bet/bet_4d/4D_MNI152_T1_2mm.nii.gz b/unit_tests/bet/bet_4d/4D_MNI152_T1_2mm.nii.gz
new file mode 100644
index 0000000000000000000000000000000000000000..f9dfc9e35225507db427f8be1f7a09c800d62894
--- /dev/null
+++ b/unit_tests/bet/bet_4d/4D_MNI152_T1_2mm.nii.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:810c9c57a2e716ef6220489545db9085d50e25105e63b6e397b575be75d68299
+size 2813852
diff --git a/unit_tests/bet/bet_4d/feedsRun b/unit_tests/bet/bet_4d/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..6374c26de1a6388452a159d12a444d5bba82f252
--- /dev/null
+++ b/unit_tests/bet/bet_4d/feedsRun
@@ -0,0 +1,32 @@
+#!/usr/bin/env fslpython
+"""
+test bet with 4D input file
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_4d():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ '4D_MNI152_T1_2mm.nii.gz',
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-F'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+ # the 4D option should create a mask, so make sure the file exists
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mask.nii.gz')) == True
+
+test_bet_4d()
diff --git a/unit_tests/bet/bet_A/feedsRun b/unit_tests/bet/bet_A/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..9ab9188929d82591c0940c28ebfd56c81b210099
--- /dev/null
+++ b/unit_tests/bet/bet_A/feedsRun
@@ -0,0 +1,41 @@
+#!/usr/bin/env fslpython
+"""
+test bet with -A option for bet2 and betsurf
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_A():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-A'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_inskull_mask.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_inskull_mesh.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_inskull_mesh.vtk')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mesh.vtk')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskin_mask.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskin_mesh.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskin_mesh.vtk')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskull_mask.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskull_mesh.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskull_mesh.vtk')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_skull_mask.nii.gz')) == True
+
+test_bet_A()
diff --git a/unit_tests/bet/bet_A2/T1.nii.gz b/unit_tests/bet/bet_A2/T1.nii.gz
new file mode 100755
index 0000000000000000000000000000000000000000..30fc4c274d9c028240ea0c4b022f46db9912b3d1
--- /dev/null
+++ b/unit_tests/bet/bet_A2/T1.nii.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65e5894cd3cda17dfc1f851b6ad904af0781e538a7bb14c280f28b650520fd49
+size 1729604
diff --git a/unit_tests/bet/bet_A2/T2.nii.gz b/unit_tests/bet/bet_A2/T2.nii.gz
new file mode 100755
index 0000000000000000000000000000000000000000..d8155f9c13e2f5d33999d9ea152459ae6fd98237
--- /dev/null
+++ b/unit_tests/bet/bet_A2/T2.nii.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:deb196bccf019cc822f5e3e7d2e3005532ebc4551c195c93c9601b3fdb8d71a7
+size 1764689
diff --git a/unit_tests/bet/bet_A2/feedsRun b/unit_tests/bet/bet_A2/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..6b31b99ce09cf57086d4f568beb2bc4aa8b90b5a
--- /dev/null
+++ b/unit_tests/bet/bet_A2/feedsRun
@@ -0,0 +1,43 @@
+#!/usr/bin/env fslpython
+"""
+test bet with -A2 option for bet2 and betsurf with a T2 added
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_A2():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ 'T1.nii.gz',
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-A2',
+ 'T2.nii.gz'
+
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_inskull_mask.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_inskull_mesh.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_inskull_mesh.vtk')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mesh.vtk')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskin_mask.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskin_mesh.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskin_mesh.vtk')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskull_mask.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskull_mesh.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_outskull_mesh.vtk')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_skull_mask.nii.gz')) == True
+
+test_bet_A2()
diff --git a/unit_tests/bet/bet_bias_and_neck_clean/feedsRun b/unit_tests/bet/bet_bias_and_neck_clean/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..7b0c6c6b7f1e3006f07b9990957eb592ded7e53e
--- /dev/null
+++ b/unit_tests/bet/bet_bias_and_neck_clean/feedsRun
@@ -0,0 +1,31 @@
+#!/usr/bin/env fslpython
+"""
+test bet with -B for bias field and neck clean
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_bias_and_neck_clean():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-B'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mask.nii.gz')) == True
+
+test_bet_bias_and_neck_clean()
diff --git a/unit_tests/bet/bet_custom_cog/feedsRun b/unit_tests/bet/bet_custom_cog/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..e4befee6d43c495f1759ce747c8ad5222ded81c2
--- /dev/null
+++ b/unit_tests/bet/bet_custom_cog/feedsRun
@@ -0,0 +1,33 @@
+#!/usr/bin/env fslpython
+"""
+test bet with custom cog value
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_custom_cog():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-c',
+ '90',
+ '113',
+ '112'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_custom_cog()
diff --git a/unit_tests/bet/bet_custom_f/feedsRun b/unit_tests/bet/bet_custom_f/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..f75d2c3168be4b0d99df385b9f6e70a31972f408
--- /dev/null
+++ b/unit_tests/bet/bet_custom_f/feedsRun
@@ -0,0 +1,50 @@
+#!/usr/bin/env fslpython
+"""
+test bet with custom -f value
+"""
+from subprocess import run, PIPE, CalledProcessError
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+def test_bet_custom_f():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-f',
+ '0.3'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+def test_bet_negative_f():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-f',
+ '-0.3'
+ ]
+ try:
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ assert False
+ except CalledProcessError as e:
+ # a negative f value is BAD. error code should be > 0 since bet2 should fail.
+ print("test_bet_negative_f correctly failed. This is good! negative -f values are not to be used with bet")
+ assert e.returncode != 0
+
+print("running test_bet_custom_f()")
+test_bet_custom_f()
+print("running test_bet_negative_f()")
+test_bet_negative_f()
diff --git a/unit_tests/bet/bet_custom_radius/feedsRun b/unit_tests/bet/bet_custom_radius/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..aac0e1e2b8284b09cf8b863d1d272cd88ed40222
--- /dev/null
+++ b/unit_tests/bet/bet_custom_radius/feedsRun
@@ -0,0 +1,31 @@
+#!/usr/bin/env fslpython
+"""
+test bet with custom radius option
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_custom_radius():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-r',
+ '50'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_custom_radius()
diff --git a/unit_tests/bet/bet_eye_clean/feedsRun b/unit_tests/bet/bet_eye_clean/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..2f47ea931a3ab39bee2eb650a43e69271f45e812
--- /dev/null
+++ b/unit_tests/bet/bet_eye_clean/feedsRun
@@ -0,0 +1,32 @@
+#!/usr/bin/env fslpython
+"""
+test bet with -S for eye cleanup
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_eye_clean():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-S'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mask.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_skull.nii.gz')) == True
+
+test_bet_eye_clean()
diff --git a/unit_tests/bet/bet_mask_only/feedsRun b/unit_tests/bet/bet_mask_only/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..b6faf73a03b6f4fe5c2f701be00ad9fce38755a4
--- /dev/null
+++ b/unit_tests/bet/bet_mask_only/feedsRun
@@ -0,0 +1,33 @@
+#!/usr/bin/env fslpython
+"""
+test bet with the -n and -m option combo
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_mask_only():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-n',
+ '-m'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the mask file should be made in this case
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mask.nii.gz')) == True
+ # however, the brain extracted input should NOT exist (we only requested the mask)
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == False
+
+test_bet_mask_only()
diff --git a/unit_tests/bet/bet_negative_gradient/feedsRun b/unit_tests/bet/bet_negative_gradient/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..901ef0c6fce87f422caa31df813fe0efba90b8e6
--- /dev/null
+++ b/unit_tests/bet/bet_negative_gradient/feedsRun
@@ -0,0 +1,31 @@
+#!/usr/bin/env fslpython
+"""
+test bet with negative gradient option
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_negative_gradient():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-g',
+ '-0.5'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_negative_gradient()
diff --git a/unit_tests/bet/bet_no_images/feedsRun b/unit_tests/bet/bet_no_images/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..84283ed2577ed49e577e63dde883395f1e21a266
--- /dev/null
+++ b/unit_tests/bet/bet_no_images/feedsRun
@@ -0,0 +1,30 @@
+#!/usr/bin/env fslpython
+"""
+test bet with -n option (will produce no images)
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_no_images():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-n'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should NOT exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == False
+
+test_bet_no_images()
diff --git a/unit_tests/bet/bet_positive_gradient/feedsRun b/unit_tests/bet/bet_positive_gradient/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..c57277b335576fdc6d890ac38b6276682a9cfab7
--- /dev/null
+++ b/unit_tests/bet/bet_positive_gradient/feedsRun
@@ -0,0 +1,31 @@
+#!/usr/bin/env fslpython
+"""
+test bet with poitive gradient option
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_positive_gradient():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-g',
+ '0.5'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_positive_gradient()
diff --git a/unit_tests/bet/bet_robust/feedsRun b/unit_tests/bet/bet_robust/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..bf073fbbc75ca2c4690aab9aabf2f5a735059374
--- /dev/null
+++ b/unit_tests/bet/bet_robust/feedsRun
@@ -0,0 +1,30 @@
+#!/usr/bin/env fslpython
+"""
+test bet with -R robust option
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_robust():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-R'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_robust()
diff --git a/unit_tests/bet/bet_simple/feedsRun b/unit_tests/bet/bet_simple/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..88c5dc1917511ea0c662f39e515d24420342ecea
--- /dev/null
+++ b/unit_tests/bet/bet_simple/feedsRun
@@ -0,0 +1,29 @@
+#!/usr/bin/env fslpython
+"""
+test bet with no options
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_simple():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz')
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_simple()
diff --git a/unit_tests/bet/bet_surface_mesh/feedsRun b/unit_tests/bet/bet_surface_mesh/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..22e8d2216a39da710dbf99e847a53f2f0ddac617
--- /dev/null
+++ b/unit_tests/bet/bet_surface_mesh/feedsRun
@@ -0,0 +1,31 @@
+#!/usr/bin/env fslpython
+"""
+test bet with the -e option to produce the surface mesh
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_surface_mesh():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-e'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mesh.vtk')) == True
+
+test_bet_surface_mesh()
diff --git a/unit_tests/bet/bet_with_mask/feedsRun b/unit_tests/bet/bet_with_mask/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..d3a8b928d4b0578d52b643446199ec45afd03fa9
--- /dev/null
+++ b/unit_tests/bet/bet_with_mask/feedsRun
@@ -0,0 +1,32 @@
+#!/usr/bin/env fslpython
+"""
+test bet with the -m combo to produce a mask file and the betted file
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_with_mask():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-m'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the mask file should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mask.nii.gz')) == True
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_with_mask()
diff --git a/unit_tests/bet/bet_with_mask_and_skull/feedsRun b/unit_tests/bet/bet_with_mask_and_skull/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..4930bc68c570501d9e6b65196e6a3948b0b1f14e
--- /dev/null
+++ b/unit_tests/bet/bet_with_mask_and_skull/feedsRun
@@ -0,0 +1,35 @@
+#!/usr/bin/env fslpython
+"""
+test bet with the -m -s combo to produce a mask file and the betted file, and the skull file
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_with_mask_and_skull():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-m',
+ '-s'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the mask file should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mask.nii.gz')) == True
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+ # the skull image should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test_skull.nii.gz')) == True
+
+test_bet_with_mask_and_skull()
diff --git a/unit_tests/bet/bet_with_overlay/feedsRun b/unit_tests/bet/bet_with_overlay/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..11c4267a1e274b9bcd954f07793c2a30a0968346
--- /dev/null
+++ b/unit_tests/bet/bet_with_overlay/feedsRun
@@ -0,0 +1,32 @@
+#!/usr/bin/env fslpython
+"""
+test bet with the -o option for overlay
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_with_overlay():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-o'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the overlay file should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test_overlay.nii.gz')) == True
+ # the betted file should have been made
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_with_overlay()
diff --git a/unit_tests/bet/bet_with_skull/feedsRun b/unit_tests/bet/bet_with_skull/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..4e32e34415b16ee4b917457c5b71ee5d5ddf785b
--- /dev/null
+++ b/unit_tests/bet/bet_with_skull/feedsRun
@@ -0,0 +1,32 @@
+#!/usr/bin/env fslpython
+"""
+test bet with the -s option to produce the skull file
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_with_skull():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-s'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+ # the skull image should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test_skull.nii.gz')) == True
+
+test_bet_with_skull()
diff --git a/unit_tests/bet/bet_with_thresholding/feedsRun b/unit_tests/bet/bet_with_thresholding/feedsRun
new file mode 100755
index 0000000000000000000000000000000000000000..265b02f30cfbc01ba25270c8f05698c63a0019d0
--- /dev/null
+++ b/unit_tests/bet/bet_with_thresholding/feedsRun
@@ -0,0 +1,33 @@
+#!/usr/bin/env fslpython
+"""
+test bet with the -t threshold option
+"""
+from subprocess import run, PIPE
+from os.path import join
+from tempfile import mkdtemp
+import os
+import sys
+
+OUTDIR = sys.argv[1]
+INDIR = sys.argv[2]
+FSLDIR = os.environ.get('FSLDIR')
+FSLBIN = join(FSLDIR, 'bin')
+
+
+def test_bet_with_mask_and_thresholding():
+ cmd = [
+ join(FSLBIN, 'bet'),
+ join(FSLDIR, 'data', 'standard', 'MNI152_T1_1mm.nii.gz'),
+ join(OUTDIR, 'bet_test.nii.gz'),
+ '-m',
+ '-t'
+ ]
+ run_result = run(cmd, stdout=PIPE, check=True)
+ stdout_string = run_result.stdout.decode('utf-8')
+ # check that the files were written to disk
+ # the mask file should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test_mask.nii.gz')) == True
+ # the brain extracted input should exist
+ assert os.path.isfile(join(OUTDIR, 'bet_test.nii.gz')) == True
+
+test_bet_with_mask_and_thresholding()