hestia-earth-models 0.64.3__py3-none-any.whl → 0.64.5__py3-none-any.whl

tests/models/cycle/test_stockingDensityAnimalHousingAverage.py

@@ -14,12 +14,12 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
     [
         (
             'no live animal => no run',
-            {'products': [{'term': {'termType': 'crop'}}]},
+            {'animals': [{'term': {'termType': 'crop'}, 'value': 10}]},
             False
         ),
         (
             'with live animal => run',
-            {'products': [{'term': {'termType': 'liveAnimal'}}]},
+            {'animals': [{'term': {'termType': 'liveAnimal'}, 'value': 10}]},
             True
         ),
     ]

tests/models/environmentalFootprintV3/test_soilQualityIndexLandOccupation.py

@@ -0,0 +1,136 @@
+import json
+from unittest.mock import patch
+
+from hestia_earth.models.environmentalFootprintV3.soilQualityIndexLandOccupation import MODEL, TERM_ID, run, _should_run
+from tests.utils import fixtures_path, fake_new_indicator
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+def test_should_run():
+    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    # a LandCover type with no CF => no run
+    cycle['site']['management'] = [{"endDate": "2024-03-31", "@type": "Management",
+                                    "term": {"termType": "landCover", "@type": "Term", "@id": "ocean"}}]
+
+    should_run, *args = _should_run(cycle)
+    assert not should_run
+
+    # no management => no run
+    cycle['site']['management'] = []
+    should_run, *args = _should_run(cycle)
+    assert not should_run
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    """
+    Example data:
+    Country: Italy
+    Quantity in m^2: 1.3573373E-9
+    CF METHOD factor: 4.3198E+01
+    "Charact Result [soil quality index]" result also in result.jsonld : 5.86342566854E-08
+    siteArea in test file in ha:    1.3573373E-9 / 10 000 = 1.3573373e-13
+
+    Name Flow: forest Land occupation
+    Parameters
+    ----------
+    args
+
+    Returns
+    -------
+
+    """
+    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run_other_sites(*args):
+    """
+    This test case contains 2 sites:
+    One is a crop in france, with value:
+    CF_METHOD_factor_france_permanent_crops * ( siteArea_france_crop * time_in_years )
+    = 87.631 * ( 1.0082662E-7 * 1 )
+    = 8.835537537220001e-06
+
+    And one a forest in italy, with value:
+    CF_METHOD_factor_italy_forest * ( siteArea_italy_forest * time_in_years )
+    = 43.198 * ( 1.3573373E-9 * 1 )
+    = 5.86342566854E-08
+
+    We expect the model to return 8.835537537220001e-06 + 5.86342566854E-08 = 8.894171793905402e-06
+
+    """
+    with open(f"{fixtures_folder}/otherSites/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/otherSites/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run_with_subclass_landcover(*args):
+    """
+    Example data:
+    Country: Italy
+    Quantity in m^2: 1.3573373E-9
+    CF METHOD factor: 4.3198E+01
+    "Charact Result [soil quality index]" result also in result.jsonld : 5.86342566854E-08
+    siteArea in test file in ha:    1.3573373E-9 / 10 000 = 1.3573373e-13
+
+    landCover field "plantationForest" should map to
+    Name Flow: "forest, intensive Land occupation"
+    """
+    with open(f"{fixtures_folder}/plantationForest/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/plantationForest/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run_with_region_missing_data(*args):
+    """
+    When given valid sub-region or country not in the lookup file should default to 'region-world'
+    """
+    with open(f"{fixtures_folder}/default-region-world/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/default-region-world/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run_with_no_region(*args):
+    """
+    When no location is specified, defaults to region world.
+    """
+    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    del cycle['site']['country']
+
+    with open(f"{fixtures_folder}/default-region-world/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/fantkeEtAl2016/test_damageToHumanHealthParticulateMatterFormation.py

@@ -0,0 +1,20 @@
+import json
+from unittest.mock import patch
+
+from hestia_earth.models.fantkeEtAl2016.damageToHumanHealthParticulateMatterFormation import MODEL, TERM_ID, run
+from tests.utils import fixtures_path, fake_new_indicator
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(mocked_indicator):
+    with open(f"{fixtures_folder}/impactassessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impactassessment)
+    assert value == expected

tests/models/frischknechtEtAl2000/test_ionisingRadiationKbqU235Eq.py

@@ -0,0 +1,70 @@
+import json
+import pytest
+from unittest.mock import patch
+from tests.utils import fixtures_path, fake_new_indicator
+
+from hestia_earth.models.frischknechtEtAl2000.ionisingRadiationKbqU235Eq import MODEL, TERM_ID, run, _should_run
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@pytest.mark.parametrize(
+    'test_name,impact,expected_should_run',
+    [
+        (
+            'no emissionsResourceUse => no run',
+            {},
+            False
+        ),
+        (
+            'no emissions in the lookups list => no run',
+            {
+                'emissionsResourceUse': [
+                    {
+                        'term': {'@id': 'co2ToAirInputsProduction'}
+                    }
+                ]
+            },
+            False
+        ),
+        (
+            'with emissions in the lookup list but no waste inputs => no run',
+            {
+                'emissionsResourceUse': [
+                    {
+                        'term': {'@id': 'ionisingCompoundsToAirInputsProduction'}
+                    }
+                ]
+            },
+            False
+        ),
+        (
+            'with emissions in the lookup list and waste inputs => run',
+            {
+                'emissionsResourceUse': [
+                    {
+                        'term': {'@id': 'ionisingCompoundsToAirInputsProduction'},
+                        'inputs': [{'termType': 'waste'}]
+                    }
+                ]
+            },
+            True
+        )
+    ]
+)
+def test_should_run(test_name, impact, expected_should_run):
+    should_run, *args = _should_run(impact)
+    assert should_run == expected_should_run, test_name
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(f"{fixtures_folder}/impact-assessment.jsonld", encoding='utf-8') as f:
+        impactassessment = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(impactassessment)
+    assert value == expected

tests/models/ipcc2019/test_co2ToAirCarbonStockChange_utils.py

@@ -0,0 +1,50 @@
+from hestia_earth.schema import EmissionMethodTier, MeasurementMethodClassification
+
+from hestia_earth.models.ipcc2019.co2ToAirCarbonStockChange_utils import (
+    add_carbon_stock_change_emissions, calc_carbon_stock_change, calc_carbon_stock_change_emission, _convert_c_to_co2,
+    lerp_carbon_stocks, CarbonStock, CarbonStockChange, CarbonStockChangeEmission
+)
+
+
+def test_convert_c_to_co2():
+    KG_C = 1000
+    EXPECTED = 3663.836163836164
+    assert _convert_c_to_co2(KG_C) == EXPECTED
+
+
+def test_lerp_carbon_stocks():
+    START = CarbonStock(20000, "2000-12-31", MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
+    END = CarbonStock(22000, "2002-12-31", MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
+    TARGET_DATE = "2001-12-31"
+    EXPECTED = CarbonStock(
+        21000, "2001-12-31", MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT
+    )
+
+    result = lerp_carbon_stocks(START, END, TARGET_DATE)
+    assert result == EXPECTED
+
+
+def test_calc_carbon_stock_change():
+    START = CarbonStock(20000, "2000", MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
+    END = CarbonStock(21000,  "2001", MeasurementMethodClassification.TIER_1_MODEL)
+    EXPECTED = CarbonStockChange(1000, "2000", "2001", MeasurementMethodClassification.TIER_1_MODEL)
+
+    result = calc_carbon_stock_change(START, END)
+    assert result == EXPECTED
+
+
+def test_calc_carbon_stock_change_emission():
+    SOC_STOCK_CHANGE = CarbonStockChange(-1000, "2000", "2001", MeasurementMethodClassification.TIER_1_MODEL)
+    EXPECTED = CarbonStockChangeEmission(3663.836163836164, "2000", "2001", EmissionMethodTier.TIER_1)
+
+    result = calc_carbon_stock_change_emission(SOC_STOCK_CHANGE)
+    assert result == EXPECTED
+
+
+def test_add_carbon_stock_change_emissions():
+    EMISSION_1 = CarbonStockChangeEmission(3000, "2000", "2001", EmissionMethodTier.TIER_1)
+    EMISSION_2 = CarbonStockChangeEmission(2000, "2001", "2002", EmissionMethodTier.TIER_1)
+    EXPECTED = CarbonStockChangeEmission(5000, "2000", "2002", EmissionMethodTier.TIER_1)
+
+    result = add_carbon_stock_change_emissions(EMISSION_1, EMISSION_2)
+    assert result == EXPECTED

tests/models/ipcc2019/test_co2ToAirSoilOrganicCarbonStockChangeManagementChange.py

@@ -4,12 +4,7 @@ from os.path import isfile
 from pytest import mark
 from unittest.mock import patch
 
-from hestia_earth.schema import EmissionMethodTier, MeasurementMethodClassification
-
-from hestia_earth.models.ipcc2019.co2ToAirSoilOrganicCarbonStockChangeManagementChange import (
-    calc_soc_stock_change, calc_soc_stock_change_emission, convert_c_to_co2, lerp_soc_stocks, MODEL, run, TERM_ID,
-    SocStock, SocStockChange, SocStockChangeEmission
-)
+from hestia_earth.models.ipcc2019.co2ToAirSoilOrganicCarbonStockChangeManagementChange import MODEL, run, TERM_ID
 
 from tests.utils import fake_new_emission, fixtures_path
 
@@ -85,36 +80,3 @@ def test_run_empty(_get_site_mock, related_cycles_mock, _new_emission_mock):
 
     result = run(CYCLE)
     assert result == EXPECTED
-
-
-def test_convert_c_to_co2():
-    KG_C = 1000
-    EXPECTED = 3663.836163836164
-    assert convert_c_to_co2(KG_C) == EXPECTED
-
-
-def test_linear_interpolate_soc_stock():
-    START = SocStock(20000, "2000-12-31", MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
-    END = SocStock(22000, "2002-12-31", MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
-    TARGET_DATE = "2001-12-31"
-    EXPECTED = SocStock(21000, "2001-12-31", MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
-
-    result = lerp_soc_stocks(START, END, TARGET_DATE)
-    assert result == EXPECTED
-
-
-def test_calc_soc_stock_change():
-    START = SocStock(20000, "2000", MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT)
-    END = SocStock(21000,  "2001", MeasurementMethodClassification.TIER_1_MODEL)
-    EXPECTED = SocStockChange(1000, "2000", "2001", MeasurementMethodClassification.TIER_1_MODEL)
-
-    result = calc_soc_stock_change(START, END)
-    assert result == EXPECTED
-
-
-def test_calc_soc_stock_change_emission():
-    SOC_STOCK_CHANGE = SocStockChange(-1000, "2000", "2001", MeasurementMethodClassification.TIER_1_MODEL)
-    EXPECTED = SocStockChangeEmission(3663.836163836164, "2000", "2001", EmissionMethodTier.TIER_1)
-
-    result = calc_soc_stock_change_emission(SOC_STOCK_CHANGE)
-    assert result == EXPECTED

tests/models/pooreNemecek2018/test_saplings.py

@@ -12,7 +12,7 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 @patch(f"{class_path}.get_crop_lookup_value", return_value=10)
 @patch(f"{class_path}._is_term_type_incomplete", return_value=True)
 def test_should_run(mock_is_term_type_incomplete, *args):
-    cycle = {'products': [{'term': {'@id': 'wheatGrain'}}]}
+    cycle = {'cycleDuration': 200, 'products': [{'term': {'@id': 'wheatGrain'}}]}
 
     mock_is_term_type_incomplete.return_value = False
     should_run, *args = _should_run(cycle)

tests/models/site/test_management.py

@@ -5,7 +5,6 @@ import pytest
 from hestia_earth.schema import TermTermType, SiteSiteType
 
 from hestia_earth.models.site.management import MODEL, MODEL_KEY, run, _should_run
-from hestia_earth.models.utils.blank_node import condense_nodes
 from tests.utils import fixtures_path
 
 CLASS_PATH = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
@@ -39,152 +38,6 @@ def lookup_side_effect(*args, **kwargs):
     return True
 
 
-@pytest.mark.parametrize(
-    "test_name,input_nodes,expected_output_nodes",
-    [
-        (
-            "No match",
-            [
-                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-                {"startDate": "2003", "endDate": "2004", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [2]},
-            ],
-            [
-                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-                {"startDate": "2003", "endDate": "2004", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [2]},
-            ],
-        ),
-        (
-            "No continuity",
-            [
-                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-                {"startDate": "2004", "endDate": "2005", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-            ],
-            [
-                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-                {"startDate": "2004", "endDate": "2005", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-            ],
-        ),
-        (
-            "No continuity (multiple values differ)",
-            [
-                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [10, 20]},
-                {"startDate": "2003", "endDate": "2004", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [10, 30]},
-            ],
-            [
-                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [10, 20]},
-                {"startDate": "2003", "endDate": "2004", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [10, 30]},
-            ],
-        ),
-        (
-            "2->1 condense (YYYY dates)",
-            [
-                {"startDate": "2001", "endDate": "2001", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [10, 20]},
-                {"startDate": "2002", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [10, 20]},
-            ],
-            [
-                {"startDate": "2001-01-01", "endDate": "2002-12-31", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [10, 20]}
-            ],
-        ),
-        (
-            "4->2 condense (YYYY-MM dates)",
-            [
-                {"startDate": "2001-01", "endDate": "2001-12", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-                {"startDate": "2002-01", "endDate": "2002-03", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-            ],
-            [
-                {"startDate": "2001-01-01", "endDate": "2002-03-31", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]}
-            ],
-        ),
-        (
-            "2->1 condense (YYYY-MM-DD dates)",
-            [
-                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-                {"startDate": "2002-01-01", "endDate": "2002-05-04", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]},
-            ],
-            [
-                {"startDate": "2001-01-01", "endDate": "2002-05-04", "term": {"@id": "treeNutTree", "units": "% area"},
-                 "value": [2]}
-            ],
-        ),
-        (
-            "3->1 condense",
-            [
-                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]},
-                {"startDate": "2002-01-01", "endDate": "2002-10-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]},
-                {"startDate": "2002-11-01", "endDate": "2004-04-05", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]},
-            ],
-            [
-                {"startDate": "2001-01-01", "endDate": "2004-04-05", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]}
-            ],
-        ),
-        (
-            "3->2 partial condense",
-            [
-                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]},
-                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]},
-                {"startDate": "2002-01-01", "endDate": "2003-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]},
-            ],
-            [
-                {"startDate": "2001-01-01", "endDate": "2003-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]},
-                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [9]}
-            ],
-        ),
-        (
-            "7->2 multi-condense",
-            [
-                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [7]},
-                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [7]},
-                {"startDate": "2001-12-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [7]},
-                {"startDate": "2002-01-01", "endDate": "2002-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [7]},
-                {"startDate": "2013-01-01", "endDate": "2013-05-20", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [7]},
-            ],
-            [
-                {"startDate": "2001-01-01", "endDate": "2002-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [7]},
-                {"startDate": "2012-02-01", "endDate": "2013-05-20", "term": {"@id": "bananaPlant", "units": "% area"},
-                 "value": [7]}
-            ],
-        ),
-    ]
-)
-def test_condense_nodes(test_name, input_nodes, expected_output_nodes):
-    assert condense_nodes(input_nodes) == expected_output_nodes
-
-
 @patch(f"{CLASS_PATH}.download_hestia", side_effect=lambda id, *args: TERM_BY_ID[id])
 @patch(f"{CLASS_PATH}.related_cycles")
 def test_should_run(mock_related_cycles, *args):
@@ -253,8 +106,7 @@ def test_should_run(mock_related_cycles, *args):
                     },
                     "value": [51],
                     "startDate": "2001",
-                    "endDate": "2002",
-                    "properties": {"test": "properties"}
+                    "endDate": "2002"
                 }
             ],
             "startDate": "2021",
@@ -275,8 +127,7 @@ def test_should_run(mock_related_cycles, *args):
                     },
                     "value": [51],
                     "startDate": "2001",
-                    "endDate": "2002",
-                    "properties": {"test": "properties"}
+                    "endDate": "2002"
                 }
             ],
             "startDate": "2021",
