Python unittest C / Fortran MPI functions resultando na função MPI_Init sendo chamada após MPI_finalize

Estou escrevendo wrappers Python para uma biblioteca Fortran que usa MPI (OpenMPI, se for relevante). O problema que menciono aqui também ocorre exatamente para wrappers Python para bibliotecas C. Devo usar o unittestpacote Python embutido para testar a interface Python.

Eu tenho o seguinte MWE que tenta encontrar inteiro máximo e mínimo em todos os processadores. Este é o arquivo Fortran:

! File mpitest.F90
module mpitest
    implicit none
    include "mpif.h"
    integer nranks
    integer rank

    contains

    !--------------------------------------------------!
    subroutine pympitest_init()
        implicit none
        integer ierror
        call MPI_INIT(ierror)
        call MPI_COMM_SIZE(MPI_COMM_WORLD, nranks, ierror)
        call MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierror)
    end subroutine pympitest_init

    !--------------------------------------------------!
    subroutine get_max_integer(inint, outint)
        implicit none
        integer, intent(in) :: inint
        integer, intent(out) :: outint
        integer ierror
        call mpi_allreduce(inint,outint,1,mpi_integer,mpi_max,MPI_COMM_WORLD,ierror)
    end subroutine get_max_integer

    !--------------------------------------------------!
    subroutine get_min_integer(inint, outint)
        implicit none
        integer, intent(in) :: inint
        integer, intent(out) :: outint
        integer ierror
        call mpi_allreduce(inint,outint,1,mpi_integer,mpi_min,MPI_COMM_WORLD,ierror)
    end subroutine get_min_integer

    !--------------------------------------------------!
    subroutine pympitest_final()
        integer ierror
        call mpi_finalize(ierror)
    end subroutine pympitest_final

end module mpitest

O arquivo de teste de unidade Python é fornecido abaixo, com algumas coisas que tentei, mas não ajudei a colocar como comentários:

#!/usr/bin/env python3
# Python file test_pympitest.py
from __future__ import print_function
import unittest
import numpy as np

from pympitest import mpitest as pm

#--------------------------------------------------------------------#
class Test_Fortran_MPI_functions(unittest.TestCase):
    """Unit test template for testing MPI functions."""

    #----------------------------------------------------------------#
    #def __init__(self):
    #    """Try MPI_Initialize -- Does not help."""
    #    print("Initializing MPI")
    #    pm.pympitest_init()

    #----------------------------------------------------------------#
    #def tearDown(self):
    #    """Try MPI_Finalize -- Does not help."""
    #    print("Finalizing MPI")
    #    pm.pympitest_final()

    #----------------------------------------------------------------#
    def setUp(self):
        """Initialize the unit test."""
        print("Initializing MPI")
        pm.pympitest_init()

        # We'll just test min. and max. of ranks across all PEs.
        self.inint = pm.rank

    #----------------------------------------------------------------#
    def tearDown(self):
        """Finalize the unit test."""
        print("Finalizing MPI")
        pm.pympitest_final()

    #----------------------------------------------------------------#
    #----------------------------------------------------------------#
    # Two Tests. If you comment out any one of the tests, then the
    # unit test runs fine. Keeping both uncommented thorws error
    # saying MPI_Init was called after MPI_Final, obviously since
    # the setUp and tearDown functions are called every time.
    #----------------------------------------------------------------#
    def test_get_min_integer(self):
        """Test get_min_integer function."""
        minint = pm.get_min_integer(self.inint)
        print("Minimum on processor {} = {}".format(pm.rank,minint))
        self.assertEqual(minint, 0)

    #----------------------------------------------------------------#
    def test_get_max_integer(self):
        """Test get_max_integer function."""
        maxint = pm.get_max_integer(self.inint)
        print("Maximum on processor {} = {}".format(pm.rank,maxint))
        self.assertEqual(maxint, pm.nranks-1)

#--------------------------------------------------------------------#
if __name__ == "__main__":
    unittest.main()

    # Tried the following. Does not help:
    # Calls MPI_Initialize but exits without calling MPI_Finalize.
    #print("Initializing MPI")
    #pm.pympitest_init()
    #unittest.main()
    #print("Finalizing MPI")
    #pm.pympitest_final()

O código Fortran é envolto em módulo Python chamado pympitestusando f2py, assim: f2py --f90exec="mpif90" -DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION -c mpitest.F90 -m pympitest. A unidade de teste é executado em processadores 4 da seguinte forma: mpirun -np 4 python test_pympitest.py.

Quero manter todos os testes de unidade MPI em um único arquivo python. Nas diferentes coisas que experimentei (veja os comentários no arquivo Python), o problema que enfrentei é que MPI_Initialize e MPI_Finalize são chamados várias vezes em uma única execução ou apenas um deles é chamado, todos os quais saem com um erro.

Como faço para corrigir isso para que os testes de unidade sejam aprovados corretamente?

Editar (adição): colocar as funções de teste em Test_...(unittest.TestCase)classes separadas dentro de um único arquivo Python também não ajuda. Dividir os testes de unidade MPI em arquivos diferentes e tentar python -m unittest discovernão funciona, o que é inconveniente. Testar uma única função MPI encapsulada por arquivo Python e executar individualmente cada arquivo Python funcionaria, mas isso é algo que prefiro evitar.

Os métodos setUp()e tearDown()de unittest.TestCasefornecer configuração e desmontagem por método de teste . Você deve esperar que o primeiro seja executado antes de cada método de teste e o último seja executado depois de cada um.

Em vez disso, você parece querer que eles sejam executados uma vez cada para toda a coleção de métodos de teste da classe. Para isso, você deseja setUpClass () e tearDownClass () . Como alternativa, se você definir várias classes de teste, pode preferir setUpModule()e tearDownModule().

Alternativamente, você pode criar uma unittest.TestSuitesubclasse com a qual executar seus testes e sobrescrever seu run()método para realizar uma configuração e desmontagem de uma vez por todas.