diff --git a/src/post_processing/utils/core_utils.py b/src/post_processing/utils/core_utils.py
index cf14302..f9b00cd 100644
--- a/src/post_processing/utils/core_utils.py
+++ b/src/post_processing/utils/core_utils.py
@@ -63,12 +63,10 @@ def get_season(ts: Timestamp, *, northern: bool = True) -> tuple[str, int]:
 
     """
     if northern:
-        winter = [1, 2, 12]
         spring = [3, 4, 5]
         summer = [6, 7, 8]
         autumn = [9, 10, 11]
     else:
-        winter = [6, 7, 8]
         spring = [9, 10, 11]
         summer = [1, 2, 12]
         autumn = [3, 4, 5]
@@ -79,11 +77,8 @@ def get_season(ts: Timestamp, *, northern: bool = True) -> tuple[str, int]:
         season = "summer"
     elif ts.month in autumn:
         season = "autumn"
-    elif ts.month in winter:
-        season = "winter"
     else:
-        msg = "Invalid timestamp"
-        raise ValueError(msg)
+        season = "winter"
 
     return season, ts.year - 1 if ts.month in [1, 2] else ts.year
 
@@ -93,10 +88,7 @@ def get_sun_times(
     stop: Timestamp,
     lat: float,
     lon: float,
-) -> (
-    list[float],
-    list[float],
-):
+) -> tuple[list[float], list[float]]:
     """Fetch sunrise and sunset hours for dates between start and stop.
 
     Parameters
@@ -171,7 +163,7 @@ def get_coordinates() -> tuple:
                     f"'{lat}' is not a valid latitude. It must be between -90 and 90.\n"
                 )
         except ValueError:
-            errmsg += f"'{lat}' is not a valid entry for latitude.\n"
+            errmsg += f"'lat', invalid entry: '{lat}'.\n"
 
         try:
             lon_val = float(lon.strip())  # Convert to float for longitude
@@ -349,7 +341,7 @@ def set_bar_height(ax: plt.Axes, pixel_height: int = 10) -> float:
 
     """
     if not ax.has_data():
-        msg = "Axe has no data"
+        msg = "Axe have no data"
         raise ValueError(msg)
 
     display_to_data = ax.transData.inverted().transform
@@ -380,7 +372,7 @@ def add_recording_period(
 
     """
     if not ax.has_data():