@@ -289,8 +140,7 @@ def test_should_run(mock_related_cycles, *args):
         'term': TERM_BY_ID['genericCropPlant'],
         'value': 100,
         'endDate': '2022',
-        'startDate': '2021',
-        'properties': {'test': 'properties'}
+        'startDate': '2021'
     }]
 
 

tests/models/utils/test_array_builders.py

@@ -1,16 +1,17 @@
-from numpy import array
-from numpy.testing import assert_array_equal
+from numpy import array, corrcoef
+from numpy.testing import assert_array_equal, assert_allclose
 from numpy.typing import NDArray
 from pytest import mark
 
 from hestia_earth.models.utils.array_builders import (
-    avg_run_in_columnwise, avg_run_in_rowwise, discrete_uniform_1d, discrete_uniform_2d, gen_seed, grouped_avg,
-    normal_1d, normal_2d, plus_minus_uncertainty_to_normal_1d, plus_minus_uncertainty_to_normal_2d,
-    repeat_1d_array_as_columns, repeat_array_as_columns, repeat_array_as_rows, repeat_single, triangular_1d,
-    triangular_2d, truncated_normal_1d, truncated_normal_2d
+    avg_run_in_columnwise, avg_run_in_rowwise, correlated_normal_2d, discrete_uniform_1d, discrete_uniform_2d,
+    gen_seed, grouped_avg, normal_1d, normal_2d, plus_minus_uncertainty_to_normal_1d,
+    plus_minus_uncertainty_to_normal_2d, repeat_1d_array_as_columns, repeat_array_as_columns, repeat_array_as_rows,
+    repeat_single, triangular_1d, triangular_2d, truncated_normal_1d, truncated_normal_2d
 )
 
 SEED = 0
