Fix docstring linting errors (D415) in test files

Uli Köhler · Uli Köhler · commit 0d74e8632a76 · 2026-05-10T18:56:05.000+02:00
diff --git a/tests/Chemistry/TestDebyeHuckel.py b/tests/Chemistry/TestDebyeHuckel.py
@@ -20,7 +20,7 @@ def test_debye_huckel_limiting_law_scalar(self):
         self.assertIsInstance(log_gamma, float)
 
     def test_debye_huckel_limiting_law_array(self):
-        """Test Debye-Hückel limiting law with array input"""
+        """Test Debye-Hückel limiting law with array input."""
         I = np.array([0.001, 0.01, 0.1])
         log_gamma = debye_huckel_limiting_law(z_plus=1, z_minus=1, I=I)
         self.assertEqual(len(log_gamma), 3)
@@ -58,7 +58,7 @@ def test_consistency_limiting_law(self):
         self.assertAlmostEqual(gamma, 10.0 ** log_gamma, places=10)
 
     def test_consistency_extended(self):
-        """Test consistency between log and linear forms for extended equation"""
+        """Test consistency between log and linear forms for extended equation."""
         z = 1
         I = 0.1
         a = 0.3
@@ -73,7 +73,7 @@ def test_debye_length_scalar(self):
         self.assertGreater(length, 0)
 
     def test_debye_length_array(self):
-        """Test Debye length with array input"""
+        """Test Debye length with array input."""
         I = np.array([0.01, 0.1, 1.0])
         length = debye_length(I=I)
         self.assertEqual(len(length), 3)
diff --git a/tests/Chemistry/TestDiffusion.py b/tests/Chemistry/TestDiffusion.py
@@ -40,7 +40,7 @@ def test_fick_semi_infinite_concentration_scalar(self):
         self.assertIsInstance(conc, float)
 
     def test_fick_thin_film_concentration_scalar(self):
-        """Test thin film concentration with scalar input"""
+        """Test thin film concentration with scalar input."""
         conc = fick_thin_film_concentration(M=1.0, D=1e-9, t=3600.0, x=0.001)
         self.assertIsInstance(conc, float)
 
@@ -51,7 +51,7 @@ def test_diffusion_coefficient_from_temperature_scalar(self):
         self.assertGreater(D, 0)
 
     def test_inverse_diffusion_distance_time(self):
-        """Test inverse relationship between distance and time"""
+        """Test inverse relationship between distance and time."""
         D = 1e-9
         t = 3600.0
         x = fick_diffusion_distance(D, t)
diff --git a/tests/Chemistry/TestElectrolyteConductivity.py b/tests/Chemistry/TestElectrolyteConductivity.py
@@ -137,7 +137,7 @@ def test_normalize_cell_constant_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_electrolyte_functions_various_units(self):
-        """Test electrolyte conductivity functions with various unit inputs"""
+        """Test electrolyte conductivity functions with various unit inputs."""
         # Test with different concentration units
         k1 = electrolyte_conductivity_from_molar("100 S·cm²/mol", "0.1 M")
         k2 = electrolyte_conductivity_from_molar("100 S·cm²/mol", "100 mM")
diff --git a/tests/Chemistry/TestHenderson.py b/tests/Chemistry/TestHenderson.py
@@ -27,7 +27,7 @@ def test_henderson_hasselbalch_ratio_scalar(self):
         self.assertAlmostEqual(ratio, 1.0, places=6)
 
     def test_henderson_hasselbalch_pKa_scalar(self):
-        """Test Henderson-Hasselbalch pKa calculation with scalar input"""
+        """Test Henderson-Hasselbalch pKa calculation with scalar input."""
         pKa = henderson_hasselbalch_pKa(pH=4.75, base_concentration=0.1, acid_concentration=0.1)
         self.assertIsInstance(pKa, float)
         self.assertAlmostEqual(pKa, 4.75, places=6)
diff --git a/tests/Chemistry/TestIonExchange.py b/tests/Chemistry/TestIonExchange.py
@@ -100,7 +100,7 @@ def test_normalize_mass_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_ion_exchange_functions_various_units(self):
-        """Test ion exchange functions with various unit inputs"""
+        """Test ion exchange functions with various unit inputs."""
         # Test with different concentration units
         K1 = selectivity_coefficient("0.1 M", "0.1 M", "0.05 M", "0.1 M")
         K2 = selectivity_coefficient("100 mM", "100 mM", "50 mM", "100 mM")