-        msg = "Axe has no data"
+        msg = "Axe have no data"
         raise ValueError(msg)
 
     recorder_intervals = [
@@ -419,10 +411,6 @@ def get_count(df: DataFrame, bin_size: Timedelta | BaseOffset) -> DataFrame:
         "<label>-<annotator>", containing the count of observations in that bin.
 
     """
-    if not isinstance(df, DataFrame):
-        msg = "`df` must be a DataFrame"
-        raise TypeError(msg)
-
     if df.empty:
         msg = "`df` contains no data"
         raise ValueError(msg)
@@ -464,10 +452,6 @@ def get_labels_and_annotators(df: DataFrame) -> tuple[list, list]:
         A tuple containing the labels and annotators lists.
 
     """
-    if not isinstance(df, DataFrame):
-        msg = "`df` must be a DataFrame"
-        raise TypeError(msg)
-
     if df.empty:
         msg = "`df` contains no data"
         raise ValueError(msg)
@@ -497,9 +481,10 @@ def localize_timestamps(timestamps: list[Timestamp], tz: tzinfo) -> list[Timesta
     return localized
 
 
-def get_time_range_and_bin_size(timestamp_list: list[Timestamp],
-                    bin_size: Timedelta | BaseOffset,
-                    ) -> (DatetimeIndex, Timedelta):
+def get_time_range_and_bin_size(
+    timestamp_list: list[Timestamp],
+    bin_size: Timedelta | BaseOffset,
+) -> tuple[DatetimeIndex, Timedelta]:
     """Return time vector given a bin size."""
     if (not isinstance(timestamp_list, list) or
             not all(isinstance(ts, Timestamp) for ts in timestamp_list)):
@@ -512,18 +497,20 @@ def get_time_range_and_bin_size(timestamp_list: list[Timestamp],
 
     start, end, _ = round_begin_end_timestamps(timestamp_list, bin_size)
     timestamp_range = date_range(start=start, end=end, freq=bin_size)
+
     if isinstance(bin_size, Timedelta):
         return timestamp_range, bin_size
-    if isinstance(bin_size, BaseOffset):
+    elif isinstance(bin_size, BaseOffset):
         return timestamp_range, timestamp_range[1] - timestamp_range[0]
-
-    msg = "Could not get time range."
-    raise ValueError(msg)
+    else:
+        msg = "bin_size must be a Timedelta or BaseOffset."
+        raise TypeError(msg)
 
 
-def round_begin_end_timestamps(timestamp_list: list[Timestamp],
-                    bin_size: Timedelta | BaseOffset,
-                    ) -> (Timestamp, Timestamp, Timedelta):
+def round_begin_end_timestamps(
+    timestamp_list: list[Timestamp],
+    bin_size: Timedelta | BaseOffset,
+) -> tuple[Timestamp, Timestamp, Timedelta]:
     """Return time vector given a bin size."""
     if (not isinstance(timestamp_list, list) or
             not all(isinstance(ts, Timestamp) for ts in timestamp_list)):
diff --git a/src/post_processing/utils/filtering_utils.py b/src/post_processing/utils/filtering_utils.py
index d4c3301..16cd35a 100644
--- a/src/post_processing/utils/filtering_utils.py
+++ b/src/post_processing/utils/filtering_utils.py
@@ -4,6 +4,7 @@
 
 import bisect
 import csv
+import datetime
 from typing import TYPE_CHECKING
 
 import pytz
@@ -68,7 +69,7 @@ def filter_by_time(
     if end is not None:
         df = df[df["end_datetime"] <= end]
         if df.empty:
-            msg = f"No detection found after '{end}'."
+            msg = f"No detection found before '{end}'."
             raise ValueError(msg)
 
     return df
@@ -81,9 +82,6 @@ def filter_by_annotator(
     """Filter a DataFrame based on annotator selection."""
     list_annotators = get_annotators(df)
 
-    if not annotator:
-        return df
-
     if isinstance(annotator, str):
         ensure_in_list(annotator, list_annotators, "annotator")
         return df[df["annotator"] == annotator]
@@ -101,9 +99,6 @@ def filter_by_label(
     """Filter a DataFrame based on label selection."""
     list_labels = get_labels(df)
 
-    if not label:
-        return df
-
     if isinstance(label, str):
         ensure_in_list(label, list_labels, "label")
         return df[df["annotation"] == label]
@@ -192,16 +187,24 @@ def get_dataset(df: DataFrame) -> list[str]:
     return datasets if len(datasets) > 1 else datasets[0]
 
 
-def get_timezone(df: DataFrame):
-    """Return timezone(s) from DataFrame."""
+def get_canonical_tz(tz):
+    """Return timezone of object as a pytz timezone."""
+    if isinstance(tz, datetime.timezone):
+        if tz == datetime.timezone.utc:
+            return pytz.utc
+        offset_minutes = int(tz.utcoffset(None).total_seconds() / 60)
+        return pytz.FixedOffset(offset_minutes)
+    if hasattr(tz, "zone") and tz.zone:
+        return pytz.timezone(tz.zone)
+    if hasattr(tz, "key"):
+        return pytz.timezone(tz.key)
+    else:
+        msg = f"Unknown timezone: {tz}"
+        raise TypeError(msg)
 
-    def get_canonical_tz(tz):
-        if hasattr(tz, "zone") and tz.zone:
-            return pytz.timezone(tz.zone)
-        if hasattr(tz, "key"):
-            return pytz.timezone(tz.key)
-        return pytz.UTC
 
+def get_timezone(df: DataFrame):
+    """Return timezone(s) from DataFrame."""
     timezones = {get_canonical_tz(ts.tzinfo) for ts in df["start_datetime"]}
 
     if len(timezones) == 1:
diff --git a/tests/test_audio_utils.py b/tests/test_audio_utils.py
index 35c3407..2a0eb27 100644
--- a/tests/test_audio_utils.py
+++ b/tests/test_audio_utils.py
@@ -19,8 +19,6 @@ def test_normalize_audio_default_folder(sample_audio: Path, tmp_path: Path) -> N
 
 def test_normalize_audio_custom_folder(sample_audio: Path, tmp_path: Path) -> None:
     out_folder = tmp_path / "output"
-    out_folder.mkdir()
-
     normalize_audio(sample_audio, output_folder=out_folder)
 
     normalized_file = out_folder / sample_audio.name
diff --git a/tests/test_core_utils.py b/tests/test_core_utils.py
index dd5576e..4264911 100644
--- a/tests/test_core_utils.py
+++ b/tests/test_core_utils.py
@@ -1,4 +1,7 @@
+from unittest.mock import patch
+
 import pytest
+from matplotlib import pyplot as plt
 from pandas import DataFrame, Timedelta, Timestamp, date_range
 from pandas.tseries import frequencies
 from pytz import timezone
@@ -15,6 +18,10 @@
     localize_timestamps,
     round_begin_end_timestamps,
     timedelta_to_str,
+    add_season_period,
+    add_recording_period,
+    set_bar_height,
+    json2df,
 )
 
 
@@ -38,7 +45,7 @@ def fake_box(msg: str, title: str, fields: list[str]) -> None:
 
 
 def test_coordinates_invalid_then_valid_input(monkeypatch: pytest.MonkeyPatch) -> None:
-    inputs = [["900", "50"], ["45", "100"]]  # first invalid, then valid
+    inputs = [["900", "50"], ["45", "900"], ["45", "100"]]
 
     def fake_box(msg: str, title: str, fields: list[str]) -> list[str]:
         return inputs.pop(0)
@@ -49,7 +56,7 @@ def fake_box(msg: str, title: str, fields: list[str]) -> list[str]:
 
 
 def test_coordinates_non_numeric_input(monkeypatch: pytest.MonkeyPatch) -> None:
-    inputs = [["abc", "-20"], ["10", "-20"]]
+    inputs = [["abc", "-20"], ["-20", "abc"], ["10", "-20"]]
 
     def fake_box(msg: str, title: str, fields: list[str]) -> list[str]:
         return inputs.pop(0)
@@ -127,11 +134,12 @@ def test_get_sun_times_valid_input(start: Timestamp,
          -1.5167),
     ],
 )
-def test_get_sun_times_naive_timestamps(start: Timestamp,
-                                        stop: Timestamp,
-                                        lat: float,
-                                        lon: float,
-                                        ) -> None:
+def test_get_sun_times_naive_timestamps(
+    start: Timestamp,
+    stop: Timestamp,
+    lat: float,
+    lon: float,
+) -> None:
     with pytest.raises(ValueError, match="start and stop must be timezone-aware"):
         get_sun_times(start, stop, lat, lon)
 
@@ -369,14 +377,106 @@ def test_round_begin_end_timestamps_valid_entry_2() -> None:
 def test_timedelta_to_str(td, expected) -> None:
     assert timedelta_to_str(td) == expected
 
+
 # %% add_weak_detection / json2df
 
 
 def test_add_wd(sample_df: DataFrame) -> None:
     df_only_wd = sample_df[sample_df["is_box"] == 1]
-    strong_det = sample_df[sample_df["is_box"] == 0].iloc[0]
-    add_weak_detection(df=df_only_wd.copy(),
-                       datetime_format="%Y_%m_%d_%H_%M_%S",
-                       max_time=strong_det["end_time"],
-                       max_freq=strong_det["end_frequency"],
-                       )
+    add_weak_detection(
+        df=df_only_wd.copy(),
+        datetime_format="%Y_%m_%d_%H_%M_%S",
+    )
+
+
+# %% add_season_period
+
+def test_add_season_valid() -> None:
+    fig, ax = plt.subplots()
+    start = Timestamp("2025-01-01T00:00:00+00:00")
+    stop = Timestamp("2025-01-02T00:00:00+00:00")
+
+    ts = date_range(start=start, end=stop, freq="H", tz="UTC")
+    values = list(range(len(ts)))
+    ax.plot(ts, values)
+    add_season_period(ax=ax)
+
+
+def test_add_season_no_data() -> None:
+    fig, ax = plt.subplots()
+    with pytest.raises(ValueError, match=r"have no data"):
+        add_season_period(ax=ax)
+
+# %% add_recording_period
+
+def test_add_recording_period_valid() -> None:
+    fig, ax = plt.subplots()
+    start = Timestamp("2025-01-01T00:00:00+00:00")
+    stop  = Timestamp("2025-01-02T00:00:00+00:00")
+
+    ts = date_range(start=start, end=stop, freq="H", tz="UTC")
+    values = list(range(len(ts)))
+    ax.plot(ts, values)
+
+    df = DataFrame(
+        data=[
+            [
+                Timestamp("2025-01-01T00:00:00+00:00"),
+                Timestamp("2025-01-02T00:00:00+00:00"),
+            ]
+        ],
+        columns=["deployment_date", "recovery_date"],
+    )
+    add_recording_period(df=df, ax=ax)
+
+
+def test_add_recording_period_no_data() -> None:
+    fig, ax = plt.subplots()
+    df = DataFrame()
+    with pytest.raises(ValueError, match=r"have no data"):
+        add_recording_period(df=df, ax=ax)
+
+# %% set_bar_height
+
+def test_set_bar_height_valid() -> None:
+    fig, ax = plt.subplots()
+    start = Timestamp("2025-01-01T00:00:00+00:00")
+    stop = Timestamp("2025-01-02T00:00:00+00:00")
+
+    ts = date_range(start=start, end=stop, freq="H", tz="UTC")
+    values = list(range(len(ts)))
+    ax.plot(ts, values)
+
+    set_bar_height(ax=ax)
+
+
+def test_set_bar_height_no_data() -> None:
+    fig, ax = plt.subplots()
+    with pytest.raises(ValueError, match=r"have no data"):
+        set_bar_height(ax=ax)
+
+# %% json2df
+
+def test_json2df_valid(tmp_path):
+    fake_json = {
+        "deployment_date": "2025-01-01T00:00:00+00:00",
+        "recovery_date": "2025-01-02T00:00:00+00:00",
+    }
+
+    json_file = tmp_path / "metadatax.json"
+    json_file.write_text("{}", encoding="utf-8")
+
+    with patch("json.load", return_value=fake_json):
+        df = json2df(json_file)
+
+    expected = DataFrame(
+        data=[
+            [
+                Timestamp("2025-01-01T00:00:00+00:00"),
+                Timestamp("2025-01-02T00:00:00+00:00"),
+            ]
+        ],
+        columns=["deployment_date", "recovery_date"],
+    )
+
+    assert df.equals(expected)
\ No newline at end of file
diff --git a/tests/test_filtering_utils.py b/tests/test_filtering_utils.py
index 93021a0..4bb4eed 100644
--- a/tests/test_filtering_utils.py
+++ b/tests/test_filtering_utils.py
@@ -1,9 +1,10 @@
 import csv
 from pathlib import Path
+from zoneinfo import ZoneInfo
 
 import pytest
 import pytz
-from pandas import DataFrame, Timedelta, Timestamp, date_range
+from pandas import DataFrame, Timedelta, Timestamp, date_range, concat, to_datetime
 
 from post_processing.utils.filtering_utils import (
     filter_by_annotator,
@@ -21,6 +22,9 @@
     get_timezone,
     read_dataframe,
     reshape_timebin,
+    get_canonical_tz,
+    ensure_no_invalid,
+    intersection_or_union,
 )
 
 # %% find delimiter
@@ -60,21 +64,56 @@ def test_find_delimiter_empty_file(tmp_path: Path) -> None:
 # %% filter utils
 
 # filter_by_time
-def test_filter_by_time_begin(sample_df: DataFrame) -> None:
-    ts = sample_df["start_datetime"].iloc[4]
-    df = filter_by_time(sample_df, begin=ts, end=None)
-    assert (df["start_datetime"] >= ts).all()
-
-
-def test_filter_by_time_end(sample_df: DataFrame) -> None:
-    ts = sample_df["end_datetime"].iloc[4]
-    df = filter_by_time(sample_df, begin=None, end=ts)
-    assert (df["end_datetime"] <= ts).all()
-
-
-def test_filter_by_time_out_of_range(sample_df: DataFrame) -> None:
-    with pytest.raises(ValueError, match="No detection found after '2050"):
-        filter_by_time(sample_df, begin=Timestamp("2050-01-01", tz="utc"), end=None)
+@pytest.mark.parametrize(
+    "begin, end",
+    [
+        pytest.param(
+            Timestamp("2020-01-01", tz="utc"),
+            None,
+            id="valid_begin_only",
+        ),
+        pytest.param(
+            None,
+            Timestamp("2030-01-01", tz="utc"),
+            id="valid_end_only",
+        ),
+        pytest.param(
+            Timestamp("2020-01-01", tz="utc"),
+            Timestamp("2030-01-01", tz="utc"),
+            id="valid_begin_and_end",
+        ),
+    ],
+)
+def test_filter_by_time_valid(sample_df: DataFrame, begin, end):
+    result = filter_by_time(sample_df, begin=begin, end=end)
+
+    assert not result.empty
+    if begin is not None:
+        assert (result["start_datetime"] >= begin).all()
+    if end is not None:
+        assert (result["end_datetime"] <= end).all()
+
+
+@pytest.mark.parametrize(
+    "begin, end, expected_msg",
+    [
+        pytest.param(
+            Timestamp("2050-01-01", tz="utc"),
+            None,
+            "No detection found after '2050",
+            id="out_of_range_begin",
+        ),
+        pytest.param(
+            None,
+            Timestamp("1900-01-01", tz="utc"),
+            "No detection found before '1900",
+            id="out_of_range_end",
+        ),
+    ],
+)
+def test_filter_by_time_out_of_range(sample_df: DataFrame, begin, end, expected_msg):
+    with pytest.raises(ValueError, match=expected_msg):
+        filter_by_time(sample_df, begin=begin, end=end)
 
 
 # filter_by_annotator
@@ -109,23 +148,58 @@ def test_filter_by_label_invalid(sample_df: DataFrame) -> None:
         filter_by_label(sample_df, "hihi")
 
 
-# filter_by_freq
-def test_filter_by_freq_min(sample_df: DataFrame) -> None:
-    freq_min = 500
-    df = filter_by_freq(sample_df, f_min=freq_min, f_max=None)
-    assert (df["start_frequency"] >= freq_min).all()
-
-
-def test_filter_by_freq_max(sample_df: DataFrame) -> None:
-    freq_max = 60000
-    df = filter_by_freq(sample_df, f_min=None, f_max=freq_max)
-    assert (df["end_frequency"] <= freq_max).all()
+@pytest.mark.parametrize(
+    "f_min, f_max",
+    [
+        pytest.param(
+            500,     # valid lower bound
+            None,
+            id="valid_f_min_only",
+        ),
+        pytest.param(
+            None,
+            60000,   # valid upper bound
+            id="valid_f_max_only",
+        ),
+        pytest.param(
+            500,
+            60000,
+            id="valid_f_min_and_f_max",
+        ),
+    ],
+)
+def test_filter_by_freq_valid(sample_df: DataFrame, f_min, f_max):
+    result = filter_by_freq(sample_df, f_min=f_min, f_max=f_max)
+
+    assert not result.empty
+
+    if f_min is not None:
+        assert (result["start_frequency"] >= f_min).all()
+    if f_max is not None:
+        assert (result["end_frequency"] <= f_max).all()
+
+@pytest.mark.parametrize(
+    "f_min, f_max, expected_msg",
+    [
+        pytest.param(
+            1e8,
+            None,
+            "No detection found above",
+            id="out_of_range_f_min",
+        ),
+        pytest.param(
+            None,
+            1,
+            "No detection found below",
+            id="out_of_range_f_max",
+        ),
+    ],
+)
 
 
-def test_filter_by_freq_no_results(sample_df: DataFrame) -> None:
-    freq_min = 144000
-    with pytest.raises(ValueError, match=f"No detection found above {int(freq_min)}Hz"):
-        filter_by_freq(sample_df, f_min=freq_min, f_max=None)
+def test_filter_by_freq_out_of_range(sample_df: DataFrame, f_min, f_max, expected_msg):
+    with pytest.raises(ValueError, match=expected_msg):
+        filter_by_freq(sample_df, f_min=f_min, f_max=f_max)
 
 
 # filter_by_score
@@ -146,11 +220,24 @@ def test_filter_by_score_missing_column(sample_df: DataFrame) -> None:
 
 
 # filter_weak_strong_detection
-def test_filter_weak_only(sample_df: DataFrame) -> None:
+def test_filter_weak_only_is_box_colum(sample_df: DataFrame) -> None:
     df = filter_strong_detection(sample_df)
     assert set(df["is_box"]) == {0}
 
 
+def test_filter_weak_only_type_column(sample_df: DataFrame) -> None:
+    sample_df = sample_df.rename(columns={"is_box": "type"})
+    sample_df["type"] = ["WEAK" if not cell else "BOX" for cell in sample_df["type"]]
+    df = filter_strong_detection(sample_df)
+    assert set(df["type"]) == {"WEAK"}
+
+
+def test_filter_weak_only_invalid() -> None:
+    invalid_df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    with pytest.raises(ValueError, match="Could not determine annotation type"):
+        filter_strong_detection(invalid_df)
+
+
 def test_filter_weak_empty(sample_df: DataFrame) -> None:
     with pytest.raises(ValueError, match="No weak detection found"):
         filter_strong_detection(sample_df[sample_df["is_box"] == 1])
@@ -180,11 +267,58 @@ def test_get_dataset(sample_df: DataFrame) -> None:
     assert get_dataset(sample_df) == sample_df["dataset"].iloc[0]
 
 
+@pytest.mark.parametrize(
+    "input_tz, expected",
+    [
+        (pytz.timezone("Europe/Samara"), pytz.timezone("Europe/Samara")),
+        (ZoneInfo("Pacific/Pago_Pago"), pytz.timezone("Pacific/Pago_Pago")),
+    ],
+)
+def test_get_canonical_tz_valid(input_tz, expected):
+    result = get_canonical_tz(input_tz)
+    assert result == expected
+
+
+def test_get_canonical_tz_raises_on_unknown():
+    class DummyTZ:
+        pass
+
+    dummy = DummyTZ()
+    with pytest.raises(TypeError) as exc:
+        get_canonical_tz(dummy)
+
+    assert "Unknown timezone" in str(exc.value)
+
+
 def test_get_timezone_single(sample_df: DataFrame) -> None:
     tz = get_timezone(sample_df)
     assert tz == pytz.utc
 
 
+def test_get_timezone_several(sample_df: DataFrame) -> None:
+    new_row = {
+        "dataset": "dataset",
+        "filename": "filename",
+        "start_time": 0,
+        "end_time": 2,
+        "start_frequency": 100,
+        "end_frequency": 200,
+        "annotation": "annotation",
+        "annotator": "annotator",
+        "start_datetime": Timestamp("2025-01-27 06:00:00.000000+07:00"),
+        "end_datetime": Timestamp("2025-01-27 06:00:00.000000+07:00"),
+        "is_box": 1,
+        "score": None,
+    }
+    sample_df = concat(
+        [sample_df, DataFrame([new_row])],
+        ignore_index=False
+    )
+    tz = get_timezone(sample_df)
+    assert len(tz) == 2
+    assert pytz.UTC in tz
+    assert pytz.FixedOffset(420) in tz
+
 # %% read DataFrame
 
 def test_read_dataframe_comma_delimiter(tmp_path: Path) -> None:
@@ -239,14 +373,38 @@ def test_read_dataframe_nrows(tmp_path: Path) -> None:
     assert len(df) == 1
     assert df.iloc[0]["annotation"] in {"whale", "dolphin"}
 
-# %% reshape_timebin
 
+# %% reshape_timebin
 
 def test_no_timebin_returns_original(sample_df: DataFrame) -> None:
     df_out = reshape_timebin(sample_df, timebin_new=None)
     assert df_out.equals(sample_df)
 
 
+def test_no_timebin_several_tz(sample_df: DataFrame) -> None:
+    new_row = {
+        "dataset": "dataset",
+        "filename": "filename",
+        "start_time": 0,
+        "end_time": 2,
+        "start_frequency": 100,
+        "end_frequency": 200,
+        "annotation": "annotation",
+        "annotator": "annotator",
+        "start_datetime": Timestamp("2025-01-27 06:00:00.000000+07:00"),
+        "end_datetime": Timestamp("2025-01-27 06:00:00.000000+07:00"),
+        "is_box": 1,
+        "score": None,
+    }
+    sample_df = concat(
+        [sample_df, DataFrame([new_row])],
+        ignore_index=False
+    )
+
+    df_out = reshape_timebin(sample_df, timebin_new=None)
+    assert df_out.equals(sample_df)
+
+
 def test_no_timebin_original_timebin(sample_df: DataFrame) -> None:
     df_out = reshape_timebin(sample_df, timebin_new=Timedelta("1min"))
     expected = DataFrame(
@@ -365,3 +523,66 @@ def test_with_manual_timestamps_vector(sample_df: DataFrame) -> None:
 def test_empty_result_when_no_matching(sample_df: DataFrame) -> None:
     with pytest.raises(ValueError, match="DataFrame is empty"):
         reshape_timebin(DataFrame(), Timedelta(hours=1))
+
+
+# %% ensure_no_invalid
+
+def test_ensure_no_invalid_empty() -> None:
+    try:
+        ensure_no_invalid([], "label")
+    except ValueError:
+        pytest.fail("ensure_no_invalid raised ValueError unexpectedly.")
+
+
+def test_ensure_no_invalid_with_elements() -> None:
+    invalid_items = ["foo", "bar"]
+    with pytest.raises(ValueError) as exc_info:
+        ensure_no_invalid(invalid_items, "columns")
+
+    assert "foo" in str(exc_info.value)
+    assert "bar" in str(exc_info.value)
+    assert "columns" in str(exc_info.value)
+
+def test_ensure_no_invalid_single_element() -> None:
+    invalid_items = ["baz"]
+    with pytest.raises(ValueError) as exc_info:
+        ensure_no_invalid(invalid_items, "features")
+    assert "baz" in str(exc_info.value)
+    assert "features" in str(exc_info.value)
+
+# %% intersection / union
+
+def test_intersection(sample_df) -> None:
+    df_result = intersection_or_union(sample_df[sample_df["annotator"].isin(["ann1", "ann2"])], user_sel="intersection")
+
+    assert set(df_result["annotation"]) == {"lbl1", "lbl2"}
+    assert set(df_result["annotator"]) == {"ann1 ∩ ann2"}
+
+
+def test_union(sample_df) -> None:
+    df_result = intersection_or_union(sample_df[sample_df["annotator"].isin(["ann1", "ann2"])], user_sel="union")
+
+    assert set(df_result["annotation"]) == {"lbl1", "lbl2"}
+    assert set(df_result["annotator"]) == {"ann1 ∪ ann2"}
+
+
+def test_all_user_sel_returns_original(sample_df) -> None:
+    df_result = intersection_or_union(sample_df, user_sel="all")
+
+    assert len(df_result) == len(sample_df)
+
+
+def test_invalid_user_sel_raises(sample_df) -> None:
+    with pytest.raises(ValueError, match="'user_sel' must be either 'intersection' or 'union'"):
+        intersection_or_union(sample_df, user_sel="invalid")
+
+
+def test_not_enough_annotators_raises() -> None:
+    df_single_annotator = DataFrame({
+        "annotation": ["cat"],
+        "start_datetime": to_datetime(["2025-01-01 10:00"]),
+        "end_datetime": to_datetime(["2025-01-01 10:01"]),
+        "annotator": ["A"]
+    })
+    with pytest.raises(ValueError, match="Not enough annotators detected"):
+        intersection_or_union(df_single_annotator, user_sel="intersection")
\ No newline at end of file
diff --git a/tests/test_glider_utils.py b/tests/test_glider_utils.py
index 5ccd047..12d83df 100644
--- a/tests/test_glider_utils.py
+++ b/tests/test_glider_utils.py
@@ -54,8 +54,10 @@ def test_get_position_from_timestamp(nav_df: DataFrame) -> None:
     assert all(isinstance(x, float) for x in lat)
 
 
-def test_plot_detections_with_nav_data(df_detections: DataFrame,
-                                       nav_df: DataFrame) -> None:
+def test_plot_detections_with_nav_data(
+        df_detections: DataFrame,
+        nav_df: DataFrame
+) -> None:
     plot_detections_with_nav_data(
         df=df_detections,
         nav=nav_df,
diff --git a/tests/test_metric_utils.py b/tests/test_metric_utils.py
new file mode 100644
index 0000000..34ce769
--- /dev/null
+++ b/tests/test_metric_utils.py
@@ -0,0 +1,15 @@
+import pytest
+from pandas import DataFrame
+
+from post_processing.utils.metrics_utils import detection_perf
+
+def test_detection_perf(sample_df: DataFrame) -> None:
+    try:
+        detection_perf(df=sample_df[sample_df["annotator"].isin(["ann1", "ann4"])], ref=("ann1", "lbl1"))
+    except ValueError:
+        pytest.fail("test_detection_perf raised ValueError unexpectedly.")
+
+
+def test_detection_perf_one_annotator(sample_df: DataFrame) -> None:
+    with pytest.raises(ValueError, match="Two annotators needed"):
+        detection_perf(df=sample_df[sample_df["annotator"] == "ann1"], ref=("ann1", "lbl1"))
\ No newline at end of file