+N_ITERATIONS = 10000
 SHAPE = (1000, 1000)
 
 
@@ -251,3 +252,63 @@ def test_gen_seed_no_id():
     EXPECTED = 2140941220
     result = gen_seed(NODE)
     assert result == EXPECTED
+
+
+# means, sds, correlation_matrix, tol_kwargs
+PARAMS_CORRELATED_NORMAL_2D = [
+    (
+        array([0, 0, 0, 0, 0]),
+        array([1, 1, 1, 1, 1]),
+        array([
+            [1.0, 0.5, 0.25, 0.125, 0.0625],
+            [0.5, 1.0, 0.5, 0.25, 0.125],
+            [0.25, 0.5, 1.0, 0.5, 0.25],
+            [0.125, 0.25, 0.5, 1.0, 0.5],
+            [0.0625, 0.125, 0.25, 0.5, 1.0]
+        ]),
+        {"atol": 0.05}
+    ),
+    (
+        array([40000, 42000, 43000, 44333.333]),
+        array([4000, 4200, 4300, 4433.333]),
+        array([
+            [1.0, 0.965867, 0.932987, 0.901227],
+            [0.965867, 1.0, 0.965959, 0.933076],
+            [0.932987, 0.965959, 1.0, 0.965959],
+            [0.901227, 0.933076, 0.965959, 1.0]
+        ]),
+        {"rtol": 0.05}
+    ),
+    (
+        array([40000, 42000, 43000, 44333.333]),
+        array([4000, 4200, 4300, 4433.333]),
+        array([
+            [1.0, 0, 0, 0],
+            [0, 1.0, 0, 0],
+            [0, 0, 1.0, 0],
+            [0, 0, 0, 1.0]
+        ]),
+        {"rtol": 0.05}
+    )
+]
+IDS_CORRELATED_NORMAL_2D = [
+    "standard normal distributions",
+    "custom normal distributions",
+    "no correlation"
+]
+
+
+@mark.parametrize(
+    "means, sds, correlation_matrix, tol_kwargs",
+    PARAMS_CORRELATED_NORMAL_2D,
+    ids=IDS_CORRELATED_NORMAL_2D
+)
+def test_correlated_normal_2d_standard_normal_dist(
+    means: NDArray, sds: NDArray, correlation_matrix: NDArray, tol_kwargs: dict
+):
+    result = correlated_normal_2d(N_ITERATIONS, means, sds, correlation_matrix, seed=SEED)
+    empirical_correlation_matrix = corrcoef(result)
+
+    assert_allclose(result.mean(axis=1), means, **tol_kwargs)  # row-wise mean matches input
+    assert_allclose(result.std(axis=1), sds, **tol_kwargs)  # row-wise SD matches input
+    assert_allclose(empirical_correlation_matrix, correlation_matrix, atol=0.05)  # correlation matches input