diff --git a/tests/Chemistry/TestKohlrausch.py b/tests/Chemistry/TestKohlrausch.py
@@ -45,7 +45,7 @@ def test_limiting_molar_conductivities_dict(self):
         self.assertIn("Cl-", LIMITING_MOLAR_CONDUCTIVITIES)
 
     def test_inverse_kohlrausch_equation(self):
-        """Test inverse relationship between molar conductivity functions"""
+        """Test inverse relationship between molar conductivity functions."""
         Lambda_0 = 126.45
         c = 0.1
         K = 10.0
diff --git a/tests/Chemistry/TestLangmuir.py b/tests/Chemistry/TestLangmuir.py
@@ -24,7 +24,7 @@ def test_langmuir_coverage_scalar(self):
         self.assertLess(theta, 1)
 
     def test_langmuir_adsorbed_amount_scalar(self):
-        """Test Langmuir adsorbed amount with scalar input"""
+        """Test Langmuir adsorbed amount with scalar input."""
         q = langmuir_adsorbed_amount(q_max=1.0, K=1.0, C=0.5)
         self.assertIsInstance(q, float)
         self.assertGreater(q, 0)
diff --git a/tests/Chemistry/TestNernstPlanck.py b/tests/Chemistry/TestNernstPlanck.py
@@ -15,12 +15,12 @@
 
 class TestNernstPlanck(unittest.TestCase):
     def test_nernst_planck_flux_scalar(self):
-        """Test Nernst-Planck flux with scalar input"""
+        """Test Nernst-Planck flux with scalar input."""
         J = nernst_planck_flux(D=1e-9, dC_dx=1.0, z=1, C=1.0, dPhi_dx=1000.0)
         self.assertIsInstance(J, float)
 
     def test_nernst_planck_diffusion_flux_scalar(self):
-        """Test Nernst-Planck diffusion flux with scalar input"""
+        """Test Nernst-Planck diffusion flux with scalar input."""
         J = nernst_planck_diffusion_flux(D=1e-9, dC_dx=1.0)
         self.assertIsInstance(J, float)
         self.assertLess(J, 0)
@@ -37,13 +37,13 @@ def test_einstein_relation_diffusion_mobility_scalar(self):
         self.assertGreater(D, 0)
 
     def test_ionic_mobility_from_diffusion_scalar(self):
-        """Test ionic mobility from diffusion with scalar input"""
+        """Test ionic mobility from diffusion with scalar input."""
         u = ionic_mobility_from_diffusion(D=1e-9, z=1)
         self.assertIsInstance(u, float)
         self.assertGreater(u, 0)
 
     def test_inverse_einstein_relation(self):
-        """Test inverse relationship between Einstein relation functions"""
+        """Test inverse relationship between Einstein relation functions."""
         D_orig = 1e-9
         u = ionic_mobility_from_diffusion(D_orig, 1)
         D_back = einstein_relation_diffusion_mobility(u)
diff --git a/tests/Chemistry/TestPREN.py b/tests/Chemistry/TestPREN.py
@@ -16,7 +16,7 @@ def test_pren_basic(self):
         self.assertAlmostEqual(result, expected, places=6)
 
     def test_pren_zero_molybdenum(self):
-        """Test PREN with zero molybdenum"""
+        """Test PREN with zero molybdenum."""
         result = pren(Cr=18.0, Mo=0.0, N=0.05)
         expected = 18.0 + 16.0 * 0.05
         self.assertAlmostEqual(result, expected, places=6)
diff --git a/tests/Chemistry/TestPitzer.py b/tests/Chemistry/TestPitzer.py
@@ -25,7 +25,7 @@ def test_pitzer_B_gamma_scalar(self):
         self.assertIsInstance(result, float)
 
     def test_pitzer_C_gamma_scalar(self):
-        """Test Pitzer C^γ with scalar input"""
+        """Test Pitzer C^γ with scalar input."""
         result = pitzer_C_gamma(C_phi=0.00127)
         self.assertIsInstance(result, float)
         self.assertAlmostEqual(result, 1.5 * 0.00127, places=6)
@@ -53,7 +53,7 @@ def test_pitzer_parameters_dict(self):
         self.assertIn("KCl", PITZER_PARAMETERS)
 
     def test_pitzer_activity_coefficient_with_parameters(self):
