# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
#
# This module contains unit tests for the classes in the mtb module

import glob
import os
import sys
import unittest

import common_unittest_utils
import fuzzy
import mtb
import test_conf as conf

from common_unittest_utils import create_mocked_devices
from firmware_constants import AXIS, GV, MTB, PLATFORM, UNIT, VAL
from mtb import FingerPath, TidPacket
from geometry.elements import Point, about_eq


unittest_path_lumpy = os.path.join(os.getcwd(), 'tests/logs/lumpy')
mocked_device = create_mocked_devices()


def get_mtb_packets(gesture_filename):
    """Get mtb_packets object by reading the gesture file."""
    parser = mtb.MtbParser()
    packets = parser.parse_file(gesture_filename)
    mtb_packets = mtb.Mtb(packets=packets)
    return mtb_packets


class FakeMtb(mtb.Mtb):
    """A fake MTB class to set up x and y positions directly."""
    def __init__(self, list_x, list_y):
        self.list_x = list_x
        self.list_y = list_y

    def get_x_y(self, target_slot):
        """Return list_x, list_y directly."""
        return (self.list_x, self.list_y)


class MtbTest(unittest.TestCase):
    """Unit tests for mtb.Mtb class."""

    def setUp(self):
        self.test_dir = os.path.join(os.getcwd(), 'tests')
        self.data_dir = os.path.join(self.test_dir, 'data')

    def _get_filepath(self, filename, gesture_dir=''):
        return os.path.join(self.data_dir, gesture_dir, filename)

    def _get_range_middle(self, criteria):
        """Get the middle range of the criteria."""
        fc = fuzzy.FuzzyCriteria(criteria)
        range_min , range_max = fc.get_criteria_value_range()
        range_middle = (range_min + range_max) / 2.0
        return range_middle

    def _call_get_reversed_motions(self, list_x, list_y, expected_x,
                                   expected_y, direction):
        mtb = FakeMtb(list_x, list_y)
        displacement = mtb.get_reversed_motions(0, direction, ratio=0.1)
        self.assertEqual(displacement[AXIS.X], expected_x)
        self.assertEqual(displacement[AXIS.Y], expected_y)

    def test_get_reversed_motions_no_reversed(self):
        list_x = (10, 22 ,36, 54, 100)
        list_y = (1, 2 ,6, 10, 22)
        self._call_get_reversed_motions(list_x, list_y, 0, 0, GV.TLBR)

    def test_get_reversed_motions_reversed_x_y(self):
        list_x = (10, 22 ,36, 154, 100)
        list_y = (1, 2 ,6, 30, 22)
        self._call_get_reversed_motions(list_x, list_y, -54, -8, GV.TLBR)

    def _test_get_x_y(self, filename, slot, expected_value):
        gesture_filename = self._get_filepath(filename)
        mtb_packets = get_mtb_packets(gesture_filename)
        list_x, list_y = mtb_packets.get_x_y(slot)
        points = zip(list_x, list_y)
        self.assertEqual(len(points), expected_value)

    def test_get_x_y(self):
        self._test_get_x_y('one_finger_with_slot_0.dat', 0, 12)
        self._test_get_x_y('one_finger_without_slot_0.dat', 0, 9)
        self._test_get_x_y('two_finger_with_slot_0.dat', 0, 121)
        self._test_get_x_y('two_finger_with_slot_0.dat', 1, 59)
        self._test_get_x_y('two_finger_without_slot_0.dat', 0, 104)
        self._test_get_x_y('two_finger_without_slot_0.dat', 1, 10)

    def test_get_pressure(self):
        """Test get pressure"""
        filename = 'one_finger_with_slot_0.dat'
        gesture_filename = self._get_filepath(filename)
        mtb_packets = get_mtb_packets(gesture_filename)
        finger_paths = mtb_packets.get_ordered_finger_paths()

        # There is only one tracking ID in the file.
        self.assertEqual(len(finger_paths), 1)

        # Verify some of the pressure values
        finger_path = finger_paths.values()[0]
        list_z = finger_path.get('pressure')
        self.assertEqual(list_z[0:5], [59, 57, 56, 58, 60])

    def test_get_x_y_multiple_slots(self):
        filename = 'x_y_multiple_slots.dat'
        filepath = self._get_filepath(filename)
        mtb_packets = get_mtb_packets(filepath)
        slots = (0, 1)
        list_x, list_y = mtb_packets.get_x_y_multiple_slots(slots)
        expected_list_x = {}
        expected_list_y = {}
        expected_list_x[0] = [1066, 1068, 1082, 1183, 1214, 1285, 1322, 1351,
                              1377, 1391]
        expected_list_y[0] = [561, 559, 542, 426, 405, 358, 328, 313, 304, 297]
        expected_list_x[1] = [770, 769, 768, 758, 697, 620, 585, 565, 538, 538]
        expected_list_y[1] = [894, 894, 895, 898, 927, 968, 996, 1003, 1013,
                              1013]
        for slot in slots:
            self.assertEqual(list_x[slot], expected_list_x[slot])
            self.assertEqual(list_y[slot], expected_list_y[slot])

    def test_get_x_y_multiple_slots2(self):
        """Test slot state machine.

        When the last slot in the previous packet is slot 0, and the first
        slot in the current packet is also slot 0, the slot 0 will not be
        displayed explicitly. This test ensures that the slot stat machine
        is tracked properly.
        """
        filename = 'pinch_to_zoom.zoom_in.dat'
        filepath = self._get_filepath(filename)
        mtb_packets = get_mtb_packets(filepath)
        slots = (0, 1)
        list_x, list_y = mtb_packets.get_x_y_multiple_slots(slots)
        expected_final_x = {}
        expected_final_y = {}
        expected_final_x[0] = 1318
        expected_final_y[0] = 255
        expected_final_x[1] = 522
        expected_final_y[1] = 1232
        for slot in slots:
            self.assertEqual(list_x[slot][-1], expected_final_x[slot])
            self.assertEqual(list_y[slot][-1], expected_final_y[slot])

    def _test_get_all_finger_paths_about_numbers_of_packets(
            self, filename, expected_numbers):
        mtb_packets = get_mtb_packets(self._get_filepath(filename))
        finger_paths = mtb_packets.get_ordered_finger_paths()
        for tid, expected_len in expected_numbers.items():
            self.assertEqual(len(finger_paths[tid].tid_packets), expected_len)

    def test_get_ordered_finger_paths_about_number_of_packets(self):
        self._test_get_all_finger_paths_about_numbers_of_packets(
                'two_finger_with_slot_0.dat', {2101: 122, 2102: 60})
        self._test_get_all_finger_paths_about_numbers_of_packets(
                'two_finger_without_slot_0.dat', {2097: 105, 2098: 11})

    def test_data_ready(self):
        """Test data_ready flag when point.x could be 0."""
        filename = ('20130506_030025-fw_11.27-robot_sim/'
                    'one_finger_to_edge.center_to_left.slow-lumpy-fw_11.27-'
                    'robot_sim-20130506_031554.dat')
        filepath = os.path.join(unittest_path_lumpy, filename)
        mtb_packets = get_mtb_packets(filepath)
        points = mtb_packets.get_ordered_finger_path(0, 'point')
        # Note:
        # 1. In the first packet, there exists the event ABS_PRESSURE
        #    but no ABS_MT_PRESSURE.
        # 2. The last packet with ABS_MT_TRACKING_ID = -1 is also counted.
        self.assertEqual(len(points), 78)

    def _test_drumroll(self, filename, expected_max_distance):
        """expected_max_distance: unit in pixel"""
        gesture_filename = self._get_filepath(filename)
        mtb_packets = get_mtb_packets(gesture_filename)
        actual_max_distance = mtb_packets.get_max_distance_of_all_tracking_ids()
        self.assertTrue(about_eq(actual_max_distance, expected_max_distance))

    def test_drumroll(self):
        expected_max_distance = 52.0216301167
        self._test_drumroll('drumroll_lumpy.dat', expected_max_distance)

    def test_drumroll1(self):
        expected_max_distance = 43.5660418216
        self._test_drumroll('drumroll_lumpy_1.dat', expected_max_distance)

    def test_drumroll_link(self):
        expected_max_distance = 25.6124969497
        self._test_drumroll('drumroll_link.dat', expected_max_distance)

    def test_no_drumroll_link(self):
        expected_max_distance = 2.91547594742
        self._test_drumroll('no_drumroll_link.dat', expected_max_distance)

    def test_no_drumroll_link(self):
        expected_max_distance = 24.8243831746
        self._test_drumroll('drumroll_link_2.dat', expected_max_distance)

    def _test_finger_path(self, filename, tid, expected_slot, expected_data,
                          request_data_ready=True):
        """Test the data in a finger path"""
        # Instantiate the expected finger_path
        expected_finger_path = FingerPath(expected_slot,
                                          [TidPacket(time, Point(*xy), z)
                                          for time, xy, z in expected_data])

        # Derive the actual finger_path for the specified tid
        mtb_packets = get_mtb_packets(self._get_filepath(filename))
        finger_paths = mtb_packets.get_ordered_finger_paths(request_data_ready)
        actual_finger_path = finger_paths[tid]

        # Assert that the packet lengths are the same.
        self.assertEqual(len(expected_finger_path.tid_packets),
                         len(actual_finger_path.tid_packets))

        # Assert that all tid data (including syn_time, point, pressure, etc.)
        # in the tid packets are the same.
        for i in range(len(actual_finger_path.tid_packets)):
            expected_packet = expected_finger_path.tid_packets[i]
            actual_packet = actual_finger_path.tid_packets[i]
            self.assertEqual(expected_packet.syn_time, actual_packet.syn_time)
            self.assertTrue(expected_packet.point == actual_packet.point)
            self.assertEqual(expected_packet.pressure, actual_packet.pressure)

    def test_get_ordered_finger_paths(self):
        """Test get_ordered_finger_paths

        Tracking ID 95: slot 0 (no explicit slot 0 assigned).
                        This is the only slot in the packet.
        """
        filename = 'drumroll_link_2.dat'
        tid = 95
        expected_slot = 0
        expected_data = [# (syn_time,    (x,   y),   z)
                         (238154.686034, (789, 358), 59),
                         (238154.691606, (789, 358), 60),
                         (238154.697058, (789, 358), 57),
                         (238154.702576, (789, 358), 59),
                         (238154.713731, (789, 358), 57),
                         (238154.719160, (789, 359), 57),
                         (238154.724791, (789, 359), 56),
                         (238154.730111, (789, 359), 58),
                         (238154.735588, (788, 359), 53),
                         (238154.741068, (788, 360), 53),
                         (238154.746569, (788, 360), 49),
                         (238154.752108, (787, 360), 40),
                         (238154.757705, (787, 361), 27),
                         (238154.763075, (490, 903), 46),
                         (238154.768532, (486, 892), 61),
                         (238154.774695, (484, 895), 57),
                         (238154.780192, (493, 890), 56),
                         (238154.785651, (488, 893), 55),
                         (238154.791140, (488, 893), 56),
                         (238154.802080, (489, 893), 55),
                         (238154.807578, (490, 893), 50),
                         (238154.818573, (490, 893), 46),
                         (238154.824066, (491, 893), 36),
                         (238154.829525, (492, 893), 22),
                         (238154.849958, (492, 893), 22),
        ]
        self._test_finger_path(filename, tid, expected_slot, expected_data)

    def test_get_ordered_finger_paths2(self):
        """Test get_ordered_finger_paths

        Tracking ID 104: slot 0 (explicit slot 0 assigned).
                         This is the 2nd slot in the packet.
                         A slot 1 has already existed.
        """

        filename = 'drumroll_link_2.dat'
        tid = 104
        expected_slot = 0
        expected_data = [# (syn_time,    (x,   y),   z)
                         (238157.994296, (780, 373), 75),
                         (238158.001110, (780, 372), 75),
                         (238158.007128, (780, 372), 76),
                         (238158.012617, (780, 372), 73),
                         (238158.018112, (780, 373), 69),
                         (238158.023600, (780, 373), 68),
                         (238158.029542, (781, 373), 51),
                         (238158.049605, (781, 373), 51),
        ]
        self._test_finger_path(filename, tid, expected_slot, expected_data)

    def test_get_ordered_finger_paths2b(self):
        """Test get_ordered_finger_paths

        Tracking ID 103: slot 1 (explicit slot 1 assigned).
                         This tracking ID overlaps with two distinct
                         tracking IDs of which the slot is the same slot 0.
                         This is a good test as a multiple-finger case.

                         tid 102, slot 0 arrived
                         tid 103, slot 1 arrived
                         tid 102, slot 0 left
                         tid 104, slot 0 arrived
                         tid 103, slot 1 left
                         tid 104, slot 0 left
        """
        filename = 'drumroll_link_2.dat'
        tid = 103
        expected_slot = 1
        expected_data = [# (syn_time,    (x,   y),   z)
                         (238157.906405, (527, 901), 71),
                         (238157.911749, (527, 901), 74),
                         (238157.917247, (527, 901), 73),
                         (238157.923152, (527, 902), 71),
                         (238157.928317, (527, 902), 72),
                         (238157.934492, (527, 902), 71),
                         (238157.939984, (527, 902), 69),
                         (238157.945485, (527, 902), 65),
                         (238157.950984, (527, 902), 66),
                         (238157.956482, (527, 902), 70),
                         (238157.961976, (527, 902), 65),
                         (238157.973768, (527, 902), 64),
                         (238157.980491, (528, 901), 61),
                         (238157.987140, (529, 899), 60),
                         (238157.994296, (531, 896), 52),
                         (238158.001110, (534, 892), 34),
                         (238158.007128, (534, 892), 34),
                         (238158.012617, (534, 892), 34),
                         (238158.018112, (534, 892), 34),
                         (238158.023600, (534, 892), 34),
                         (238158.029542, (534, 892), 34),
        ]
        self._test_finger_path(filename, tid, expected_slot, expected_data)

    def test_get_ordered_finger_paths3(self):
        """Test get_ordered_finger_paths

        This is a good test sample.
        - An unusual slot 9
        - This is the 2nd slot in the packet. A slot 8 has already existed.
        - Its ABS_MT_PRESSURE is missing in the first packet.
        - Slot 8 terminates a few packets earlier than this slot.
        - Some of the ABS_MT_POSITION_X/Y and ABS_MT_PRESSURE are not shown.
        """
        filename = 'drumroll_3.dat'
        tid = 582
        expected_slot = 9
        expected_data = [# (syn_time,  (x,   y),   z)
                         (6411.371613, (682, 173), None),
                         (6411.382541, (667, 186), 35),
                         (6411.393355, (664, 189), 37),
                         (6411.404310, (664, 190), 38),
                         (6411.413015, (664, 189), 38),
                         (6411.422118, (665, 189), 38),
                         (6411.430792, (665, 189), 37),
                         (6411.439764, (667, 188), 36),
                         (6411.448484, (675, 185), 29),
                         (6411.457212, (683, 181), 17),
                         (6411.465843, (693, 172), 5),
                         (6411.474749, (469, 381), 6),
                         (6411.483702, (471, 395), 26),
                         (6411.492369, (471, 396), 13),
                         (6411.499916, (471, 396), 13),
        ]
        self._test_finger_path(filename, tid, expected_slot, expected_data,
                               request_data_ready=False)

    def test_get_slot_data(self):
        """Test if it can get the data from the correct slot.

        slot 0 and slot 1 start at the same packet. This test verifies if the
        method uses the correct corresponding slot numbers.
        """
        filename = 'two_finger_tracking.diagonal.slow.dat'
        gesture_filename = self._get_filepath(filename)
        mtb_packets = get_mtb_packets(gesture_filename)

        # There are more packets. Use just a few of them to verify.
        xy_pairs = {
            # Slot 0
            0: [(1142, 191), (1144, 201), (1144, 200)],
            # Slot 1
            1: [(957, 105), (966, 106), (960, 104)],
        }

        number_packets = {
            # Slot 0
            0: 190,
            # Slot 1
            1: 189,
        }

        slots = [0, 1]
        for slot in slots:
            points = mtb_packets.get_slot_data(slot, 'point')
            # Verify the number of packets in each slot
            self.assertEqual(len(points), number_packets[slot])
            # Verify a few packets in each slot
            for i, xy_pair in enumerate(xy_pairs[slot]):
                self.assertTrue(Point(*xy_pair) == points[i])

    def test_convert_to_evemu_format(self):
        evemu_filename = self._get_filepath('one_finger_swipe.evemu.dat')
        mtplot_filename = self._get_filepath('one_finger_swipe.dat')
        packets = mtb.MtbParser().parse_file(mtplot_filename)
        evemu_converted_iter = iter(mtb.convert_to_evemu_format(packets))
        with open(evemu_filename) as evemuf:
            for line_evemu_original in evemuf:
                evemu_original = line_evemu_original.split()
                evemu_converted_str = next(evemu_converted_iter, None)
                self.assertNotEqual(evemu_converted_str, None)
                if evemu_converted_str:
                    evemu_converted = evemu_converted_str.split()
                self.assertEqual(len(evemu_original), 5)
                self.assertEqual(len(evemu_converted), 5)
                # Skip the timestamps for they are different in both formats.
                # Prefix, type, code, and value should be the same.
                for i in [0, 2, 3, 4]:
                    self.assertEqual(evemu_original[i], evemu_converted[i])

    def test_get_largest_gap_ratio(self):
        """Test get_largest_gap_ratio for one-finger and two-finger gestures."""
        # The following files come with noticeable large gaps.
        list_large_ratio = [
            'one_finger_tracking.left_to_right.slow_1.dat',
            'two_finger_gaps.vertical.dat',
            'two_finger_gaps.horizontal.dat',
            'resting_finger_2nd_finger_moving_segment_gaps.dat',
            'gap_new_finger_arriving_or_departing.dat',
            'one_stationary_finger_2nd_finger_moving_gaps.dat',
            'resting_finger_2nd_finger_moving_gaps.dat',
        ]
        gesture_slots = {
            'one_finger': [0,],
            'two_finger': [0, 1],
            'resting_finger': [1,],
            'gap_new_finger': [0,],
            'one_stationary_finger': [1,],
        }

        range_middle = self._get_range_middle(conf.no_gap_criteria)
        gap_data_dir = self._get_filepath('gaps')
        gap_data_filenames = glob.glob(os.path.join(gap_data_dir, '*.dat'))
        for filename in gap_data_filenames:
            mtb_packets = get_mtb_packets(filename)
            base_filename = os.path.basename(filename)

            # What slots to check are based on the gesture name.
            slots = []
            for gesture in gesture_slots:
                if base_filename.startswith(gesture):
                    slots = gesture_slots[gesture]
                    break

            for slot in slots:
                largest_gap_ratio = mtb_packets.get_largest_gap_ratio(slot)
                if base_filename in list_large_ratio:
                    self.assertTrue(largest_gap_ratio >= range_middle)
                else:
                    self.assertTrue(largest_gap_ratio < range_middle)

    def test_get_largest_accumulated_level_jumps(self):
        """Test get_largest_accumulated_level_jumps."""
        dir_level_jumps = 'drag_edge_thumb'

        filenames = [
            # filenames with level jumps
            # ----------------------------------
            'drag_edge_thumb.horizontal.dat',
            'drag_edge_thumb.horizontal_2.dat',
            # test no points in some tracking ID
            'drag_edge_thumb.horizontal_3.no_points.dat',
            'drag_edge_thumb.vertical.dat',
            'drag_edge_thumb.vertical_2.dat',
            'drag_edge_thumb.diagonal.dat',
            # Change tracking IDs quickly.
            'drag_edge_thumb.horizontal_4.change_ids_quickly.dat',

            # filenames without level jumps
            # ----------------------------------
            'drag_edge_thumb.horizontal.curvy.dat',
            'drag_edge_thumb.horizontal_2.curvy.dat',
            'drag_edge_thumb.vertical.curvy.dat',
            'drag_edge_thumb.vertical_2.curvy.dat',
            # Rather small level jumps
            'drag_edge_thumb.horizontal_5.small_level_jumps.curvy.dat',
        ]

        largest_level_jumps = {
            # Large jumps
            'drag_edge_thumb.horizontal.dat': {AXIS.X: 0, AXIS.Y: 97},
            # Smaller jumps
            'drag_edge_thumb.horizontal_2.dat': {AXIS.X: 0, AXIS.Y: 24},
            # test no points in some tracking ID
            'drag_edge_thumb.horizontal_3.no_points.dat':
                    {AXIS.X: 97, AXIS.Y: 88},
            # Change tracking IDs quickly.
            'drag_edge_thumb.horizontal_4.change_ids_quickly.dat':
                    {AXIS.X: 0, AXIS.Y: 14},
            # Large jumps
            'drag_edge_thumb.vertical.dat': {AXIS.X: 54, AXIS.Y: 0},
            # The first slot 0 comes with smaller jumps only.
            'drag_edge_thumb.vertical_2.dat': {AXIS.X: 20, AXIS.Y: 0},
            # Large jumps
            'drag_edge_thumb.diagonal.dat': {AXIS.X: 84, AXIS.Y: 58},
        }

        target_slot = 0
        for filename in filenames:
            filepath = self._get_filepath(filename, gesture_dir=dir_level_jumps)
            packets = get_mtb_packets(filepath)
            displacements = packets.get_displacements_for_slots(target_slot)

            # There are no level jumps in a curvy line.
            file_with_level_jump = 'curvy' not in filename

            # Check the first slot only
            tids = displacements.keys()
            tids.sort()
            tid = tids[0]
            # Check both axis X and axis Y
            for axis in AXIS.LIST:
                disp = displacements[tid][axis]
                jump = packets.get_largest_accumulated_level_jumps(disp)
                # Verify that there are no jumps in curvy files, and
                #        that there are jumps in the other files.
                expected_jump = (0 if not file_with_level_jump
                                   else largest_level_jumps[filename][axis])
                self.assertTrue(jump == expected_jump)

    def test_get_max_distance_from_points(self):
        """Test get_max_distance_from_points"""
        # Two farthest points: (15, 16) and (46, 70)
        list_coordinates_pairs = [
            (20, 25), (21, 35), (15, 16), (25, 22), (30, 32), (46, 70),
            (35, 68), (42, 53), (50, 30), (43, 69), (16, 17), (14, 30),
        ]
        points = [Point(*pairs) for pairs in list_coordinates_pairs]
        mtb_packets = mtb.Mtb(device=mocked_device[PLATFORM.LUMPY])

        # Verify the max distance in pixels
        max_distance_px = mtb_packets.get_max_distance_from_points(points,
                                                                   UNIT.PIXEL)
        expected_max_distance_px = ((46 - 15) ** 2 + (70 - 16) ** 2) ** 0.5
        self.assertAlmostEqual(max_distance_px, expected_max_distance_px)

        # Verify the max distance in mms
        max_distance_mm = mtb_packets.get_max_distance_from_points(points,
                                                                   UNIT.MM)
        expected_max_distance_mm = (((46 - 15) / 12.0) ** 2 +
                                    ((70 - 16) / 10.0) ** 2) ** 0.5
        self.assertAlmostEqual(max_distance_mm, expected_max_distance_mm)

    def _test_get_segments(self, list_t, list_coord, expected_segments, ratio):
        """Test get_segments

        @param expected_segments: a dictionary of
                {segment_flag: expected_segment_indexes}
        """
        mtb_packets = mtb.Mtb(device=mocked_device[PLATFORM.LUMPY])
        for segment_flag, (expected_segment_t, expected_segment_coord) in \
                expected_segments.items():
            segment_t, segment_coord = mtb_packets.get_segments(
                    list_t, list_coord, segment_flag, ratio)
            self.assertEqual(segment_t, expected_segment_t)
            self.assertEqual(segment_coord, expected_segment_coord)

    def test_get_segments_by_distance(self):
        """Test get_segments_by_distance

        In the test case below,
            min_coord = 100
            max_coord = 220
            max_distance = max_coord - min_coord = 220 - 100 = 120
            ratio = 0.1
            120 * 0.1 = 12
            begin segment: 100 ~ 112
            end segment: 208 ~ 220
        """
        list_coord = [102, 101, 101, 100, 100, 103, 104, 110, 118, 120,
                      122, 124, 131, 140, 150, 160, 190, 210, 217, 220]
        list_t = [1000 + 0.012 * i for i in range(len(list_coord))]
        ratio = 0.1
        expected_segments= {
                VAL.WHOLE: (list_t, list_coord),
                VAL.MIDDLE: (list_t[8:17], list_coord[8:17]),
                VAL.BEGIN: (list_t[:8], list_coord[:8]),
                VAL.END: (list_t[17:], list_coord[17:]),
        }
        self._test_get_segments(list_t, list_coord, expected_segments, ratio)

    def test_get_segments_by_length(self):
        """Test get_segments_by_length"""
        list_coords = [
                [105, 105, 105, 105, 105, 105, 105, 105, 105, 105],
                [104, 105, 105, 105, 105, 105, 105, 105, 105, 105],
                [105, 105, 105, 105, 105, 105, 105, 105, 105, 106],
        ]
        ratio = 0.1
        for list_c in list_coords:
            list_t = [1000 + 0.012 * i for i in range(len(list_c))]
            expected_segments= {
                    VAL.WHOLE: (list_t, list_c),
                    VAL.MIDDLE: (list_t[1:9], list_c[1:9]),
                    VAL.BEGIN: (list_t[:1], list_c[:1]),
                    VAL.END: (list_t[9:], list_c[9:]),
            }
            self._test_get_segments(list_t, list_c, expected_segments, ratio)


if __name__ == '__main__':
  unittest.main()