tools/testing/selftests/hid/tests/test_wacom_generic.py

   1 #!/bin/env python3
   2 # SPDX-License-Identifier: GPL-2.0
   3 # -*- coding: utf-8 -*-
   4 #
   5 # Copyright (c) 2017 Benjamin Tissoires <benjamin.tissoires@gmail.com>
   6 # Copyright (c) 2017 Red Hat, Inc.
   7 # Copyright (c) 2020 Wacom Technology Corp.
   8 #
   9 # Authors:
  10 #     Jason Gerecke <jason.gerecke@wacom.com>
  11
  12 """
  13 Tests for the Wacom driver generic codepath.
  14
  15 This module tests the function of the Wacom driver's generic codepath.
  16 The generic codepath is used by devices which are not explicitly listed
  17 in the driver's device table. It uses the device's HID descriptor to
  18 decode reports sent by the device.
  19 """
  20
  21 from .descriptors_wacom import (
  22     wacom_pth660_v145,
  23     wacom_pth660_v150,
  24     wacom_pth860_v145,
  25     wacom_pth860_v150,
  26     wacom_pth460_v105,
  27 )
  28
  29 import attr
  30 from collections import namedtuple
  31 from enum import Enum
  32 from hidtools.hut import HUT
  33 from hidtools.hid import HidUnit
  34 from . import base
  35 from . import test_multitouch
  36 import libevdev
  37 import pytest
  38
  39 import logging
  40
  41 logger = logging.getLogger("hidtools.test.wacom")
  42
  43 KERNEL_MODULE = ("wacom", "wacom")
  44
  45
  46 class ProximityState(Enum):
  47     """
  48     Enumeration of allowed proximity states.
  49     """
  50
  51     # Tool is not able to be sensed by the device
  52     OUT = 0
  53
  54     # Tool is close enough to be sensed, but some data may be invalid
  55     # or inaccurate
  56     IN_PROXIMITY = 1
  57
  58     # Tool is close enough to be sensed with high accuracy. All data
  59     # valid.
  60     IN_RANGE = 2
  61
  62     def fill(self, reportdata):
  63         """Fill a report with approrpiate HID properties/values."""
  64         reportdata.inrange = self in [ProximityState.IN_RANGE]
  65         reportdata.wacomsense = self in [
  66             ProximityState.IN_PROXIMITY,
  67             ProximityState.IN_RANGE,
  68         ]
  69
  70
  71 class ReportData:
  72     """
  73     Placeholder for HID report values.
  74     """
  75
  76     pass
  77
  78
  79 @attr.s
  80 class Buttons:
  81     """
  82     Stylus button state.
  83
  84     Describes the state of each of the buttons / "side switches" that
  85     may be present on a stylus. Buttons set to 'None' indicate the
  86     state is "unchanged" since the previous event.
  87     """
  88
  89     primary = attr.ib(default=None)
  90     secondary = attr.ib(default=None)
  91     tertiary = attr.ib(default=None)
  92
  93     @staticmethod
  94     def clear():
  95         """Button object with all states cleared."""
  96         return Buttons(False, False, False)
  97
  98     def fill(self, reportdata):
  99         """Fill a report with approrpiate HID properties/values."""
 100         reportdata.barrelswitch = int(self.primary or 0)
 101         reportdata.secondarybarrelswitch = int(self.secondary or 0)
 102         reportdata.b3 = int(self.tertiary or 0)
 103
 104
 105 @attr.s
 106 class ToolID:
 107     """
 108     Stylus tool identifiers.
 109
 110     Contains values used to identify a specific stylus, e.g. its serial
 111     number and tool-type identifier. Values of ``0`` may sometimes be
 112     used for the out-of-range condition.
 113     """
 114
 115     serial = attr.ib()
 116     tooltype = attr.ib()
 117
 118     @staticmethod
 119     def clear():
 120         """ToolID object with all fields cleared."""
 121         return ToolID(0, 0)
 122
 123     def fill(self, reportdata):
 124         """Fill a report with approrpiate HID properties/values."""
 125         reportdata.transducerserialnumber = self.serial & 0xFFFFFFFF
 126         reportdata.serialhi = (self.serial >> 32) & 0xFFFFFFFF
 127         reportdata.tooltype = self.tooltype
 128
 129
 130 @attr.s
 131 class PhysRange:
 132     """
 133     Range of HID physical values, with units.
 134     """
 135
 136     unit = attr.ib()
 137     min_size = attr.ib()
 138     max_size = attr.ib()
 139
 140     CENTIMETER = HidUnit.from_string("SILinear: cm")
 141     DEGREE = HidUnit.from_string("EnglishRotation: deg")
 142
 143     def contains(self, field):
 144         """
 145         Check if the physical size of the provided field is in range.
 146
 147         Compare the physical size described by the provided HID field
 148         against the range of sizes described by this object. This is
 149         an exclusive range comparison (e.g. 0 cm is not within the
 150         range 0 cm - 5 cm) and exact unit comparison (e.g. 1 inch is
 151         not within the range 0 cm - 5 cm).
 152         """
 153         phys_size = (field.physical_max - field.physical_min) * 10 ** (field.unit_exp)
 154         return (
 155             field.unit == self.unit.value
 156             and phys_size > self.min_size
 157             and phys_size < self.max_size
 158         )
 159
 160
 161 class BaseTablet(base.UHIDTestDevice):
 162     """
 163     Skeleton object for all kinds of tablet devices.
 164     """
 165
 166     def __init__(self, rdesc, name=None, info=None):
 167         assert rdesc is not None
 168         super().__init__(name, "Pen", input_info=info, rdesc=rdesc)
 169         self.buttons = Buttons.clear()
 170         self.toolid = ToolID.clear()
 171         self.proximity = ProximityState.OUT
 172         self.offset = 0
 173         self.ring = -1
 174         self.ek0 = False
 175
 176     def match_evdev_rule(self, application, evdev):
 177         """
 178         Filter out evdev nodes based on the requested application.
 179
 180         The Wacom driver may create several device nodes for each USB
 181         interface device. It is crucial that we run tests with the
 182         expected device node or things will obviously go off the rails.
 183         Use the Wacom driver's usual naming conventions to apply a
 184         sensible default filter.
 185         """
 186         if application in ["Pen", "Pad"]:
 187             return evdev.name.endswith(application)
 188         else:
 189             return True
 190
 191     def create_report(
 192         self, x, y, pressure, buttons=None, toolid=None, proximity=None, reportID=None
 193     ):
 194         """
 195         Return an input report for this device.
 196
 197         :param x: absolute x
 198         :param y: absolute y
 199         :param pressure: pressure
 200         :param buttons: stylus button state. Use ``None`` for unchanged.
 201         :param toolid: tool identifiers. Use ``None`` for unchanged.
 202         :param proximity: a ProximityState indicating the sensor's ability
 203              to detect and report attributes of this tool. Use ``None``
 204              for unchanged.
 205         :param reportID: the numeric report ID for this report, if needed
 206         """
 207         if buttons is not None:
 208             self.buttons = buttons
 209         buttons = self.buttons
 210
 211         if toolid is not None:
 212             self.toolid = toolid
 213         toolid = self.toolid
 214
 215         if proximity is not None:
 216             self.proximity = proximity
 217         proximity = self.proximity
 218
 219         reportID = reportID or self.default_reportID
 220
 221         report = ReportData()
 222         report.x = x
 223         report.y = y
 224         report.tippressure = pressure
 225         report.tipswitch = pressure > 0
 226         buttons.fill(report)
 227         proximity.fill(report)
 228         toolid.fill(report)
 229
 230         return super().create_report(report, reportID=reportID)
 231
 232     def create_report_heartbeat(self, reportID):
 233         """
 234         Return a heartbeat input report for this device.
 235
 236         Heartbeat reports generally contain battery status information,
 237         among other things.
 238         """
 239         report = ReportData()
 240         report.wacombatterycharging = 1
 241         return super().create_report(report, reportID=reportID)
 242
 243     def create_report_pad(self, reportID, ring, ek0):
 244         report = ReportData()
 245
 246         if ring is not None:
 247             self.ring = ring
 248         ring = self.ring
 249
 250         if ek0 is not None:
 251             self.ek0 = ek0
 252         ek0 = self.ek0
 253
 254         if ring >= 0:
 255             report.wacomtouchring = ring
 256             report.wacomtouchringstatus = 1
 257         else:
 258             report.wacomtouchring = 0x7F
 259             report.wacomtouchringstatus = 0
 260
 261         report.wacomexpresskey00 = ek0
 262         return super().create_report(report, reportID=reportID)
 263
 264     def event(self, x, y, pressure, buttons=None, toolid=None, proximity=None):
 265         """
 266         Send an input event on the default report ID.
 267
 268         :param x: absolute x
 269         :param y: absolute y
 270         :param buttons: stylus button state. Use ``None`` for unchanged.
 271         :param toolid: tool identifiers. Use ``None`` for unchanged.
 272         :param proximity: a ProximityState indicating the sensor's ability
 273              to detect and report attributes of this tool. Use ``None``
 274              for unchanged.
 275         """
 276         r = self.create_report(x, y, pressure, buttons, toolid, proximity)
 277         self.call_input_event(r)
 278         return [r]
 279
 280     def event_heartbeat(self, reportID):
 281         """
 282         Send a heartbeat event on the requested report ID.
 283         """
 284         r = self.create_report_heartbeat(reportID)
 285         self.call_input_event(r)
 286         return [r]
 287
 288     def event_pad(self, reportID, ring=None, ek0=None):
 289         """
 290         Send a pad event on the requested report ID.
 291         """
 292         r = self.create_report_pad(reportID, ring, ek0)
 293         self.call_input_event(r)
 294         return [r]
 295
 296     def get_report(self, req, rnum, rtype):
 297         if rtype != self.UHID_FEATURE_REPORT:
 298             return (1, [])
 299
 300         rdesc = None
 301         for v in self.parsed_rdesc.feature_reports.values():
 302             if v.report_ID == rnum:
 303                 rdesc = v
 304
 305         if rdesc is None:
 306             return (1, [])
 307
 308         result = (1, [])
 309         result = self.create_report_offset(rdesc) or result
 310         return result
 311
 312     def create_report_offset(self, rdesc):
 313         require = [
 314             "Wacom Offset Left",
 315             "Wacom Offset Top",
 316             "Wacom Offset Right",
 317             "Wacom Offset Bottom",
 318         ]
 319         if not set(require).issubset(set([f.usage_name for f in rdesc])):
 320             return None
 321
 322         report = ReportData()
 323         report.wacomoffsetleft = self.offset
 324         report.wacomoffsettop = self.offset
 325         report.wacomoffsetright = self.offset
 326         report.wacomoffsetbottom = self.offset
 327         r = rdesc.create_report([report], None)
 328         return (0, r)
 329
 330
 331 class OpaqueTablet(BaseTablet):
 332     """
 333     Bare-bones opaque tablet with a minimum of features.
 334
 335     A tablet stripped down to its absolute core. It is capable of
 336     reporting X/Y position and if the pen is in contact. No pressure,
 337     no barrel switches, no eraser. Notably it *does* report an "In
 338     Range" flag, but this is only because the Wacom driver expects
 339     one to function properly. The device uses only standard HID usages,
 340     not any of Wacom's vendor-defined pages.
 341     """
 342
 343     # fmt: off
 344     report_descriptor = [
 345         0x05, 0x0D,                     # . Usage Page (Digitizer),
 346         0x09, 0x01,                     # . Usage (Digitizer),
 347         0xA1, 0x01,                     # . Collection (Application),
 348         0x85, 0x01,                     # .     Report ID (1),
 349         0x09, 0x20,                     # .     Usage (Stylus),
 350         0xA1, 0x00,                     # .     Collection (Physical),
 351         0x09, 0x42,                     # .         Usage (Tip Switch),
 352         0x09, 0x32,                     # .         Usage (In Range),
 353         0x15, 0x00,                     # .         Logical Minimum (0),
 354         0x25, 0x01,                     # .         Logical Maximum (1),
 355         0x75, 0x01,                     # .         Report Size (1),
 356         0x95, 0x02,                     # .         Report Count (2),
 357         0x81, 0x02,                     # .         Input (Variable),
 358         0x95, 0x06,                     # .         Report Count (6),
 359         0x81, 0x03,                     # .         Input (Constant, Variable),
 360         0x05, 0x01,                     # .         Usage Page (Desktop),
 361         0x09, 0x30,                     # .         Usage (X),
 362         0x27, 0x80, 0x3E, 0x00, 0x00,   # .         Logical Maximum (16000),
 363         0x47, 0x80, 0x3E, 0x00, 0x00,   # .         Physical Maximum (16000),
 364         0x65, 0x11,                     # .         Unit (Centimeter),
 365         0x55, 0x0D,                     # .         Unit Exponent (13),
 366         0x75, 0x10,                     # .         Report Size (16),
 367         0x95, 0x01,                     # .         Report Count (1),
 368         0x81, 0x02,                     # .         Input (Variable),
 369         0x09, 0x31,                     # .         Usage (Y),
 370         0x27, 0x28, 0x23, 0x00, 0x00,   # .         Logical Maximum (9000),
 371         0x47, 0x28, 0x23, 0x00, 0x00,   # .         Physical Maximum (9000),
 372         0x81, 0x02,                     # .         Input (Variable),
 373         0xC0,                           # .     End Collection,
 374         0xC0,                           # . End Collection,
 375     ]
 376     # fmt: on
 377
 378     def __init__(self, rdesc=report_descriptor, name=None, info=(0x3, 0x056A, 0x9999)):
 379         super().__init__(rdesc, name, info)
 380         self.default_reportID = 1
 381
 382
 383 class OpaqueCTLTablet(BaseTablet):
 384     """
 385     Opaque tablet similar to something in the CTL product line.
 386
 387     A pen-only tablet with most basic features you would expect from
 388     an actual device. Position, eraser, pressure, barrel buttons.
 389     Uses the Wacom vendor-defined usage page.
 390     """
 391
 392     # fmt: off
 393     report_descriptor = [
 394         0x06, 0x0D, 0xFF,               # . Usage Page (Vnd Wacom Emr),
 395         0x09, 0x01,                     # . Usage (Digitizer),
 396         0xA1, 0x01,                     # . Collection (Application),
 397         0x85, 0x10,                     # .     Report ID (16),
 398         0x09, 0x20,                     # .     Usage (Stylus),
 399         0x35, 0x00,                     # .     Physical Minimum (0),
 400         0x45, 0x00,                     # .     Physical Maximum (0),
 401         0x15, 0x00,                     # .     Logical Minimum (0),
 402         0x25, 0x01,                     # .     Logical Maximum (1),
 403         0xA1, 0x00,                     # .     Collection (Physical),
 404         0x09, 0x42,                     # .         Usage (Tip Switch),
 405         0x09, 0x44,                     # .         Usage (Barrel Switch),
 406         0x09, 0x5A,                     # .         Usage (Secondary Barrel Switch),
 407         0x09, 0x45,                     # .         Usage (Eraser),
 408         0x09, 0x3C,                     # .         Usage (Invert),
 409         0x09, 0x32,                     # .         Usage (In Range),
 410         0x09, 0x36,                     # .         Usage (In Proximity),
 411         0x25, 0x01,                     # .         Logical Maximum (1),
 412         0x75, 0x01,                     # .         Report Size (1),
 413         0x95, 0x07,                     # .         Report Count (7),
 414         0x81, 0x02,                     # .         Input (Variable),
 415         0x95, 0x01,                     # .         Report Count (1),
 416         0x81, 0x03,                     # .         Input (Constant, Variable),
 417         0x0A, 0x30, 0x01,               # .         Usage (X),
 418         0x65, 0x11,                     # .         Unit (Centimeter),
 419         0x55, 0x0D,                     # .         Unit Exponent (13),
 420         0x47, 0x80, 0x3E, 0x00, 0x00,   # .         Physical Maximum (16000),
 421         0x27, 0x80, 0x3E, 0x00, 0x00,   # .         Logical Maximum (16000),
 422         0x75, 0x18,                     # .         Report Size (24),
 423         0x95, 0x01,                     # .         Report Count (1),
 424         0x81, 0x02,                     # .         Input (Variable),
 425         0x0A, 0x31, 0x01,               # .         Usage (Y),
 426         0x47, 0x28, 0x23, 0x00, 0x00,   # .         Physical Maximum (9000),
 427         0x27, 0x28, 0x23, 0x00, 0x00,   # .         Logical Maximum (9000),
 428         0x81, 0x02,                     # .         Input (Variable),
 429         0x09, 0x30,                     # .         Usage (Tip Pressure),
 430         0x55, 0x00,                     # .         Unit Exponent (0),
 431         0x65, 0x00,                     # .         Unit,
 432         0x47, 0x00, 0x00, 0x00, 0x00,   # .         Physical Maximum (0),
 433         0x26, 0xFF, 0x0F,               # .         Logical Maximum (4095),
 434         0x75, 0x10,                     # .         Report Size (16),
 435         0x81, 0x02,                     # .         Input (Variable),
 436         0x75, 0x08,                     # .         Report Size (8),
 437         0x95, 0x06,                     # .         Report Count (6),
 438         0x81, 0x03,                     # .         Input (Constant, Variable),
 439         0x0A, 0x32, 0x01,               # .         Usage (Z),
 440         0x25, 0x3F,                     # .         Logical Maximum (63),
 441         0x75, 0x08,                     # .         Report Size (8),
 442         0x95, 0x01,                     # .         Report Count (1),
 443         0x81, 0x02,                     # .         Input (Variable),
 444         0x09, 0x5B,                     # .         Usage (Transducer Serial Number),
 445         0x09, 0x5C,                     # .         Usage (Transducer Serial Number Hi),
 446         0x17, 0x00, 0x00, 0x00, 0x80,   # .         Logical Minimum (-2147483648),
 447         0x27, 0xFF, 0xFF, 0xFF, 0x7F,   # .         Logical Maximum (2147483647),
 448         0x75, 0x20,                     # .         Report Size (32),
 449         0x95, 0x02,                     # .         Report Count (2),
 450         0x81, 0x02,                     # .         Input (Variable),
 451         0x09, 0x77,                     # .         Usage (Tool Type),
 452         0x15, 0x00,                     # .         Logical Minimum (0),
 453         0x26, 0xFF, 0x0F,               # .         Logical Maximum (4095),
 454         0x75, 0x10,                     # .         Report Size (16),
 455         0x95, 0x01,                     # .         Report Count (1),
 456         0x81, 0x02,                     # .         Input (Variable),
 457         0xC0,                           # .     End Collection,
 458         0xC0                            # . End Collection
 459     ]
 460     # fmt: on
 461
 462     def __init__(self, rdesc=report_descriptor, name=None, info=(0x3, 0x056A, 0x9999)):
 463         super().__init__(rdesc, name, info)
 464         self.default_reportID = 16
 465
 466
 467 class PTHX60_Pen(BaseTablet):
 468     """
 469     Pen interface of a PTH-660 / PTH-860 / PTH-460 tablet.
 470
 471     This generation of devices are nearly identical to each other, though
 472     the PTH-460 uses a slightly different descriptor construction (splits
 473     the pad among several physical collections)
 474     """
 475
 476     def __init__(self, rdesc=None, name=None, info=None):
 477         super().__init__(rdesc, name, info)
 478         self.default_reportID = 16
 479
 480
 481 class BaseTest:
 482     class TestTablet(base.BaseTestCase.TestUhid):
 483         kernel_modules = [KERNEL_MODULE]
 484
 485         def sync_and_assert_events(
 486             self, report, expected_events, auto_syn=True, strict=False
 487         ):
 488             """
 489             Assert we see the expected events in response to a report.
 490             """
 491             uhdev = self.uhdev
 492             syn_event = self.syn_event
 493             if auto_syn:
 494                 expected_events.append(syn_event)
 495             actual_events = uhdev.next_sync_events()
 496             self.debug_reports(report, uhdev, actual_events)
 497             if strict:
 498                 self.assertInputEvents(expected_events, actual_events)
 499             else:
 500                 self.assertInputEventsIn(expected_events, actual_events)
 501
 502         def get_usages(self, uhdev):
 503             def get_report_usages(report):
 504                 application = report.application
 505                 for field in report.fields:
 506                     if field.usages is not None:
 507                         for usage in field.usages:
 508                             yield (field, usage, application)
 509                     else:
 510                         yield (field, field.usage, application)
 511
 512             desc = uhdev.parsed_rdesc
 513             reports = [
 514                 *desc.input_reports.values(),
 515                 *desc.feature_reports.values(),
 516                 *desc.output_reports.values(),
 517             ]
 518             for report in reports:
 519                 for usage in get_report_usages(report):
 520                     yield usage
 521
 522         def assertName(self, uhdev, type):
 523             """
 524             Assert that the name is as we expect.
 525
 526             The Wacom driver applies a number of decorations to the name
 527             provided by the hardware. We cannot rely on the definition of
 528             this assertion from the base class to work properly.
 529             """
 530             evdev = uhdev.get_evdev()
 531             expected_name = uhdev.name + type
 532             if "wacom" not in expected_name.lower():
 533                 expected_name = "Wacom " + expected_name
 534             assert evdev.name == expected_name
 535
 536         def test_descriptor_physicals(self):
 537             """
 538             Verify that all HID usages which should have a physical range
 539             actually do, and those which shouldn't don't. Also verify that
 540             the associated unit is correct and within a sensible range.
 541             """
 542
 543             def usage_id(page_name, usage_name):
 544                 page = HUT.usage_page_from_name(page_name)
 545                 return (page.page_id << 16) | page[usage_name].usage
 546
 547             required = {
 548                 usage_id("Generic Desktop", "X"): PhysRange(
 549                     PhysRange.CENTIMETER, 5, 150
 550                 ),
 551                 usage_id("Generic Desktop", "Y"): PhysRange(
 552                     PhysRange.CENTIMETER, 5, 150
 553                 ),
 554                 usage_id("Digitizers", "Width"): PhysRange(
 555                     PhysRange.CENTIMETER, 5, 150
 556                 ),
 557                 usage_id("Digitizers", "Height"): PhysRange(
 558                     PhysRange.CENTIMETER, 5, 150
 559                 ),
 560                 usage_id("Digitizers", "X Tilt"): PhysRange(PhysRange.DEGREE, 90, 180),
 561                 usage_id("Digitizers", "Y Tilt"): PhysRange(PhysRange.DEGREE, 90, 180),
 562                 usage_id("Digitizers", "Twist"): PhysRange(PhysRange.DEGREE, 358, 360),
 563                 usage_id("Wacom", "X Tilt"): PhysRange(PhysRange.DEGREE, 90, 180),
 564                 usage_id("Wacom", "Y Tilt"): PhysRange(PhysRange.DEGREE, 90, 180),
 565                 usage_id("Wacom", "Twist"): PhysRange(PhysRange.DEGREE, 358, 360),
 566                 usage_id("Wacom", "X"): PhysRange(PhysRange.CENTIMETER, 5, 150),
 567                 usage_id("Wacom", "Y"): PhysRange(PhysRange.CENTIMETER, 5, 150),
 568                 usage_id("Wacom", "Wacom TouchRing"): PhysRange(
 569                     PhysRange.DEGREE, 358, 360
 570                 ),
 571                 usage_id("Wacom", "Wacom Offset Left"): PhysRange(
 572                     PhysRange.CENTIMETER, 0, 0.5
 573                 ),
 574                 usage_id("Wacom", "Wacom Offset Top"): PhysRange(
 575                     PhysRange.CENTIMETER, 0, 0.5
 576                 ),
 577                 usage_id("Wacom", "Wacom Offset Right"): PhysRange(
 578                     PhysRange.CENTIMETER, 0, 0.5
 579                 ),
 580                 usage_id("Wacom", "Wacom Offset Bottom"): PhysRange(
 581                     PhysRange.CENTIMETER, 0, 0.5
 582                 ),
 583             }
 584             for field, usage, application in self.get_usages(self.uhdev):
 585                 if application == usage_id("Generic Desktop", "Mouse"):
 586                     # Ignore the vestigial Mouse collection which exists
 587                     # on Wacom tablets only for backwards compatibility.
 588                     continue
 589
 590                 expect_physical = usage in required
 591
 592                 phys_set = field.physical_min != 0 or field.physical_max != 0
 593                 assert phys_set == expect_physical
 594
 595                 unit_set = field.unit != 0
 596                 assert unit_set == expect_physical
 597
 598                 if unit_set:
 599                     assert required[usage].contains(field)
 600
 601         def test_prop_direct(self):
 602             """
 603             Todo: Verify that INPUT_PROP_DIRECT is set on display devices.
 604             """
 605             pass
 606
 607         def test_prop_pointer(self):
 608             """
 609             Todo: Verify that INPUT_PROP_POINTER is set on opaque devices.
 610             """
 611             pass
 612
 613
 614 class PenTabletTest(BaseTest.TestTablet):
 615     def assertName(self, uhdev):
 616         super().assertName(uhdev, " Pen")
 617
 618
 619 class TouchTabletTest(BaseTest.TestTablet):
 620     def assertName(self, uhdev):
 621         super().assertName(uhdev, " Finger")
 622
 623
 624 class TestOpaqueTablet(PenTabletTest):
 625     def create_device(self):
 626         return OpaqueTablet()
 627
 628     def test_sanity(self):
 629         """
 630         Bring a pen into contact with the tablet, then remove it.
 631
 632         Ensure that we get the basic tool/touch/motion events that should
 633         be sent by the driver.
 634         """
 635         uhdev = self.uhdev
 636
 637         self.sync_and_assert_events(
 638             uhdev.event(
 639                 100,
 640                 200,
 641                 pressure=300,
 642                 buttons=Buttons.clear(),
 643                 toolid=ToolID(serial=1, tooltype=1),
 644                 proximity=ProximityState.IN_RANGE,
 645             ),
 646             [
 647                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOOL_PEN, 1),
 648                 libevdev.InputEvent(libevdev.EV_ABS.ABS_X, 100),
 649                 libevdev.InputEvent(libevdev.EV_ABS.ABS_Y, 200),
 650                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1),
 651             ],
 652         )
 653
 654         self.sync_and_assert_events(
 655             uhdev.event(110, 220, pressure=0),
 656             [
 657                 libevdev.InputEvent(libevdev.EV_ABS.ABS_X, 110),
 658                 libevdev.InputEvent(libevdev.EV_ABS.ABS_Y, 220),
 659                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 0),
 660             ],
 661         )
 662
 663         self.sync_and_assert_events(
 664             uhdev.event(
 665                 120,
 666                 230,
 667                 pressure=0,
 668                 toolid=ToolID.clear(),
 669                 proximity=ProximityState.OUT,
 670             ),
 671             [
 672                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOOL_PEN, 0),
 673             ],
 674         )
 675
 676         self.sync_and_assert_events(
 677             uhdev.event(130, 240, pressure=0), [], auto_syn=False, strict=True
 678         )
 679
 680
 681 class TestOpaqueCTLTablet(TestOpaqueTablet):
 682     def create_device(self):
 683         return OpaqueCTLTablet()
 684
 685     def test_buttons(self):
 686         """
 687         Test that the barrel buttons (side switches) work as expected.
 688
 689         Press and release each button individually to verify that we get
 690         the expected events.
 691         """
 692         uhdev = self.uhdev
 693
 694         self.sync_and_assert_events(
 695             uhdev.event(
 696                 100,
 697                 200,
 698                 pressure=0,
 699                 buttons=Buttons.clear(),
 700                 toolid=ToolID(serial=1, tooltype=1),
 701                 proximity=ProximityState.IN_RANGE,
 702             ),
 703             [
 704                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOOL_PEN, 1),
 705                 libevdev.InputEvent(libevdev.EV_ABS.ABS_X, 100),
 706                 libevdev.InputEvent(libevdev.EV_ABS.ABS_Y, 200),
 707                 libevdev.InputEvent(libevdev.EV_MSC.MSC_SERIAL, 1),
 708             ],
 709         )
 710
 711         self.sync_and_assert_events(
 712             uhdev.event(100, 200, pressure=0, buttons=Buttons(primary=True)),
 713             [
 714                 libevdev.InputEvent(libevdev.EV_KEY.BTN_STYLUS, 1),
 715                 libevdev.InputEvent(libevdev.EV_MSC.MSC_SERIAL, 1),
 716             ],
 717         )
 718
 719         self.sync_and_assert_events(
 720             uhdev.event(100, 200, pressure=0, buttons=Buttons(primary=False)),
 721             [
 722                 libevdev.InputEvent(libevdev.EV_KEY.BTN_STYLUS, 0),
 723                 libevdev.InputEvent(libevdev.EV_MSC.MSC_SERIAL, 1),
 724             ],
 725         )
 726
 727         self.sync_and_assert_events(
 728             uhdev.event(100, 200, pressure=0, buttons=Buttons(secondary=True)),
 729             [
 730                 libevdev.InputEvent(libevdev.EV_KEY.BTN_STYLUS2, 1),
 731                 libevdev.InputEvent(libevdev.EV_MSC.MSC_SERIAL, 1),
 732             ],
 733         )
 734
 735         self.sync_and_assert_events(
 736             uhdev.event(100, 200, pressure=0, buttons=Buttons(secondary=False)),
 737             [
 738                 libevdev.InputEvent(libevdev.EV_KEY.BTN_STYLUS2, 0),
 739                 libevdev.InputEvent(libevdev.EV_MSC.MSC_SERIAL, 1),
 740             ],
 741         )
 742
 743
 744 PTHX60_Devices = [
 745     {"rdesc": wacom_pth660_v145, "info": (0x3, 0x056A, 0x0357)},
 746     {"rdesc": wacom_pth660_v150, "info": (0x3, 0x056A, 0x0357)},
 747     {"rdesc": wacom_pth860_v145, "info": (0x3, 0x056A, 0x0358)},
 748     {"rdesc": wacom_pth860_v150, "info": (0x3, 0x056A, 0x0358)},
 749     {"rdesc": wacom_pth460_v105, "info": (0x3, 0x056A, 0x0392)},
 750 ]
 751
 752 PTHX60_Names = [
 753     "PTH-660/v145",
 754     "PTH-660/v150",
 755     "PTH-860/v145",
 756     "PTH-860/v150",
 757     "PTH-460/v105",
 758 ]
 759
 760
 761 class TestPTHX60_Pen(TestOpaqueCTLTablet):
 762     @pytest.fixture(
 763         autouse=True, scope="class", params=PTHX60_Devices, ids=PTHX60_Names
 764     )
 765     def set_device_params(self, request):
 766         request.cls.device_params = request.param
 767
 768     def create_device(self):
 769         return PTHX60_Pen(**self.device_params)
 770
 771     @pytest.mark.xfail
 772     def test_descriptor_physicals(self):
 773         # XFAIL: Various documented errata
 774         super().test_descriptor_physicals()
 775
 776     def test_heartbeat_spurious(self):
 777         """
 778         Test that the heartbeat report does not send spurious events.
 779         """
 780         uhdev = self.uhdev
 781
 782         self.sync_and_assert_events(
 783             uhdev.event(
 784                 100,
 785                 200,
 786                 pressure=300,
 787                 buttons=Buttons.clear(),
 788                 toolid=ToolID(serial=1, tooltype=0x822),
 789                 proximity=ProximityState.IN_RANGE,
 790             ),
 791             [
 792                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOOL_PEN, 1),
 793                 libevdev.InputEvent(libevdev.EV_ABS.ABS_X, 100),
 794                 libevdev.InputEvent(libevdev.EV_ABS.ABS_Y, 200),
 795                 libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1),
 796             ],
 797         )
 798
 799         # Exactly zero events: not even a SYN
 800         self.sync_and_assert_events(
 801             uhdev.event_heartbeat(19), [], auto_syn=False, strict=True
 802         )
 803
 804         self.sync_and_assert_events(
 805             uhdev.event(110, 200, pressure=300),
 806             [
 807                 libevdev.InputEvent(libevdev.EV_ABS.ABS_X, 110),
 808             ],
 809         )
 810
 811     def test_empty_pad_sync(self):
 812         self.empty_pad_sync(num=3, denom=16, reverse=True)
 813
 814     def empty_pad_sync(self, num, denom, reverse):
 815         """
 816         Test that multiple pad collections do not trigger empty syncs.
 817         """
 818
 819         def offset_rotation(value):
 820             """
 821             Offset touchring rotation values by the same factor as the
 822             Linux kernel. Tablets historically don't use the same origin
 823             as HID, and it sometimes changes from tablet to tablet...
 824             """
 825             evdev = self.uhdev.get_evdev()
 826             info = evdev.absinfo[libevdev.EV_ABS.ABS_WHEEL]
 827             delta = info.maximum - info.minimum + 1
 828             if reverse:
 829                 value = info.maximum - value
 830             value += num * delta // denom
 831             if value > info.maximum:
 832                 value -= delta
 833             elif value < info.minimum:
 834                 value += delta
 835             return value
 836
 837         uhdev = self.uhdev
 838         uhdev.application = "Pad"
 839         evdev = uhdev.get_evdev()
 840
 841         print(evdev.name)
 842         self.sync_and_assert_events(
 843             uhdev.event_pad(reportID=17, ring=0, ek0=1),
 844             [
 845                 libevdev.InputEvent(libevdev.EV_KEY.BTN_0, 1),
 846                 libevdev.InputEvent(libevdev.EV_ABS.ABS_WHEEL, offset_rotation(0)),
 847                 libevdev.InputEvent(libevdev.EV_ABS.ABS_MISC, 15),
 848             ],
 849         )
 850
 851         self.sync_and_assert_events(
 852             uhdev.event_pad(reportID=17, ring=1, ek0=1),
 853             [libevdev.InputEvent(libevdev.EV_ABS.ABS_WHEEL, offset_rotation(1))],
 854         )
 855
 856         self.sync_and_assert_events(
 857             uhdev.event_pad(reportID=17, ring=2, ek0=0),
 858             [
 859                 libevdev.InputEvent(libevdev.EV_ABS.ABS_WHEEL, offset_rotation(2)),
 860                 libevdev.InputEvent(libevdev.EV_KEY.BTN_0, 0),
 861             ],
 862         )
 863
 864
 865 class TestDTH2452Tablet(test_multitouch.BaseTest.TestMultitouch, TouchTabletTest):
 866     ContactIds = namedtuple("ContactIds", "contact_id, tracking_id, slot_num")
 867
 868     def create_device(self):
 869         return test_multitouch.Digitizer(
 870             "DTH 2452",
 871             rdesc="05 0d 09 04 a1 01 85 0c 95 01 75 08 15 00 26 ff 00 81 03 09 54 81 02 09 22 a1 02 05 0d 95 01 75 01 25 01 09 42 81 02 81 03 09 47 81 02 95 05 81 03 09 51 26 ff 00 75 10 95 01 81 02 35 00 65 11 55 0e 05 01 09 30 26 a0 44 46 96 14 81 42 09 31 26 9a 26 46 95 0b 81 42 05 0d 75 08 95 01 15 00 09 48 26 5f 00 46 7c 14 81 02 09 49 25 35 46 7d 0b 81 02 45 00 65 00 55 00 c0 05 0d 09 22 a1 02 05 0d 95 01 75 01 25 01 09 42 81 02 81 03 09 47 81 02 95 05 81 03 09 51 26 ff 00 75 10 95 01 81 02 35 00 65 11 55 0e 05 01 09 30 26 a0 44 46 96 14 81 42 09 31 26 9a 26 46 95 0b 81 42 05 0d 75 08 95 01 15 00 09 48 26 5f 00 46 7c 14 81 02 09 49 25 35 46 7d 0b 81 02 45 00 65 00 55 00 c0 05 0d 09 22 a1 02 05 0d 95 01 75 01 25 01 09 42 81 02 81 03 09 47 81 02 95 05 81 03 09 51 26 ff 00 75 10 95 01 81 02 35 00 65 11 55 0e 05 01 09 30 26 a0 44 46 96 14 81 42 09 31 26 9a 26 46 95 0b 81 42 05 0d 75 08 95 01 15 00 09 48 26 5f 00 46 7c 14 81 02 09 49 25 35 46 7d 0b 81 02 45 00 65 00 55 00 c0 05 0d 09 22 a1 02 05 0d 95 01 75 01 25 01 09 42 81 02 81 03 09 47 81 02 95 05 81 03 09 51 26 ff 00 75 10 95 01 81 02 35 00 65 11 55 0e 05 01 09 30 26 a0 44 46 96 14 81 42 09 31 26 9a 26 46 95 0b 81 42 05 0d 75 08 95 01 15 00 09 48 26 5f 00 46 7c 14 81 02 09 49 25 35 46 7d 0b 81 02 45 00 65 00 55 00 c0 05 0d 09 22 a1 02 05 0d 95 01 75 01 25 01 09 42 81 02 81 03 09 47 81 02 95 05 81 03 09 51 26 ff 00 75 10 95 01 81 02 35 00 65 11 55 0e 05 01 09 30 26 a0 44 46 96 14 81 42 09 31 26 9a 26 46 95 0b 81 42 05 0d 75 08 95 01 15 00 09 48 26 5f 00 46 7c 14 81 02 09 49 25 35 46 7d 0b 81 02 45 00 65 00 55 00 c0 05 0d 27 ff ff 00 00 75 10 95 01 09 56 81 02 75 08 95 0e 81 03 09 55 26 ff 00 75 08 b1 02 85 0a 06 00 ff 09 c5 96 00 01 b1 02 c0 06 00 ff 09 01 a1 01 09 01 85 13 15 00 26 ff 00 75 08 95 3f 81 02 06 00 ff 09 01 15 00 26 ff 00 75 08 95 3f 91 02 c0",
 872             input_info=(0x3, 0x056A, 0x0383),
 873         )
 874
 875     def make_contact(self, contact_id=0, t=0):
 876         """
 877         Make a single touch contact that can move over time.
 878
 879         Creates a touch object that has a well-known position in space that
 880         does not overlap with other contacts. The value of `t` may be
 881         incremented over time to move the point along a linear path.
 882         """
 883         x = 50 + 10 * contact_id + t * 11
 884         y = 100 + 100 * contact_id + t * 11
 885         return test_multitouch.Touch(contact_id, x, y)
 886
 887     def make_contacts(self, n, t=0):
 888         """
 889         Make multiple touch contacts that can move over time.
 890
 891         Returns a list of `n` touch objects that are positioned at well-known
 892         locations. The value of `t` may be incremented over time to move the
 893         points along a linear path.
 894         """
 895         return [ self.make_contact(id, t) for id in range(0, n) ]
 896
 897     def assert_contact(self, uhdev, evdev, contact_ids, t=0):
 898         """
 899         Assert properties of a contact generated by make_contact.
 900         """
 901         contact_id = contact_ids.contact_id
 902         tracking_id = contact_ids.tracking_id
 903         slot_num = contact_ids.slot_num
 904
 905         x = 50 + 10 * contact_id + t * 11
 906         y = 100 + 100 * contact_id + t * 11
 907
 908         # If the data isn't supposed to be stored in any slots, there is
 909         # nothing we can check for in the evdev stream.
 910         if slot_num is None:
 911             assert tracking_id == -1
 912             return
 913
 914         assert evdev.slots[slot_num][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == tracking_id
 915         if tracking_id != -1:
 916             assert evdev.slots[slot_num][libevdev.EV_ABS.ABS_MT_POSITION_X] == x
 917             assert evdev.slots[slot_num][libevdev.EV_ABS.ABS_MT_POSITION_Y] == y
 918
 919     def assert_contacts(self, uhdev, evdev, data, t=0):
 920         """
 921         Assert properties of a list of contacts generated by make_contacts.
 922         """
 923         for contact_ids in data:
 924             self.assert_contact(uhdev, evdev, contact_ids, t)
 925
 926     def test_contact_id_0(self):
 927         """
 928         Bring a finger in contact with the tablet, then hold it down and remove it.
 929
 930         Ensure that even with contact ID = 0 which is usually given as an invalid
 931         touch event by most tablets with the exception of a few, that given the
 932         confidence bit is set to 1 it should process it as a valid touch to cover
 933         the few tablets using contact ID = 0 as a valid touch value.
 934         """
 935         uhdev = self.uhdev
 936         evdev = uhdev.get_evdev()
 937
 938         t0 = test_multitouch.Touch(0, 50, 100)
 939         r = uhdev.event([t0])
 940         events = uhdev.next_sync_events()
 941         self.debug_reports(r, uhdev, events)
 942
 943         slot = self.get_slot(uhdev, t0, 0)
 944
 945         assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1) in events
 946         assert evdev.slots[slot][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0
 947         assert evdev.slots[slot][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50
 948         assert evdev.slots[slot][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100
 949
 950         t0.tipswitch = False
 951         if uhdev.quirks is None or "VALID_IS_INRANGE" not in uhdev.quirks:
 952             t0.inrange = False
 953         r = uhdev.event([t0])
 954         events = uhdev.next_sync_events()
 955         self.debug_reports(r, uhdev, events)
 956         assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 0) in events
 957         assert evdev.slots[slot][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1
 958
 959     def test_confidence_false(self):
 960         """
 961         Bring a finger in contact with the tablet with confidence set to false.
 962
 963         Ensure that the confidence bit being set to false should not result in a touch event.
 964         """
 965         uhdev = self.uhdev
 966         _evdev = uhdev.get_evdev()
 967
 968         t0 = test_multitouch.Touch(1, 50, 100)
 969         t0.confidence = False
 970         r = uhdev.event([t0])
 971         events = uhdev.next_sync_events()
 972         self.debug_reports(r, uhdev, events)
 973
 974         _slot = self.get_slot(uhdev, t0, 0)
 975
 976         assert not events
 977
 978     def test_confidence_multitouch(self):
 979         """
 980         Bring multiple fingers in contact with the tablet, some with the
 981         confidence bit set, and some without.
 982
 983         Ensure that all confident touches are reported and that all non-
 984         confident touches are ignored.
 985         """
 986         uhdev = self.uhdev
 987         evdev = uhdev.get_evdev()
 988
 989         touches = self.make_contacts(5)
 990         touches[0].confidence = False
 991         touches[2].confidence = False
 992         touches[4].confidence = False
 993
 994         r = uhdev.event(touches)
 995         events = uhdev.next_sync_events()
 996         self.debug_reports(r, uhdev, events)
 997
 998         assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1) in events
 999
1000         self.assert_contacts(uhdev, evdev,
1001             [ self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = None),
1002               self.ContactIds(contact_id = 1, tracking_id = 0, slot_num = 0),
1003               self.ContactIds(contact_id = 2, tracking_id = -1, slot_num = None),
1004               self.ContactIds(contact_id = 3, tracking_id = 1, slot_num = 1),
1005               self.ContactIds(contact_id = 4, tracking_id = -1, slot_num = None) ])
1006
1007     def confidence_change_assert_playback(self, uhdev, evdev, timeline):
1008         """
1009         Assert proper behavior of contacts that move and change tipswitch /
1010         confidence status over time.
1011
1012         Given a `timeline` list of touch states to iterate over, verify
1013         that the contacts move and are reported as up/down as expected
1014         by the state of the tipswitch and confidence bits.
1015         """
1016         t = 0
1017
1018         for state in timeline:
1019             touches = self.make_contacts(len(state), t)
1020
1021             for item in zip(touches, state):
1022                 item[0].tipswitch = item[1][1]
1023                 item[0].confidence = item[1][2]
1024
1025             r = uhdev.event(touches)
1026             events = uhdev.next_sync_events()
1027             self.debug_reports(r, uhdev, events)
1028
1029             ids = [ x[0] for x in state ]
1030             self.assert_contacts(uhdev, evdev, ids, t)
1031
1032             t += 1
1033
1034     def test_confidence_loss_a(self):
1035         """
1036         Transition a confident contact to a non-confident contact by
1037         first clearing the tipswitch.
1038
1039         Ensure that the driver reports the transitioned contact as
1040         being removed and that other contacts continue to report
1041         normally. This mode of confidence loss is used by the
1042         DTH-2452.
1043         """
1044         uhdev = self.uhdev
1045         evdev = uhdev.get_evdev()
1046
1047         self.confidence_change_assert_playback(uhdev, evdev, [
1048             # t=0: Contact 0 == Down + confident; Contact 1 == Down + confident
1049             # Both fingers confidently in contact
1050             [(self.ContactIds(contact_id = 0, tracking_id = 0, slot_num = 0), True, True),
1051              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1052
1053             # t=1: Contact 0 == !Down + confident; Contact 1 == Down + confident
1054             # First finger looses confidence and clears only the tipswitch flag
1055             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, True),
1056              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1057
1058             # t=2: Contact 0 == !Down + !confident; Contact 1 == Down + confident
1059             # First finger has lost confidence and has both flags cleared
1060             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, False),
1061              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1062
1063             # t=3: Contact 0 == !Down + !confident; Contact 1 == Down + confident
1064             # First finger has lost confidence and has both flags cleared
1065             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, False),
1066              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)]
1067         ])
1068
1069     def test_confidence_loss_b(self):
1070         """
1071         Transition a confident contact to a non-confident contact by
1072         cleraing both tipswitch and confidence bits simultaneously.
1073
1074         Ensure that the driver reports the transitioned contact as
1075         being removed and that other contacts continue to report
1076         normally. This mode of confidence loss is used by some
1077         AES devices.
1078         """
1079         uhdev = self.uhdev
1080         evdev = uhdev.get_evdev()
1081
1082         self.confidence_change_assert_playback(uhdev, evdev, [
1083             # t=0: Contact 0 == Down + confident; Contact 1 == Down + confident
1084             # Both fingers confidently in contact
1085             [(self.ContactIds(contact_id = 0, tracking_id = 0, slot_num = 0), True, True),
1086              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1087
1088             # t=1: Contact 0 == !Down + !confident; Contact 1 == Down + confident
1089             # First finger looses confidence and has both flags cleared simultaneously
1090             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, False),
1091              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1092
1093             # t=2: Contact 0 == !Down + !confident; Contact 1 == Down + confident
1094             # First finger has lost confidence and has both flags cleared
1095             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, False),
1096              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1097
1098             # t=3: Contact 0 == !Down + !confident; Contact 1 == Down + confident
1099             # First finger has lost confidence and has both flags cleared
1100             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, False),
1101              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)]
1102         ])
1103
1104     def test_confidence_loss_c(self):
1105         """
1106         Transition a confident contact to a non-confident contact by
1107         clearing only the confidence bit.
1108
1109         Ensure that the driver reports the transitioned contact as
1110         being removed and that other contacts continue to report
1111         normally.
1112         """
1113         uhdev = self.uhdev
1114         evdev = uhdev.get_evdev()
1115
1116         self.confidence_change_assert_playback(uhdev, evdev, [
1117             # t=0: Contact 0 == Down + confident; Contact 1 == Down + confident
1118             # Both fingers confidently in contact
1119             [(self.ContactIds(contact_id = 0, tracking_id = 0, slot_num = 0), True, True),
1120              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1121
1122             # t=1: Contact 0 == Down + !confident; Contact 1 == Down + confident
1123             # First finger looses confidence and clears only the confidence flag
1124             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), True, False),
1125              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1126
1127             # t=2: Contact 0 == !Down + !confident; Contact 1 == Down + confident
1128             # First finger has lost confidence and has both flags cleared
1129             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, False),
1130              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1131
1132             # t=3: Contact 0 == !Down + !confident; Contact 1 == Down + confident
1133             # First finger has lost confidence and has both flags cleared
1134             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, False),
1135              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)]
1136         ])
1137
1138     def test_confidence_gain_a(self):
1139         """
1140         Transition a contact that was always non-confident to confident.
1141
1142         Ensure that the confident contact is reported normally.
1143         """
1144         uhdev = self.uhdev
1145         evdev = uhdev.get_evdev()
1146
1147         self.confidence_change_assert_playback(uhdev, evdev, [
1148             # t=0: Contact 0 == Down + !confident; Contact 1 == Down + confident
1149             # Only second finger is confidently in contact
1150             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = None), True, False),
1151              (self.ContactIds(contact_id = 1, tracking_id = 0, slot_num = 0), True, True)],
1152
1153             # t=1: Contact 0 == Down + !confident; Contact 1 == Down + confident
1154             # First finger gains confidence
1155             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = None), True, False),
1156              (self.ContactIds(contact_id = 1, tracking_id = 0, slot_num = 0), True, True)],
1157
1158             # t=2: Contact 0 == Down + confident; Contact 1 == Down + confident
1159             # First finger remains confident
1160             [(self.ContactIds(contact_id = 0, tracking_id = 1, slot_num = 1), True, True),
1161              (self.ContactIds(contact_id = 1, tracking_id = 0, slot_num = 0), True, True)],
1162
1163             # t=3: Contact 0 == Down + confident; Contact 1 == Down + confident
1164             # First finger remains confident
1165             [(self.ContactIds(contact_id = 0, tracking_id = 1, slot_num = 1), True, True),
1166              (self.ContactIds(contact_id = 1, tracking_id = 0, slot_num = 0), True, True)]
1167         ])
1168
1169     def test_confidence_gain_b(self):
1170         """
1171         Transition a contact from non-confident to confident.
1172
1173         Ensure that the confident contact is reported normally.
1174         """
1175         uhdev = self.uhdev
1176         evdev = uhdev.get_evdev()
1177
1178         self.confidence_change_assert_playback(uhdev, evdev, [
1179             # t=0: Contact 0 == Down + confident; Contact 1 == Down + confident
1180             # First and second finger confidently in contact
1181             [(self.ContactIds(contact_id = 0, tracking_id = 0, slot_num = 0), True, True),
1182              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1183
1184             # t=1: Contact 0 == Down + !confident; Contact 1 == Down + confident
1185             # Firtst finger looses confidence
1186             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), True, False),
1187              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1188
1189             # t=2: Contact 0 == Down + confident; Contact 1 == Down + confident
1190             # First finger gains confidence
1191             [(self.ContactIds(contact_id = 0, tracking_id = 2, slot_num = 0), True, True),
1192              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)],
1193
1194             # t=3: Contact 0 == !Down + confident; Contact 1 == Down + confident
1195             # First finger goes up
1196             [(self.ContactIds(contact_id = 0, tracking_id = -1, slot_num = 0), False, True),
1197              (self.ContactIds(contact_id = 1, tracking_id = 1, slot_num = 1), True, True)]
1198         ])