Inlay intervals algorithm tests

from typing import Callable
from unittest import TestCase
from data_interval import DataInterval, inlay_data_intervals


def _example():
    # data intervals (example):
    #    0    1    2    3    4    5    6    7    8    9    10
    # 1            [___]
    # 2    [___________________________________]
    # 3    [_______]
    # 8        [_______________________]
    # 7                        [___________________]
    # 6                                    [___]
    # 4        [_______________________]

    # (data, start, stop)
    intervals = [
        DataInterval(data, start, stop) for (data, start, stop) in [
            (0, 9, 2),
            (0, 2, 3),
            (1, 7, 8),
            (1, 7, 4),
            (3, 4, 1),
            (5, 10, 5),
            (8, 9, 6),
        ]
    ]

class TestInlayTwoIntervals(TestCase):
    extract_value: Callable[[DataInterval], float] = lambda interv: (-interv.data, (interv.stop - interv.start), -interv.start)

    # All cases for two intervals:
    #    0    1    2    3    4    5    6    7    8    9
    #                   [______________]
    #
    #  1 [_________]    |              |                 altc_altd_bltc_bltd
    #  2      [_________]              |                 altc_altd_beqc_bltd
    #  3           [_________]         |                 altc_altd_bgtc_bltd
    #  4                [_________]    |                 aeqc_altd_bgtc_bltd
    #  5                |     [___]    |                 agtc_altd_bgtc_bltd
    #  6                [______________]                 aeqc_altd_bgtc_beqd
    #  7           [___________________]                 altc_altd_bgtc_beqd
    #  8           [________________________]            altc_altd_bgtc_bgtd
    #  9                [___________________]            aeqc_altd_bgtc_bgtd
    # 10                |    [_________]                 agtc_altd_bgtc_beqd
    # 11                |         [_________]            agtc_altd_bgtc_bgtd
    # 12                |              [_________]       agtc_aeqb_bgtc_bgtd
    # 13                |              |    [_________]  agtc_agtd_bgtc_bgtd

    def lists_are_equal(self, nums1: list[float], nums2: list[float]):
        return nums1 == nums2

    def build_error_message(self, inputs, expected, actual):
        return 'Test FAILED!\n' + \
            f'inputs: {[self.from_data_interval(interval) for interval in inputs]},\n' + \
            f'expected: {[self.from_data_interval(interval) for interval in expected]},\n' + \
            f'actual: {[self.from_data_interval(interval) for interval in actual]}\n'

    def from_data_interval(self, interval: DataInterval):
        return (interval.data, interval.start, interval.stop)

    # value left > value right
    def test_max_altc_altd_bltc_bltd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 0, 2)]]
        expected = [DataInterval(*params) for params in [(1, 0, 2), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_beqc_bltd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 1, 3)]]
        expected = [DataInterval(*params) for params in [(1, 1, 3), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_bltd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 2, 4)]]
        expected = [DataInterval(*params) for params in [(1, 2, 3), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_bltd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 3, 5)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_bltd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 4, 5)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_beqd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 3, 6)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_beqd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 2, 6)]]
        expected = [DataInterval(*params) for params in [(1, 2, 3), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_bgtd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 2, 7)]]
        expected = [DataInterval(*params) for params in [(1, 2, 3), (2, 3, 6), (1, 6, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_bgtd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 3, 7)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (1, 6, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_beqd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 4, 6)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_bgtd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 5, 7)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (1, 6, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_aeqb_bgtc_bgtd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 6, 8)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (1, 6, 8)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_agtd_bgtc_bgtd_abgtcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (1, 7, 9)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (1, 7, 9)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    # value left == value right
    def test_max_altc_altd_bltc_bltd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 0, 2)]]
        expected = [DataInterval(*params) for params in [(2, 0, 2), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_beqc_bltd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 1, 3)]]
        expected = [DataInterval(*params) for params in [(2, 1, 3), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_bltd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 2, 4)]]
        expected = [DataInterval(*params) for params in [(2, 2, 4), (2, 4, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_bltd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 3, 5)]]
        expected = [DataInterval(*params) for params in [(2, 3, 5), (2, 5, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_bltd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 4, 5)]]
        expected = [DataInterval(*params) for params in [(2, 3, 4), (2, 4, 5), (2, 5, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_beqd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 3, 6)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_beqd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 2, 6)]]
        expected = [DataInterval(*params) for params in [(2, 2, 3), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_bgtd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 2, 7)]]
        expected = [DataInterval(*params) for params in [(2, 2, 3), (2, 3, 6), (2, 6, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_bgtd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 3, 7)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (2, 6, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_beqd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 4, 6)]]
        expected = [DataInterval(*params) for params in [(2, 3, 4), (2, 4, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_bgtd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 5, 7)]]
        expected = [DataInterval(*params) for params in [(2, 3, 5), (2, 5, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_aeqb_bgtc_bgtd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 6, 8)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (2, 6, 8)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_agtd_bgtc_bgtd_abeqcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (2, 7, 9)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (2, 7, 9)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    # value left < value right
    def test_max_altc_altd_bltc_bltd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 0, 2)]]
        expected = [DataInterval(*params) for params in [(3, 0, 2), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_beqc_bltd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 1, 3)]]
        expected = [DataInterval(*params) for params in [(3, 1, 3), (2, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_bltd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 2, 4)]]
        expected = [DataInterval(*params) for params in [(3, 2, 4), (2, 4, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_bltd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 3, 5)]]
        expected = [DataInterval(*params) for params in [(3, 3, 5), (2, 5, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_bltd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 4, 5)]]
        expected = [DataInterval(*params) for params in [(2, 3, 4), (3, 4, 5), (2, 5, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_beqd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 3, 6)]]
        expected = [DataInterval(*params) for params in [(3, 3, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_beqd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 2, 6)]]
        expected = [DataInterval(*params) for params in [(3, 2, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_altc_altd_bgtc_bgtd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 2, 7)]]
        expected = [DataInterval(*params) for params in [(3, 2, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_aeqc_altd_bgtc_bgtd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 3, 7)]]
        expected = [DataInterval(*params) for params in [(3, 3, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_beqd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 4, 6)]]
        expected = [DataInterval(*params) for params in [(2, 3, 4), (3, 4, 6)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_altd_bgtc_bgtd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 5, 7)]]
        expected = [DataInterval(*params) for params in [(2, 3, 5), (3, 5, 7)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_aeqb_bgtc_bgtd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 6, 8)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (3, 6, 8)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )

    def test_max_agtc_agtd_bgtc_bgtd_abltcd(self):
        inputs = [DataInterval(*params) for params in [(2, 3, 6), (3, 7, 9)]]
        expected = [DataInterval(*params) for params in [(2, 3, 6), (3, 7, 9)]]
        actual = list(inlay_data_intervals(inputs, key=TestInlayTwoIntervals.extract_value))
        self.assertTrue(
            self.lists_are_equal(
                [self.from_data_interval(interval) for interval in actual],
                [self.from_data_interval(interval) for interval in expected]
            ),
            self.build_error_message(inputs, expected, actual)
        )