Added testing for reading OpenFOAM mesh in binary format

Author: filippo-biondi

tests/test_openfoamhandler.py

@@ -1,16 +1,20 @@
 from unittest import TestCase
 import unittest
+import pytest
 import numpy as np
 from smithers.io.openfoam import OpenFoamHandler, FoamMesh
 
 openfoam_mesh_path = "tests/test_datasets/openfoam_mesh"
+openfoam_mesh_binary_path = "tests/test_datasets/openfoam_mesh_binary"
 notime_openfoam_mesh_path = "tests/test_datasets/notime_openfoam_mesh"
-handler = OpenFoamHandler()
-mesh = handler.read(openfoam_mesh_path)
+notime_openfoam_mesh_binary_path = "tests/test_datasets/notime_openfoam_mesh_binary"
+mesh_ascii = OpenFoamHandler().read(openfoam_mesh_path)
+mesh_binary = OpenFoamHandler().read(openfoam_mesh_binary_path)
 truth_mesh = FoamMesh(openfoam_mesh_path)
 
 
-def test_read():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read(mesh):
     assert type(mesh) == dict
 
     assert "points" in mesh["0"]
@@ -19,7 +23,8 @@ def test_read():
     assert "cells" in mesh["0"]
 
 
-def test_read_boundary_names():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_boundary_names(mesh):
     assert set(mesh["0"]["boundary"].keys()) == set(
         [
             b"inlet",
@@ -32,19 +37,23 @@ def test_read_boundary_names():
     )
 
 
-def test_read_points():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_points(mesh):
     np.testing.assert_almost_equal(mesh["0"]["points"], truth_mesh.points)
 
 
-def test_read_faces():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_faces(mesh):
     np.testing.assert_almost_equal(mesh["0"]["faces"], truth_mesh.faces)
 
 
-def test_read_cells():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_cells(mesh):
     assert len(mesh["0"]["cells"]) == len(truth_mesh.cell_faces)
 
 
-def test_read_cell_faces():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_cell_faces(mesh):
     a_key = list(mesh["0"]["cells"].keys())[0]
     smithers_cell = mesh["0"]["cells"][a_key]
 
@@ -53,15 +62,17 @@ def test_read_cell_faces():
     )
 
 
-def test_read_cell_neighbors():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_cell_neighbors(mesh):
     a_key = list(mesh["0"]["cells"].keys())[-1]
     smithers_cell = mesh["0"]["cells"][a_key]
     np.testing.assert_almost_equal(
         smithers_cell["neighbours"], truth_mesh.cell_neighbour[a_key]
     )
 
 
-def test_read_cell_points():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_cell_points(mesh):
     a_key = list(mesh["0"]["cells"].keys())[-1]
     smithers_cell = mesh["0"]["cells"][a_key]
 
@@ -74,7 +85,8 @@ def test_read_cell_points():
     np.testing.assert_almost_equal(smithers_cell["points"], faces_points)
 
 
-def test_boundary():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_boundary(mesh):
     ofpp_obstacle = truth_mesh.boundary[b"obstacle"]
     smithers_obstacle = mesh["0"]["boundary"][b"obstacle"]
 
@@ -104,40 +116,46 @@ def test_boundary():
     )
 
 
-def test_read_fields_time_instants_all():
-    all_numeric_mesh = handler.read(
-        openfoam_mesh_path, time_instants="all_numeric"
+@pytest.mark.parametrize("path", [openfoam_mesh_path, openfoam_mesh_binary_path])
+def test_read_fields_time_instants_all(path):
+    all_numeric_mesh = OpenFoamHandler().read(
+        path, time_instants="all_numeric"
     )
     assert set(all_numeric_mesh.keys()) == set(["0", "1088", "4196"])
 
 
-def test_read_fields_time_instants_first():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_fields_time_instants_first(mesh):
     assert set(mesh.keys()) == set(["0"])
 
 
-def test_read_fields_time_instants_list():
-    handler = OpenFoamHandler()
-    time_list_mesh = handler.read(openfoam_mesh_path, time_instants=["1088"])
+@pytest.mark.parametrize("path", [openfoam_mesh_path, openfoam_mesh_binary_path])
+def test_read_fields_time_instants_list(path):
+    time_list_mesh = OpenFoamHandler().read(path, time_instants=["1088"])
     assert set(time_list_mesh.keys()) == set(["1088"])
 
 
-def test_read_fields_all():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_read_fields_all(mesh):
     for tdc in mesh.values():
         assert set(tdc["fields"].keys()) == set(["U", "p"])
 
 
-def test_read_fields_list():
-    fields_list_mesh = handler.read(openfoam_mesh_path, field_names=["p"])
+@pytest.mark.parametrize("path", [openfoam_mesh_path, openfoam_mesh_binary_path])
+def test_read_fields_list(path):
+    fields_list_mesh = OpenFoamHandler().read(path, field_names=["p"])
     for tdc in fields_list_mesh.values():
         assert set(tdc["fields"].keys()) == set(["p"])
 
 
-def test_no_time_instants():
+@pytest.mark.parametrize("path", [notime_openfoam_mesh_path, notime_openfoam_mesh_binary_path])
+def test_no_time_instants(path):
     # assert that this doesn't raise anything
-    handler.read(notime_openfoam_mesh_path)
+    OpenFoamHandler().read(path)
 
 
-def test_area():
+@pytest.mark.parametrize("mesh", [mesh_ascii, mesh_binary])
+def test_area(mesh):
     np.testing.assert_almost_equal(
         mesh["0"]["boundary"][b"obstacle"]["faces"]["area"][100],
         0.039269502373542965,