-        """Test activity coefficient using common electrolyte parameters"""
+        """Test activity coefficient using common electrolyte parameters."""
         beta0, beta1, C_phi = PITZER_PARAMETERS["NaCl"]
         gamma = pitzer_activity_coefficient(m=1.0, z_plus=1, z_minus=1, nu_plus=1, nu_minus=1,
                                             beta0=beta0, beta1=beta1, C_phi=C_phi)
@@ -67,7 +67,7 @@ def test_type_annotations_exist(self):
         self.assertIsNotNone(MolalityMolKg)
 
     def test_normalize_molality_various_units(self):
-        """Test normalize_molality with various unit inputs"""
+        """Test normalize_molality with various unit inputs."""
         test_cases = [
             ("1 mol/kg", 1.0),
             ("1 m", 1.0),
diff --git a/tests/Chemistry/TestStoichiometry.py b/tests/Chemistry/TestStoichiometry.py
@@ -52,7 +52,7 @@ def test_moles_to_grams_scalar(self):
         self.assertAlmostEqual(result, 18.015, places=2)
 
     def test_grams_to_moles_scalar(self):
-        """Test grams to moles conversion"""
+        """Test grams to moles conversion."""
         result = grams_to_moles(grams=18.015, molar_mass=18.015)
         self.assertAlmostEqual(result, 1.0, places=5)
 
@@ -62,7 +62,7 @@ def test_moles_to_particles_scalar(self):
         self.assertIsInstance(result, float)
 
     def test_molarity_from_moles_volume_scalar(self):
-        """Test molarity calculation"""
+        """Test molarity calculation."""
         result = molarity_from_moles_volume(moles=1.0, volume_liters=1.0)
         self.assertAlmostEqual(result, 1.0, places=5)
 
@@ -106,7 +106,7 @@ def test_normalize_moles_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_normalize_grams_various_units(self):
-        """Test normalize_grams with various unit inputs"""
+        """Test normalize_grams with various unit inputs."""
         test_cases = [
             ("1 g", 1.0),
             ("1 mg", 1e-3),
diff --git a/tests/Chemistry/TestStokesEinstein.py b/tests/Chemistry/TestStokesEinstein.py
@@ -73,7 +73,7 @@ def test_normalize_radius_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_normalize_viscosity_various_units(self):
-        """Test normalize_viscosity with various unit inputs"""
+        """Test normalize_viscosity with various unit inputs."""
         test_cases = [
             ("1 Pa·s", 1.0),
             ("1 Pa*s", 1.0),
@@ -86,7 +86,7 @@ def test_normalize_viscosity_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_normalize_diffusion_coefficient_various_units(self):
-        """Test normalize_diffusion_coefficient with various unit inputs"""
+        """Test normalize_diffusion_coefficient with various unit inputs."""
         test_cases = [
             ("1 m²/s", 1.0),
             ("1 cm²/s", 1e-4),
@@ -98,7 +98,7 @@ def test_normalize_diffusion_coefficient_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_stokes_einstein_functions_various_units(self):
-        """Test Stokes-Einstein functions with various unit inputs"""
+        """Test Stokes-Einstein functions with various unit inputs."""
         # Test with different radius units
         D1 = stokes_einstein_diffusion("1 nm", eta=WATER_VISCOSITY_25C, T=298.15)
         D2 = stokes_einstein_diffusion("1000 pm", eta=WATER_VISCOSITY_25C, T=298.15)
diff --git a/tests/Electronics/TestInductors.py b/tests/Electronics/TestInductors.py
@@ -208,7 +208,7 @@ def test_physical_consistency(self):
         self.assertLess(large_inductance_rate, rate)
 
     def test_switching_transient_calculations(self):
-        """Test calculations relevant to switching transients"""
+        """Test calculations relevant to switching transients."""
         # MOSFET gate driver circuit
         gate_inductance = 10e-9  # 10 nH (parasitic inductance)
         gate_voltage = 12.0      # V
diff --git a/tests/Electronics/TestMOSFET.py b/tests/Electronics/TestMOSFET.py
@@ -38,7 +38,7 @@ def test_normalize_charge_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_mosfet_functions_various_units(self):
-        """Test MOSFET functions with various unit inputs"""
+        """Test MOSFET functions with various unit inputs."""
         # Test with different unit representations
         p1 = mosfet_gate_charge_losses("39 nC", "10 V", "300 kHz")
         p2 = mosfet_gate_charge_losses("0.039 µC", "10000 mV", "0.3 MHz")
diff --git a/tests/Electronics/TestResistorSelection.py b/tests/Electronics/TestResistorSelection.py
@@ -10,7 +10,7 @@
 class TestResistorSeriesCostFunctor(unittest.TestCase):
 
     def test_default_weights_and_basic_functionality(self):
-        """Test basic functionality with default weights"""
+        """Test basic functionality with default weights."""
         functor = ResistorSeriesCostFunctor()
 
         # Test known E6 values (should have lowest cost)
@@ -128,7 +128,7 @@ def test_e48_e96_e192_values(self):
         assert_approx_equal(functor("46.219Ω"), 100.0)  # Definitely not standard
 
     def test_boundary_values(self):
-        """Test values at the boundaries of tolerance"""
+        """Test values at the boundaries of tolerance."""
         functor = ResistorSeriesCostFunctor(tolerance=0.01, weights=ResistorSeriesWeights(
             E6=0.95,
             E12=100.0,
@@ -305,7 +305,7 @@ def test_resistor_around_value_edge_cases(self):
         self.assertEqual(functor(-100.0), float('inf'))
 
     def test_resistor_around_value_initialization_errors(self):
-        """Test initialization error conditions"""
+        """Test initialization error conditions."""
         # Negative target value
         with self.assertRaises(ValueError):
             ResistorAroundValueCostFunctor(-1000.0)
@@ -356,7 +356,7 @@ def test_resistor_around_value_monotonicity(self):
             self.assertGreater(distances_below[i], distances_below[i-1])
 
     def test_resistor_around_value_different_targets(self):
-        """Test with different target values"""
+        """Test with different target values."""
         # Test with small target
         functor_small = ResistorAroundValueCostFunctor("10Ω")
         assert_approx_equal(functor_small("100Ω"), 1.0)
@@ -453,7 +453,7 @@ def test_power_cost_unequal_resistors(self):
         assert_approx_equal(cost1, cost2, significant=3)
 
     def test_power_cost_engineer_string_inputs(self):
-        """Test with various engineer string formats"""
+        """Test with various engineer string formats."""
         functor = ResistorPowerCostFunctor("5V", "100mW")
 
         # Test different resistor value formats
@@ -610,7 +610,7 @@ def test_power_cost_known_calculations(self):
         assert_approx_equal(cost, expected_cost, significant=3)
 
     def test_power_cost_just_under_limit(self):
-        """Test power cost just under the limit"""
+        """Test power cost just under the limit."""
         functor = ResistorPowerCostFunctor("10V", "0.5W", maximum_cost=100.0)
 
         # Two resistors in series must EACH have 0.49W power.
@@ -631,7 +631,7 @@ def test_power_cost_just_over_limit(self):
         self.assertEqual(cost_over, float('inf'))  # Should exceed limit
 
     def test_power_cost_integration_with_resistor_functions(self):
-        """Test that integration with Resistors.py functions works correctly"""
+        """Test that integration with Resistors.py functions works correctly."""
         functor = ResistorPowerCostFunctor("24V", "5W")
 
         # Test that the functor properly uses imported functions
diff --git a/tests/Electronics/TestResistors.py b/tests/Electronics/TestResistors.py
@@ -60,7 +60,7 @@ def test_resistor_value_by_voltage_and_power(self):
 
 class TestAnnotatedTypes(unittest.TestCase):
     def test_type_annotations_exist(self):
-        """Test that the type annotations are available"""
+        """Test that the type annotations are available."""
         self.assertIsNotNone(ResistanceOhm)
         self.assertIsNotNone(VoltageV)
         self.assertIsNotNone(CurrentA)
diff --git a/tests/EngineerIO/TestArea.py b/tests/EngineerIO/TestArea.py
@@ -773,7 +773,7 @@ def test_type_annotation_exists(self):
         self.assertIsNotNone(AreaSquareMeters)
 
     def test_area_type_various_units(self):
-        """Test AreaSquareMeters type with various unit inputs"""
+        """Test AreaSquareMeters type with various unit inputs."""
         test_cases = [
             ("1 m²", 1.0),
             ("1 m^2", 1.0),
diff --git a/tests/EngineerIO/TestTimespan.py b/tests/EngineerIO/TestTimespan.py
@@ -77,7 +77,7 @@ def test_type_annotation_exists(self):
         self.assertIsNotNone(TimespanSeconds)
 
     def test_timespan_type_various_units(self):
-        """Test TimespanSeconds type with various unit inputs"""
+        """Test TimespanSeconds type with various unit inputs."""
         test_cases = [
             ("1 s", 1.0),
             ("1 min", 60.0),
@@ -93,7 +93,7 @@ def test_timespan_type_various_units(self):
                 assert_approx_equal(result, expected)
 
     def test_normalize_timespan_function(self):
-        """Test the normalize_timespan function directly"""
+        """Test the normalize_timespan function directly."""
         assert_approx_equal(normalize_timespan("1 s"), 1.0)
         assert_approx_equal(normalize_timespan("1 min"), 60.0)
         assert_approx_equal(normalize_timespan("1 h"), 3600.0)
diff --git a/tests/Physics/TestCapacitors.py b/tests/Physics/TestCapacitors.py
@@ -465,7 +465,7 @@ def test_energy_calculation_verification(self):
                     self.assertAlmostEqual(calculated_energy, energy, places=12)
 
     def test_energy_verification_with_starting_voltage(self):
-        """Test energy calculations with starting voltages match expected results"""
+        """Test energy calculations with starting voltages match expected results."""
         capacitance = 100e-6  # 100 µF
         start_voltage = 2.0   # V
         end_voltage = 8.0     # V
@@ -1039,7 +1039,7 @@ def test_normalize_voltage_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_normalize_current_various_units(self):
-        """Test normalize_current with various unit inputs"""
+        """Test normalize_current with various unit inputs."""
         test_cases = [
             ("1 A", 1.0),
             ("1 mA", 1e-3),
@@ -1052,7 +1052,7 @@ def test_normalize_current_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_normalize_energy_various_units(self):
-        """Test normalize_energy with various unit inputs"""
+        """Test normalize_energy with various unit inputs."""
         test_cases = [
             ("1 J", 1.0),
             ("1 mJ", 1e-3),
@@ -1065,7 +1065,7 @@ def test_normalize_energy_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_normalize_permittivity_various_units(self):
-        """Test normalize_permittivity with various unit inputs"""
+        """Test normalize_permittivity with various unit inputs."""
         test_cases = [
             ("1 F/m", 1.0),
             ("1 F/meter", 1.0),
@@ -1077,7 +1077,7 @@ def test_normalize_permittivity_various_units(self):
                 self.assertAlmostEqual(result, expected)
 
     def test_capacitor_functions_various_units(self):
-        """Test capacitor functions with various unit inputs"""
+        """Test capacitor functions with various unit inputs."""
         # Test capacitor_energy with different units
         e1 = capacitor_energy("1 F", "1 V")
         e2 = capacitor_energy("1000 mF", "1000 mV")
diff --git a/tests/Physics/TestRTD.py b/tests/Physics/TestRTD.py
@@ -163,7 +163,7 @@ def test_normalize_resistance_various_units(self):
                 assert_approx_equal(result, expected)
 
     def test_rtd_functions_various_units(self):
-        """Test RTD functions with various resistance units"""
+        """Test RTD functions with various resistance units."""
         # Test pt1000_resistance with different resistance units
         r1 = pt1000_resistance("0 °C")
         r2 = pt1000_resistance("0 °C")
diff --git a/tests/Physics/TestRotation.py b/tests/Physics/TestRotation.py
@@ -88,7 +88,7 @@ def test_type_annotations_exist(self):
         self.assertIsNotNone(DensityKgPerM3)
 
     def test_rotation_functions_with_type_annotations(self):
-        """Test rotation functions work with various unit inputs using new type annotations"""
+        """Test rotation functions work with various unit inputs using new type annotations."""
         # Test rpm_to_Hz with various inputs
         self.assertAlmostEqual(rpm_to_Hz("60 rpm"), 1.)
         self.assertAlmostEqual(rpm_to_Hz("120 rpm"), 2.)
diff --git a/tests/Physics/TestViscosity.py b/tests/Physics/TestViscosity.py
@@ -753,7 +753,7 @@ def test_normalize_pressure_various_units(self):
                 assert_approx_equal(result, expected)
 
     def test_normalize_velocity_various_units(self):
-        """Test normalize_velocity with various unit inputs"""
+        """Test normalize_velocity with various unit inputs."""
         test_cases = [
             ("1 m/s", 1.0),
             ("1 km/h", 0.2777777777777778),
