TestHIDEventCompatibility.h   [plain text]

//
//  TestHIDEventCompatibility.h
//  IOHIDFamily
//
//  Created by yg on 2/27/17.
//
//

#ifndef TestHIDEventCompatibility_h
#define TestHIDEventCompatibility_h

                             

XCTAssert (sizeof(IOHIDNULLEventData) == sizeof(base::IOHIDNULLEventData), "Size:%lu expected:%lu", sizeof(IOHIDNULLEventData), sizeof(base::IOHIDNULLEventData));
XCTAssert (sizeof(IOHIDVendorDefinedEventData) == sizeof(base::IOHIDVendorDefinedEventData), "Size:%lu expected:%lu", sizeof(IOHIDVendorDefinedEventData), sizeof(base::IOHIDVendorDefinedEventData));
XCTAssert (sizeof(IOHIDKeyboardEventData) == sizeof(base::IOHIDKeyboardEventData), "Size:%lu expected:%lu", sizeof(IOHIDKeyboardEventData), sizeof(base::IOHIDKeyboardEventData));
XCTAssert (sizeof(IOHIDUnicodeEventData) == sizeof(base::IOHIDUnicodeEventData), "Size:%lu expected:%lu", sizeof(IOHIDUnicodeEventData), sizeof(base::IOHIDUnicodeEventData));
XCTAssert (sizeof(IOHIDLEDEventData) == sizeof(base::IOHIDLEDEventData), "Size:%lu expected:%lu", sizeof(IOHIDLEDEventData), sizeof(base::IOHIDLEDEventData));
XCTAssert (sizeof(IOHIDRotationEventData) == sizeof(base::IOHIDRotationEventData), "Size:%lu expected:%lu", sizeof(IOHIDRotationEventData), sizeof(base::IOHIDRotationEventData));
XCTAssert (sizeof(IOHIDVelocityEventData) == sizeof(base::IOHIDVelocityEventData), "Size:%lu expected:%lu", sizeof(IOHIDVelocityEventData), sizeof(base::IOHIDVelocityEventData));
XCTAssert (sizeof(IOHIDTranslationEventData) == sizeof(base::IOHIDTranslationEventData), "Size:%lu expected:%lu", sizeof(IOHIDTranslationEventData), sizeof(base::IOHIDTranslationEventData));
XCTAssert (sizeof(IOHIDScrollEventData) == sizeof(base::IOHIDScrollEventData), "Size:%lu expected:%lu", sizeof(IOHIDScrollEventData), sizeof(base::IOHIDScrollEventData));
XCTAssert (sizeof(IOHIDScaleEventData) == sizeof(base::IOHIDScaleEventData), "Size:%lu expected:%lu", sizeof(IOHIDScaleEventData), sizeof(base::IOHIDScaleEventData));
XCTAssert (sizeof(IOHIDOrientationEventData) == sizeof(base::IOHIDOrientationEventData), "Size:%lu expected:%lu", sizeof(IOHIDOrientationEventData), sizeof(base::IOHIDOrientationEventData));
XCTAssert (sizeof(IOHIDAccelerometerEventData) == sizeof(base::IOHIDAccelerometerEventData), "Size:%lu expected:%lu", sizeof(IOHIDAccelerometerEventData), sizeof(base::IOHIDAccelerometerEventData));
XCTAssert (sizeof(IOHIDGyroEventData) == sizeof(base::IOHIDGyroEventData), "Size:%lu expected:%lu", sizeof(IOHIDGyroEventData), sizeof(base::IOHIDGyroEventData));
XCTAssert (sizeof(IOHIDCompassEventData) == sizeof(base::IOHIDCompassEventData), "Size:%lu expected:%lu", sizeof(IOHIDCompassEventData), sizeof(base::IOHIDCompassEventData));
XCTAssert (sizeof(IOHIDAmbientLightSensorEventData) == sizeof(base::IOHIDAmbientLightSensorEventData), "Size:%lu expected:%lu", sizeof(IOHIDAmbientLightSensorEventData), sizeof(base::IOHIDAmbientLightSensorEventData));
XCTAssert (sizeof(IOHIDTemperatureEventData) == sizeof(base::IOHIDTemperatureEventData), "Size:%lu expected:%lu", sizeof(IOHIDTemperatureEventData), sizeof(base::IOHIDTemperatureEventData));
XCTAssert (sizeof(IOHIDProximityEventData) == sizeof(base::IOHIDProximityEventData), "Size:%lu expected:%lu", sizeof(IOHIDProximityEventData), sizeof(base::IOHIDProximityEventData));
XCTAssert (sizeof(IOHIDProgressEventData) == sizeof(base::IOHIDProgressEventData), "Size:%lu expected:%lu", sizeof(IOHIDProgressEventData), sizeof(base::IOHIDProgressEventData));
XCTAssert (sizeof(IOHIDBiometricEventData) == sizeof(base::IOHIDBiometricEventData), "Size:%lu expected:%lu", sizeof(IOHIDBiometricEventData), sizeof(base::IOHIDBiometricEventData));
XCTAssert (sizeof(IOHIDZoomToggleEventData) == sizeof(base::IOHIDZoomToggleEventData), "Size:%lu expected:%lu", sizeof(IOHIDZoomToggleEventData), sizeof(base::IOHIDZoomToggleEventData));
XCTAssert (sizeof(IOHIDButtonEventData) == sizeof(base::IOHIDButtonEventData), "Size:%lu expected:%lu", sizeof(IOHIDButtonEventData), sizeof(base::IOHIDButtonEventData));
XCTAssert (sizeof(IOHIDPointerEventData) == sizeof(base::IOHIDPointerEventData), "Size:%lu expected:%lu", sizeof(IOHIDPointerEventData), sizeof(base::IOHIDPointerEventData));
XCTAssert (sizeof(IOHIDMultiAxisPointerEventData) == sizeof(base::IOHIDMultiAxisPointerEventData), "Size:%lu expected:%lu", sizeof(IOHIDMultiAxisPointerEventData), sizeof(base::IOHIDMultiAxisPointerEventData));
XCTAssert (sizeof(IOHIDDigitizerEventData) == sizeof(base::IOHIDDigitizerEventData), "Size:%lu expected:%lu", sizeof(IOHIDDigitizerEventData), sizeof(base::IOHIDDigitizerEventData));
XCTAssert (sizeof(IOHIDNavigationSwipeEventData) == sizeof(base::IOHIDNavigationSwipeEventData), "Size:%lu expected:%lu", sizeof(IOHIDNavigationSwipeEventData), sizeof(base::IOHIDNavigationSwipeEventData));
XCTAssert (sizeof(IOHIDDockSwipeEventData) == sizeof(base::IOHIDDockSwipeEventData), "Size:%lu expected:%lu", sizeof(IOHIDDockSwipeEventData), sizeof(base::IOHIDDockSwipeEventData));
XCTAssert (sizeof(IOHIDFluidTouchGestureEventData) == sizeof(base::IOHIDFluidTouchGestureEventData), "Size:%lu expected:%lu", sizeof(IOHIDFluidTouchGestureEventData), sizeof(base::IOHIDFluidTouchGestureEventData));
XCTAssert (sizeof(IOHIDBoundaryScrollEventData) == sizeof(base::IOHIDBoundaryScrollEventData), "Size:%lu expected:%lu", sizeof(IOHIDBoundaryScrollEventData), sizeof(base::IOHIDBoundaryScrollEventData));
XCTAssert (sizeof(IOHIDSymbolicHotKeyEventData) == sizeof(base::IOHIDSymbolicHotKeyEventData), "Size:%lu expected:%lu", sizeof(IOHIDSymbolicHotKeyEventData), sizeof(base::IOHIDSymbolicHotKeyEventData));
XCTAssert (sizeof(IOHIDPowerEventData) == sizeof(base::IOHIDPowerEventData), "Size:%lu expected:%lu", sizeof(IOHIDPowerEventData), sizeof(base::IOHIDPowerEventData));
XCTAssert (sizeof(IOHIDAtmosphericPressureEventData) == sizeof(base::IOHIDAtmosphericPressureEventData), "Size:%lu expected:%lu", sizeof(IOHIDAtmosphericPressureEventData), sizeof(base::IOHIDAtmosphericPressureEventData));
XCTAssert (sizeof(IOHIDForceEventData) == sizeof(base::IOHIDForceEventData), "Size:%lu expected:%lu", sizeof(IOHIDForceEventData), sizeof(base::IOHIDForceEventData));
XCTAssert (sizeof(IOHIDMotionActivityEventData) == sizeof(base::IOHIDMotionActivityEventData), "Size:%lu expected:%lu", sizeof(IOHIDMotionActivityEventData), sizeof(base::IOHIDMotionActivityEventData));
XCTAssert (sizeof(IOHIDMotionGestureEventData) == sizeof(base::IOHIDMotionGestureEventData), "Size:%lu expected:%lu", sizeof(IOHIDMotionGestureEventData), sizeof(base::IOHIDMotionGestureEventData));
XCTAssert (sizeof(IOHIDGameControllerEventData) == sizeof(base::IOHIDGameControllerEventData), "Size:%lu expected:%lu", sizeof(IOHIDGameControllerEventData), sizeof(base::IOHIDGameControllerEventData));
XCTAssert (sizeof(IOHIDHumidityEventData) == sizeof(base::IOHIDHumidityEventData), "Size:%lu expected:%lu", sizeof(IOHIDHumidityEventData), sizeof(base::IOHIDHumidityEventData));
XCTAssert (sizeof(IOHIDBrightnessEventData) == sizeof(base::IOHIDBrightnessEventData), "Size:%lu expected:%lu", sizeof(IOHIDBrightnessEventData), sizeof(base::IOHIDBrightnessEventData));

XCTAssert (kIOHIDEventFieldIsRelative == base::kIOHIDEventFieldIsRelative, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldIsRelative, base::kIOHIDEventFieldIsRelative);
XCTAssert (kIOHIDEventFieldIsCollection == base::kIOHIDEventFieldIsCollection, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldIsCollection, base::kIOHIDEventFieldIsCollection);
XCTAssert (kIOHIDEventFieldIsPixelUnits == base::kIOHIDEventFieldIsPixelUnits, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldIsPixelUnits, base::kIOHIDEventFieldIsPixelUnits);
XCTAssert (kIOHIDEventFieldIsCenterOrigin == base::kIOHIDEventFieldIsCenterOrigin, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldIsCenterOrigin, base::kIOHIDEventFieldIsCenterOrigin);
XCTAssert (kIOHIDEventFieldIsBuiltIn == base::kIOHIDEventFieldIsBuiltIn, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldIsBuiltIn, base::kIOHIDEventFieldIsBuiltIn);
XCTAssert (kIOHIDEventFieldVendorDefinedUsagePage == base::kIOHIDEventFieldVendorDefinedUsagePage, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldVendorDefinedUsagePage, base::kIOHIDEventFieldVendorDefinedUsagePage);
XCTAssert (kIOHIDEventFieldVendorDefinedUsage == base::kIOHIDEventFieldVendorDefinedUsage, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldVendorDefinedUsage, base::kIOHIDEventFieldVendorDefinedUsage);
XCTAssert (kIOHIDEventFieldVendorDefinedVersion == base::kIOHIDEventFieldVendorDefinedVersion, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldVendorDefinedVersion, base::kIOHIDEventFieldVendorDefinedVersion);
XCTAssert (kIOHIDEventFieldVendorDefinedDataLength == base::kIOHIDEventFieldVendorDefinedDataLength, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldVendorDefinedDataLength, base::kIOHIDEventFieldVendorDefinedDataLength);
XCTAssert (kIOHIDEventFieldVendorDefinedData == base::kIOHIDEventFieldVendorDefinedData, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldVendorDefinedData, base::kIOHIDEventFieldVendorDefinedData);
XCTAssert (kIOHIDEventFieldKeyboardRepeat == base::kIOHIDEventFieldKeyboardRepeat, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardRepeat, base::kIOHIDEventFieldKeyboardRepeat);
XCTAssert (kIOHIDEventFieldKeyboardUsagePage == base::kIOHIDEventFieldKeyboardUsagePage, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardUsagePage, base::kIOHIDEventFieldKeyboardUsagePage);
XCTAssert (kIOHIDEventFieldKeyboardUsage == base::kIOHIDEventFieldKeyboardUsage, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardUsage, base::kIOHIDEventFieldKeyboardUsage);
XCTAssert (kIOHIDEventFieldKeyboardDown == base::kIOHIDEventFieldKeyboardDown, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardDown, base::kIOHIDEventFieldKeyboardDown);
XCTAssert (kIOHIDEventFieldKeyboardLongPress == base::kIOHIDEventFieldKeyboardLongPress, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardLongPress, base::kIOHIDEventFieldKeyboardLongPress);
XCTAssert (kIOHIDEventFieldKeyboardClickSpeed == base::kIOHIDEventFieldKeyboardClickSpeed, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardClickSpeed, base::kIOHIDEventFieldKeyboardClickSpeed);
XCTAssert (kIOHIDEventFieldKeyboardSlowKeyPhase == base::kIOHIDEventFieldKeyboardSlowKeyPhase, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardSlowKeyPhase, base::kIOHIDEventFieldKeyboardSlowKeyPhase);
XCTAssert (kIOHIDEventFieldKeyboardMouseKeyToggle == base::kIOHIDEventFieldKeyboardMouseKeyToggle, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardMouseKeyToggle, base::kIOHIDEventFieldKeyboardMouseKeyToggle);
XCTAssert (kIOHIDEventFieldKeyboardPressCount == base::kIOHIDEventFieldKeyboardPressCount, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldKeyboardPressCount, base::kIOHIDEventFieldKeyboardPressCount);
XCTAssert (kIOHIDEventFieldUnicodeEncoding == base::kIOHIDEventFieldUnicodeEncoding, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldUnicodeEncoding, base::kIOHIDEventFieldUnicodeEncoding);
XCTAssert (kIOHIDEventFieldUnicodeQuality == base::kIOHIDEventFieldUnicodeQuality, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldUnicodeQuality, base::kIOHIDEventFieldUnicodeQuality);
XCTAssert (kIOHIDEventFieldUnicodeLength == base::kIOHIDEventFieldUnicodeLength, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldUnicodeLength, base::kIOHIDEventFieldUnicodeLength);
XCTAssert (kIOHIDEventFieldUnicodePayload == base::kIOHIDEventFieldUnicodePayload, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldUnicodePayload, base::kIOHIDEventFieldUnicodePayload);
XCTAssert (kIOHIDEventFieldLEDMask == base::kIOHIDEventFieldLEDMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldLEDMask, base::kIOHIDEventFieldLEDMask);
XCTAssert (kIOHIDEventFieldLEDNumber == base::kIOHIDEventFieldLEDNumber, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldLEDNumber, base::kIOHIDEventFieldLEDNumber);
XCTAssert (kIOHIDEventFieldLEDState == base::kIOHIDEventFieldLEDState, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldLEDState, base::kIOHIDEventFieldLEDState);
XCTAssert (kIOHIDEventFieldRotationX == base::kIOHIDEventFieldRotationX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldRotationX, base::kIOHIDEventFieldRotationX);
XCTAssert (kIOHIDEventFieldRotationY == base::kIOHIDEventFieldRotationY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldRotationY, base::kIOHIDEventFieldRotationY);
XCTAssert (kIOHIDEventFieldRotationZ == base::kIOHIDEventFieldRotationZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldRotationZ, base::kIOHIDEventFieldRotationZ);
XCTAssert (kIOHIDEventFieldVelocityX == base::kIOHIDEventFieldVelocityX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldVelocityX, base::kIOHIDEventFieldVelocityX);
XCTAssert (kIOHIDEventFieldVelocityY == base::kIOHIDEventFieldVelocityY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldVelocityY, base::kIOHIDEventFieldVelocityY);
XCTAssert (kIOHIDEventFieldVelocityZ == base::kIOHIDEventFieldVelocityZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldVelocityZ, base::kIOHIDEventFieldVelocityZ);
XCTAssert (kIOHIDEventFieldTranslationX == base::kIOHIDEventFieldTranslationX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldTranslationX, base::kIOHIDEventFieldTranslationX);
XCTAssert (kIOHIDEventFieldTranslationY == base::kIOHIDEventFieldTranslationY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldTranslationY, base::kIOHIDEventFieldTranslationY);
XCTAssert (kIOHIDEventFieldTranslationZ == base::kIOHIDEventFieldTranslationZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldTranslationZ, base::kIOHIDEventFieldTranslationZ);
XCTAssert (kIOHIDEventFieldScrollIsPixels == base::kIOHIDEventFieldScrollIsPixels, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldScrollIsPixels, base::kIOHIDEventFieldScrollIsPixels);
XCTAssert (kIOHIDEventFieldScrollX == base::kIOHIDEventFieldScrollX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldScrollX, base::kIOHIDEventFieldScrollX);
XCTAssert (kIOHIDEventFieldScrollY == base::kIOHIDEventFieldScrollY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldScrollY, base::kIOHIDEventFieldScrollY);
XCTAssert (kIOHIDEventFieldScrollZ == base::kIOHIDEventFieldScrollZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldScrollZ, base::kIOHIDEventFieldScrollZ);
XCTAssert (kIOHIDEventFieldScaleX == base::kIOHIDEventFieldScaleX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldScaleX, base::kIOHIDEventFieldScaleX);
XCTAssert (kIOHIDEventFieldScaleY == base::kIOHIDEventFieldScaleY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldScaleY, base::kIOHIDEventFieldScaleY);
XCTAssert (kIOHIDEventFieldScaleZ == base::kIOHIDEventFieldScaleZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldScaleZ, base::kIOHIDEventFieldScaleZ);
XCTAssert (kIOHIDEventFieldOrientationRadius == base::kIOHIDEventFieldOrientationRadius, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldOrientationRadius, base::kIOHIDEventFieldOrientationRadius);
XCTAssert (kIOHIDEventFieldOrientationAzimuth == base::kIOHIDEventFieldOrientationAzimuth, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldOrientationAzimuth, base::kIOHIDEventFieldOrientationAzimuth);
XCTAssert (kIOHIDEventFieldOrientationAltitude == base::kIOHIDEventFieldOrientationAltitude, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldOrientationAltitude, base::kIOHIDEventFieldOrientationAltitude);
XCTAssert (kIOHIDEventFieldAccelerometerX == base::kIOHIDEventFieldAccelerometerX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAccelerometerX, base::kIOHIDEventFieldAccelerometerX);
XCTAssert (kIOHIDEventFieldAccelerometerY == base::kIOHIDEventFieldAccelerometerY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAccelerometerY, base::kIOHIDEventFieldAccelerometerY);
XCTAssert (kIOHIDEventFieldAccelerometerZ == base::kIOHIDEventFieldAccelerometerZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAccelerometerZ, base::kIOHIDEventFieldAccelerometerZ);
XCTAssert (kIOHIDEventFieldAccelerometerType == base::kIOHIDEventFieldAccelerometerType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAccelerometerType, base::kIOHIDEventFieldAccelerometerType);
XCTAssert (kIOHIDEventFieldAccelerometerSubType == base::kIOHIDEventFieldAccelerometerSubType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAccelerometerSubType, base::kIOHIDEventFieldAccelerometerSubType);
XCTAssert (kIOHIDEventFieldAccelerometerSequence == base::kIOHIDEventFieldAccelerometerSequence, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAccelerometerSequence, base::kIOHIDEventFieldAccelerometerSequence);
XCTAssert (kIOHIDEventFieldGyroX == base::kIOHIDEventFieldGyroX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGyroX, base::kIOHIDEventFieldGyroX);
XCTAssert (kIOHIDEventFieldGyroY == base::kIOHIDEventFieldGyroY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGyroY, base::kIOHIDEventFieldGyroY);
XCTAssert (kIOHIDEventFieldGyroZ == base::kIOHIDEventFieldGyroZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGyroZ, base::kIOHIDEventFieldGyroZ);
XCTAssert (kIOHIDEventFieldGyroType == base::kIOHIDEventFieldGyroType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGyroType, base::kIOHIDEventFieldGyroType);
XCTAssert (kIOHIDEventFieldGyroSubType == base::kIOHIDEventFieldGyroSubType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGyroSubType, base::kIOHIDEventFieldGyroSubType);
XCTAssert (kIOHIDEventFieldGyroSequence == base::kIOHIDEventFieldGyroSequence, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGyroSequence, base::kIOHIDEventFieldGyroSequence);
XCTAssert (kIOHIDEventFieldCompassX == base::kIOHIDEventFieldCompassX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldCompassX, base::kIOHIDEventFieldCompassX);
XCTAssert (kIOHIDEventFieldCompassY == base::kIOHIDEventFieldCompassY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldCompassY, base::kIOHIDEventFieldCompassY);
XCTAssert (kIOHIDEventFieldCompassZ == base::kIOHIDEventFieldCompassZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldCompassZ, base::kIOHIDEventFieldCompassZ);
XCTAssert (kIOHIDEventFieldCompassType == base::kIOHIDEventFieldCompassType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldCompassType, base::kIOHIDEventFieldCompassType);
XCTAssert (kIOHIDEventFieldCompassSubType == base::kIOHIDEventFieldCompassSubType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldCompassSubType, base::kIOHIDEventFieldCompassSubType);
XCTAssert (kIOHIDEventFieldCompassSequence == base::kIOHIDEventFieldCompassSequence, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldCompassSequence, base::kIOHIDEventFieldCompassSequence);
XCTAssert (kIOHIDEventFieldAmbientLightSensorLevel == base::kIOHIDEventFieldAmbientLightSensorLevel, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightSensorLevel, base::kIOHIDEventFieldAmbientLightSensorLevel);
XCTAssert (kIOHIDEventFieldAmbientLightSensorRawChannel0 == base::kIOHIDEventFieldAmbientLightSensorRawChannel0, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightSensorRawChannel0, base::kIOHIDEventFieldAmbientLightSensorRawChannel0);
XCTAssert (kIOHIDEventFieldAmbientLightSensorRawChannel1 == base::kIOHIDEventFieldAmbientLightSensorRawChannel1, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightSensorRawChannel1, base::kIOHIDEventFieldAmbientLightSensorRawChannel1);
XCTAssert (kIOHIDEventFieldAmbientLightSensorRawChannel2 == base::kIOHIDEventFieldAmbientLightSensorRawChannel2, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightSensorRawChannel2, base::kIOHIDEventFieldAmbientLightSensorRawChannel2);
XCTAssert (kIOHIDEventFieldAmbientLightSensorRawChannel3 == base::kIOHIDEventFieldAmbientLightSensorRawChannel3, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightSensorRawChannel3, base::kIOHIDEventFieldAmbientLightSensorRawChannel3);
XCTAssert (kIOHIDEventFieldAmbientLightDisplayBrightnessChanged == base::kIOHIDEventFieldAmbientLightDisplayBrightnessChanged, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightDisplayBrightnessChanged, base::kIOHIDEventFieldAmbientLightDisplayBrightnessChanged);
XCTAssert (kIOHIDEventFieldAmbientLightColorSpace == base::kIOHIDEventFieldAmbientLightColorSpace, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightColorSpace, base::kIOHIDEventFieldAmbientLightColorSpace);
XCTAssert (kIOHIDEventFieldAmbientLightColorComponent0 == base::kIOHIDEventFieldAmbientLightColorComponent0, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightColorComponent0, base::kIOHIDEventFieldAmbientLightColorComponent0);
XCTAssert (kIOHIDEventFieldAmbientLightColorComponent1 == base::kIOHIDEventFieldAmbientLightColorComponent1, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightColorComponent1, base::kIOHIDEventFieldAmbientLightColorComponent1);
XCTAssert (kIOHIDEventFieldAmbientLightColorComponent2 == base::kIOHIDEventFieldAmbientLightColorComponent2, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAmbientLightColorComponent2, base::kIOHIDEventFieldAmbientLightColorComponent2);
XCTAssert (kIOHIDEventFieldTemperatureLevel == base::kIOHIDEventFieldTemperatureLevel, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldTemperatureLevel, base::kIOHIDEventFieldTemperatureLevel);
XCTAssert (kIOHIDEventFieldProximityDetectionMask == base::kIOHIDEventFieldProximityDetectionMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldProximityDetectionMask, base::kIOHIDEventFieldProximityDetectionMask);
XCTAssert (kIOHIDEventFieldProximityLevel == base::kIOHIDEventFieldProximityLevel, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldProximityLevel, base::kIOHIDEventFieldProximityLevel);
XCTAssert (kIOHIDEventFieldProgressEventType == base::kIOHIDEventFieldProgressEventType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldProgressEventType, base::kIOHIDEventFieldProgressEventType);
XCTAssert (kIOHIDEventFieldProgressLevel == base::kIOHIDEventFieldProgressLevel, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldProgressLevel, base::kIOHIDEventFieldProgressLevel);
XCTAssert (kIOHIDEventFieldBiometricEventType == base::kIOHIDEventFieldBiometricEventType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBiometricEventType, base::kIOHIDEventFieldBiometricEventType);
XCTAssert (kIOHIDEventFieldBiometricLevel == base::kIOHIDEventFieldBiometricLevel, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBiometricLevel, base::kIOHIDEventFieldBiometricLevel);
XCTAssert (kIOHIDEventFieldBiometricUsagePage == base::kIOHIDEventFieldBiometricUsagePage, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBiometricUsagePage, base::kIOHIDEventFieldBiometricUsagePage);
XCTAssert (kIOHIDEventFieldBiometricUsage == base::kIOHIDEventFieldBiometricUsage, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBiometricUsage, base::kIOHIDEventFieldBiometricUsage);
XCTAssert (kIOHIDEventFieldBiometricTapCount == base::kIOHIDEventFieldBiometricTapCount, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBiometricTapCount, base::kIOHIDEventFieldBiometricTapCount);
XCTAssert (kIOHIDEventFieldButtonMask == base::kIOHIDEventFieldButtonMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldButtonMask, base::kIOHIDEventFieldButtonMask);
XCTAssert (kIOHIDEventFieldButtonPressure == base::kIOHIDEventFieldButtonPressure, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldButtonPressure, base::kIOHIDEventFieldButtonPressure);
XCTAssert (kIOHIDEventFieldButtonNumber == base::kIOHIDEventFieldButtonNumber, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldButtonNumber, base::kIOHIDEventFieldButtonNumber);
XCTAssert (kIOHIDEventFieldButtonClickCount == base::kIOHIDEventFieldButtonClickCount, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldButtonClickCount, base::kIOHIDEventFieldButtonClickCount);
XCTAssert (kIOHIDEventFieldButtonState == base::kIOHIDEventFieldButtonState, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldButtonState, base::kIOHIDEventFieldButtonState);
XCTAssert (kIOHIDEventFieldPointerX == base::kIOHIDEventFieldPointerX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldPointerX, base::kIOHIDEventFieldPointerX);
XCTAssert (kIOHIDEventFieldPointerY == base::kIOHIDEventFieldPointerY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldPointerY, base::kIOHIDEventFieldPointerY);
XCTAssert (kIOHIDEventFieldPointerZ == base::kIOHIDEventFieldPointerZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldPointerZ, base::kIOHIDEventFieldPointerZ);
XCTAssert (kIOHIDEventFieldPointerButtonMask == base::kIOHIDEventFieldPointerButtonMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldPointerButtonMask, base::kIOHIDEventFieldPointerButtonMask);
XCTAssert (kIOHIDEventFieldMultiAxisPointerX == base::kIOHIDEventFieldMultiAxisPointerX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMultiAxisPointerX, base::kIOHIDEventFieldMultiAxisPointerX);
XCTAssert (kIOHIDEventFieldMultiAxisPointerY == base::kIOHIDEventFieldMultiAxisPointerY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMultiAxisPointerY, base::kIOHIDEventFieldMultiAxisPointerY);
XCTAssert (kIOHIDEventFieldMultiAxisPointerZ == base::kIOHIDEventFieldMultiAxisPointerZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMultiAxisPointerZ, base::kIOHIDEventFieldMultiAxisPointerZ);
XCTAssert (kIOHIDEventFieldMultiAxisPointerButtonMask == base::kIOHIDEventFieldMultiAxisPointerButtonMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMultiAxisPointerButtonMask, base::kIOHIDEventFieldMultiAxisPointerButtonMask);
XCTAssert (kIOHIDEventFieldMultiAxisPointerRx == base::kIOHIDEventFieldMultiAxisPointerRx, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMultiAxisPointerRx, base::kIOHIDEventFieldMultiAxisPointerRx);
XCTAssert (kIOHIDEventFieldMultiAxisPointerRy == base::kIOHIDEventFieldMultiAxisPointerRy, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMultiAxisPointerRy, base::kIOHIDEventFieldMultiAxisPointerRy);
XCTAssert (kIOHIDEventFieldMultiAxisPointerRz == base::kIOHIDEventFieldMultiAxisPointerRz, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMultiAxisPointerRz, base::kIOHIDEventFieldMultiAxisPointerRz);
XCTAssert (kIOHIDEventFieldDigitizerCollection == base::kIOHIDEventFieldDigitizerCollection, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerCollection, base::kIOHIDEventFieldDigitizerCollection);
XCTAssert (kIOHIDEventFieldDigitizerRange == base::kIOHIDEventFieldDigitizerRange, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerRange, base::kIOHIDEventFieldDigitizerRange);
XCTAssert (kIOHIDEventFieldDigitizerTouch == base::kIOHIDEventFieldDigitizerTouch, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerTouch, base::kIOHIDEventFieldDigitizerTouch);
XCTAssert (kIOHIDEventFieldDigitizerIsDisplayIntegrated == base::kIOHIDEventFieldDigitizerIsDisplayIntegrated, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerIsDisplayIntegrated, base::kIOHIDEventFieldDigitizerIsDisplayIntegrated);
XCTAssert (kIOHIDEventFieldDigitizerX == base::kIOHIDEventFieldDigitizerX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerX, base::kIOHIDEventFieldDigitizerX);
XCTAssert (kIOHIDEventFieldDigitizerY == base::kIOHIDEventFieldDigitizerY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerY, base::kIOHIDEventFieldDigitizerY);
XCTAssert (kIOHIDEventFieldDigitizerZ == base::kIOHIDEventFieldDigitizerZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerZ, base::kIOHIDEventFieldDigitizerZ);
XCTAssert (kIOHIDEventFieldDigitizerIndex == base::kIOHIDEventFieldDigitizerIndex, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerIndex, base::kIOHIDEventFieldDigitizerIndex);
XCTAssert (kIOHIDEventFieldDigitizerType == base::kIOHIDEventFieldDigitizerType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerType, base::kIOHIDEventFieldDigitizerType);
XCTAssert (kIOHIDEventFieldDigitizerIdentity == base::kIOHIDEventFieldDigitizerIdentity, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerIdentity, base::kIOHIDEventFieldDigitizerIdentity);
XCTAssert (kIOHIDEventFieldDigitizerEventMask == base::kIOHIDEventFieldDigitizerEventMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerEventMask, base::kIOHIDEventFieldDigitizerEventMask);
XCTAssert (kIOHIDEventFieldDigitizerChildEventMask == base::kIOHIDEventFieldDigitizerChildEventMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerChildEventMask, base::kIOHIDEventFieldDigitizerChildEventMask);
XCTAssert (kIOHIDEventFieldDigitizerButtonMask == base::kIOHIDEventFieldDigitizerButtonMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerButtonMask, base::kIOHIDEventFieldDigitizerButtonMask);
XCTAssert (kIOHIDEventFieldDigitizerPressure == base::kIOHIDEventFieldDigitizerPressure, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerPressure, base::kIOHIDEventFieldDigitizerPressure);
XCTAssert (kIOHIDEventFieldDigitizerAuxiliaryPressure == base::kIOHIDEventFieldDigitizerAuxiliaryPressure, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerAuxiliaryPressure, base::kIOHIDEventFieldDigitizerAuxiliaryPressure);
XCTAssert (kIOHIDEventFieldDigitizerTwist == base::kIOHIDEventFieldDigitizerTwist, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerTwist, base::kIOHIDEventFieldDigitizerTwist);
//XCTAssert (kIOHIDEventFieldDigitizerOrientationType == base::kIOHIDEventFieldDigitizerOrientationType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerOrientationType, base::kIOHIDEventFieldDigitizerOrientationType);
XCTAssert (kIOHIDEventFieldDigitizerTiltX == base::kIOHIDEventFieldDigitizerTiltX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerTiltX, base::kIOHIDEventFieldDigitizerTiltX);
XCTAssert (kIOHIDEventFieldDigitizerTiltY == base::kIOHIDEventFieldDigitizerTiltY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerTiltY, base::kIOHIDEventFieldDigitizerTiltY);
XCTAssert (kIOHIDEventFieldDigitizerAltitude == base::kIOHIDEventFieldDigitizerAltitude, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerAltitude, base::kIOHIDEventFieldDigitizerAltitude);
XCTAssert (kIOHIDEventFieldDigitizerAzimuth == base::kIOHIDEventFieldDigitizerAzimuth, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerAzimuth, base::kIOHIDEventFieldDigitizerAzimuth);
XCTAssert (kIOHIDEventFieldDigitizerQuality == base::kIOHIDEventFieldDigitizerQuality, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerQuality, base::kIOHIDEventFieldDigitizerQuality);
XCTAssert (kIOHIDEventFieldDigitizerDensity == base::kIOHIDEventFieldDigitizerDensity, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerDensity, base::kIOHIDEventFieldDigitizerDensity);
XCTAssert (kIOHIDEventFieldDigitizerMajorRadius == base::kIOHIDEventFieldDigitizerMajorRadius, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerMajorRadius, base::kIOHIDEventFieldDigitizerMajorRadius);
XCTAssert (kIOHIDEventFieldDigitizerMinorRadius == base::kIOHIDEventFieldDigitizerMinorRadius, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerMinorRadius, base::kIOHIDEventFieldDigitizerMinorRadius);
XCTAssert (kIOHIDEventFieldDigitizerQuality == base::kIOHIDEventFieldDigitizerQuality, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerQuality, base::kIOHIDEventFieldDigitizerQuality);
XCTAssert (kIOHIDEventFieldDigitizerDensity == base::kIOHIDEventFieldDigitizerDensity, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerDensity, base::kIOHIDEventFieldDigitizerDensity);
XCTAssert (kIOHIDEventFieldDigitizerIrregularity == base::kIOHIDEventFieldDigitizerIrregularity, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerIrregularity, base::kIOHIDEventFieldDigitizerIrregularity);
XCTAssert (kIOHIDEventFieldDigitizerMajorRadius == base::kIOHIDEventFieldDigitizerMajorRadius, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerMajorRadius, base::kIOHIDEventFieldDigitizerMajorRadius);
XCTAssert (kIOHIDEventFieldDigitizerMinorRadius == base::kIOHIDEventFieldDigitizerMinorRadius, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerMinorRadius, base::kIOHIDEventFieldDigitizerMinorRadius);
XCTAssert (kIOHIDEventFieldDigitizerQualityRadiiAccuracy == base::kIOHIDEventFieldDigitizerQualityRadiiAccuracy, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerQualityRadiiAccuracy, base::kIOHIDEventFieldDigitizerQualityRadiiAccuracy);
XCTAssert (kIOHIDEventFieldDigitizerGenerationCount == base::kIOHIDEventFieldDigitizerGenerationCount, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerGenerationCount, base::kIOHIDEventFieldDigitizerGenerationCount);
XCTAssert (kIOHIDEventFieldDigitizerWillUpdateMask == base::kIOHIDEventFieldDigitizerWillUpdateMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerWillUpdateMask, base::kIOHIDEventFieldDigitizerWillUpdateMask);
XCTAssert (kIOHIDEventFieldDigitizerDidUpdateMask == base::kIOHIDEventFieldDigitizerDidUpdateMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDigitizerDidUpdateMask, base::kIOHIDEventFieldDigitizerDidUpdateMask);
XCTAssert (kIOHIDEventFieldNavigationSwipePositionX == base::kIOHIDEventFieldNavigationSwipePositionX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldNavigationSwipePositionX, base::kIOHIDEventFieldNavigationSwipePositionX);
XCTAssert (kIOHIDEventFieldNavigationSwipePositionY == base::kIOHIDEventFieldNavigationSwipePositionY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldNavigationSwipePositionY, base::kIOHIDEventFieldNavigationSwipePositionY);
XCTAssert (kIOHIDEventFieldNavigationSwipeMask == base::kIOHIDEventFieldNavigationSwipeMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldNavigationSwipeMask, base::kIOHIDEventFieldNavigationSwipeMask);
XCTAssert (kIOHIDEventFieldNavigationSwipeMotion == base::kIOHIDEventFieldNavigationSwipeMotion, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldNavigationSwipeMotion, base::kIOHIDEventFieldNavigationSwipeMotion);
XCTAssert (kIOHIDEventFieldNavigationSwipeFlavor == base::kIOHIDEventFieldNavigationSwipeFlavor, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldNavigationSwipeFlavor, base::kIOHIDEventFieldNavigationSwipeFlavor);
XCTAssert (kIOHIDEventFieldNavigationSwipeProgress == base::kIOHIDEventFieldNavigationSwipeProgress, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldNavigationSwipeProgress, base::kIOHIDEventFieldNavigationSwipeProgress);
XCTAssert (kIOHIDEventFieldDockSwipePositionX == base::kIOHIDEventFieldDockSwipePositionX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDockSwipePositionX, base::kIOHIDEventFieldDockSwipePositionX);
XCTAssert (kIOHIDEventFieldDockSwipePositionY == base::kIOHIDEventFieldDockSwipePositionY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDockSwipePositionY, base::kIOHIDEventFieldDockSwipePositionY);
XCTAssert (kIOHIDEventFieldDockSwipeMask == base::kIOHIDEventFieldDockSwipeMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDockSwipeMask, base::kIOHIDEventFieldDockSwipeMask);
XCTAssert (kIOHIDEventFieldDockSwipeMotion == base::kIOHIDEventFieldDockSwipeMotion, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDockSwipeMotion, base::kIOHIDEventFieldDockSwipeMotion);
XCTAssert (kIOHIDEventFieldDockSwipeFlavor == base::kIOHIDEventFieldDockSwipeFlavor, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDockSwipeFlavor, base::kIOHIDEventFieldDockSwipeFlavor);
XCTAssert (kIOHIDEventFieldDockSwipeProgress == base::kIOHIDEventFieldDockSwipeProgress, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldDockSwipeProgress, base::kIOHIDEventFieldDockSwipeProgress);
XCTAssert (kIOHIDEventFieldFluidTouchGesturePositionX == base::kIOHIDEventFieldFluidTouchGesturePositionX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldFluidTouchGesturePositionX, base::kIOHIDEventFieldFluidTouchGesturePositionX);
XCTAssert (kIOHIDEventFieldFluidTouchGesturePositionY == base::kIOHIDEventFieldFluidTouchGesturePositionY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldFluidTouchGesturePositionY, base::kIOHIDEventFieldFluidTouchGesturePositionY);
XCTAssert (kIOHIDEventFieldFluidTouchGestureMask == base::kIOHIDEventFieldFluidTouchGestureMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldFluidTouchGestureMask, base::kIOHIDEventFieldFluidTouchGestureMask);
XCTAssert (kIOHIDEventFieldFluidTouchGestureMotion == base::kIOHIDEventFieldFluidTouchGestureMotion, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldFluidTouchGestureMotion, base::kIOHIDEventFieldFluidTouchGestureMotion);
XCTAssert (kIOHIDEventFieldFluidTouchGestureFlavor == base::kIOHIDEventFieldFluidTouchGestureFlavor, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldFluidTouchGestureFlavor, base::kIOHIDEventFieldFluidTouchGestureFlavor);
XCTAssert (kIOHIDEventFieldFluidTouchGestureProgress == base::kIOHIDEventFieldFluidTouchGestureProgress, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldFluidTouchGestureProgress, base::kIOHIDEventFieldFluidTouchGestureProgress);
XCTAssert (kIOHIDEventFieldBoundaryScrollPositionX == base::kIOHIDEventFieldBoundaryScrollPositionX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBoundaryScrollPositionX, base::kIOHIDEventFieldBoundaryScrollPositionX);
XCTAssert (kIOHIDEventFieldBoundaryScrollPositionY == base::kIOHIDEventFieldBoundaryScrollPositionY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBoundaryScrollPositionY, base::kIOHIDEventFieldBoundaryScrollPositionY);
XCTAssert (kIOHIDEventFieldBoundaryScrollMask == base::kIOHIDEventFieldBoundaryScrollMask, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBoundaryScrollMask, base::kIOHIDEventFieldBoundaryScrollMask);
XCTAssert (kIOHIDEventFieldBoundaryScrollMotion == base::kIOHIDEventFieldBoundaryScrollMotion, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBoundaryScrollMotion, base::kIOHIDEventFieldBoundaryScrollMotion);
XCTAssert (kIOHIDEventFieldBoundaryScrollFlavor == base::kIOHIDEventFieldBoundaryScrollFlavor, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBoundaryScrollFlavor, base::kIOHIDEventFieldBoundaryScrollFlavor);
XCTAssert (kIOHIDEventFieldBoundaryScrollProgress == base::kIOHIDEventFieldBoundaryScrollProgress, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldBoundaryScrollProgress, base::kIOHIDEventFieldBoundaryScrollProgress);
XCTAssert (kIOHIDEventFieldSymbolicHotKeyIsCGSEvent == base::kIOHIDEventFieldSymbolicHotKeyIsCGSEvent, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldSymbolicHotKeyIsCGSEvent, base::kIOHIDEventFieldSymbolicHotKeyIsCGSEvent);
XCTAssert (kIOHIDEventFieldSymbolicHotKeyValue == base::kIOHIDEventFieldSymbolicHotKeyValue, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldSymbolicHotKeyValue, base::kIOHIDEventFieldSymbolicHotKeyValue);
XCTAssert (kIOHIDEventFieldPowerMeasurement == base::kIOHIDEventFieldPowerMeasurement, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldPowerMeasurement, base::kIOHIDEventFieldPowerMeasurement);
XCTAssert (kIOHIDEventFieldPowerType == base::kIOHIDEventFieldPowerType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldPowerType, base::kIOHIDEventFieldPowerType);
XCTAssert (kIOHIDEventFieldPowerSubType == base::kIOHIDEventFieldPowerSubType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldPowerSubType, base::kIOHIDEventFieldPowerSubType);
XCTAssert (kIOHIDEventFieldAtmosphericPressureLevel == base::kIOHIDEventFieldAtmosphericPressureLevel, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAtmosphericPressureLevel, base::kIOHIDEventFieldAtmosphericPressureLevel);
XCTAssert (kIOHIDEventFieldAtmosphericSequence == base::kIOHIDEventFieldAtmosphericSequence, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldAtmosphericSequence, base::kIOHIDEventFieldAtmosphericSequence);
XCTAssert (kIOHIDEventFieldForceBehavior == base::kIOHIDEventFieldForceBehavior, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldForceBehavior, base::kIOHIDEventFieldForceBehavior);
XCTAssert (kIOHIDEventFieldForceProgress == base::kIOHIDEventFieldForceProgress, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldForceProgress, base::kIOHIDEventFieldForceProgress);
XCTAssert (kIOHIDEventFieldForceStage == base::kIOHIDEventFieldForceStage, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldForceStage, base::kIOHIDEventFieldForceStage);
XCTAssert (kIOHIDEventFieldForceStagePressure == base::kIOHIDEventFieldForceStagePressure, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldForceStagePressure, base::kIOHIDEventFieldForceStagePressure);
XCTAssert (kIOHIDEventFieldMotionActivityActivityType == base::kIOHIDEventFieldMotionActivityActivityType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMotionActivityActivityType, base::kIOHIDEventFieldMotionActivityActivityType);
XCTAssert (kIOHIDEventFieldMotionActivityConfidence == base::kIOHIDEventFieldMotionActivityConfidence, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMotionActivityConfidence, base::kIOHIDEventFieldMotionActivityConfidence);
XCTAssert (kIOHIDEventFieldMotionGestureGestureType == base::kIOHIDEventFieldMotionGestureGestureType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMotionGestureGestureType, base::kIOHIDEventFieldMotionGestureGestureType);
XCTAssert (kIOHIDEventFieldMotionGestureProgress == base::kIOHIDEventFieldMotionGestureProgress, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldMotionGestureProgress, base::kIOHIDEventFieldMotionGestureProgress);
XCTAssert (kIOHIDEventFieldGameControllerType == base::kIOHIDEventFieldGameControllerType, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerType, base::kIOHIDEventFieldGameControllerType);
XCTAssert (kIOHIDEventFieldGameControllerDirectionPadUp == base::kIOHIDEventFieldGameControllerDirectionPadUp, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerDirectionPadUp, base::kIOHIDEventFieldGameControllerDirectionPadUp);
XCTAssert (kIOHIDEventFieldGameControllerDirectionPadDown == base::kIOHIDEventFieldGameControllerDirectionPadDown, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerDirectionPadDown, base::kIOHIDEventFieldGameControllerDirectionPadDown);
XCTAssert (kIOHIDEventFieldGameControllerDirectionPadLeft == base::kIOHIDEventFieldGameControllerDirectionPadLeft, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerDirectionPadLeft, base::kIOHIDEventFieldGameControllerDirectionPadLeft);
XCTAssert (kIOHIDEventFieldGameControllerDirectionPadRight == base::kIOHIDEventFieldGameControllerDirectionPadRight, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerDirectionPadRight, base::kIOHIDEventFieldGameControllerDirectionPadRight);
XCTAssert (kIOHIDEventFieldGameControllerFaceButtonX == base::kIOHIDEventFieldGameControllerFaceButtonX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerFaceButtonX, base::kIOHIDEventFieldGameControllerFaceButtonX);
XCTAssert (kIOHIDEventFieldGameControllerFaceButtonY == base::kIOHIDEventFieldGameControllerFaceButtonY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerFaceButtonY, base::kIOHIDEventFieldGameControllerFaceButtonY);
XCTAssert (kIOHIDEventFieldGameControllerFaceButtonA == base::kIOHIDEventFieldGameControllerFaceButtonA, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerFaceButtonA, base::kIOHIDEventFieldGameControllerFaceButtonA);
XCTAssert (kIOHIDEventFieldGameControllerFaceButtonB == base::kIOHIDEventFieldGameControllerFaceButtonB, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerFaceButtonB, base::kIOHIDEventFieldGameControllerFaceButtonB);
XCTAssert (kIOHIDEventFieldGameControllerJoyStickAxisX == base::kIOHIDEventFieldGameControllerJoyStickAxisX, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerJoyStickAxisX, base::kIOHIDEventFieldGameControllerJoyStickAxisX);
XCTAssert (kIOHIDEventFieldGameControllerJoyStickAxisY == base::kIOHIDEventFieldGameControllerJoyStickAxisY, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerJoyStickAxisY, base::kIOHIDEventFieldGameControllerJoyStickAxisY);
XCTAssert (kIOHIDEventFieldGameControllerJoyStickAxisZ == base::kIOHIDEventFieldGameControllerJoyStickAxisZ, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerJoyStickAxisZ, base::kIOHIDEventFieldGameControllerJoyStickAxisZ);
XCTAssert (kIOHIDEventFieldGameControllerJoyStickAxisRz == base::kIOHIDEventFieldGameControllerJoyStickAxisRz, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerJoyStickAxisRz, base::kIOHIDEventFieldGameControllerJoyStickAxisRz);
XCTAssert (kIOHIDEventFieldGameControllerShoulderButtonL1 == base::kIOHIDEventFieldGameControllerShoulderButtonL1, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerShoulderButtonL1, base::kIOHIDEventFieldGameControllerShoulderButtonL1);
XCTAssert (kIOHIDEventFieldGameControllerShoulderButtonL2 == base::kIOHIDEventFieldGameControllerShoulderButtonL2, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerShoulderButtonL2, base::kIOHIDEventFieldGameControllerShoulderButtonL2);
XCTAssert (kIOHIDEventFieldGameControllerShoulderButtonR1 == base::kIOHIDEventFieldGameControllerShoulderButtonR1, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerShoulderButtonR1, base::kIOHIDEventFieldGameControllerShoulderButtonR1);
XCTAssert (kIOHIDEventFieldGameControllerShoulderButtonR2 == base::kIOHIDEventFieldGameControllerShoulderButtonR2, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldGameControllerShoulderButtonR2, base::kIOHIDEventFieldGameControllerShoulderButtonR2);
XCTAssert (kIOHIDEventFieldHumidityRH == base::kIOHIDEventFieldHumidityRH, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldHumidityRH, base::kIOHIDEventFieldHumidityRH);
XCTAssert (kIOHIDEventFieldHumiditySequence == base::kIOHIDEventFieldHumiditySequence, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldHumiditySequence, base::kIOHIDEventFieldHumiditySequence);
XCTAssert (kIOHIDEventFieldCurrentBrightness == base::kIOHIDEventFieldCurrentBrightness, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldCurrentBrightness, base::kIOHIDEventFieldCurrentBrightness);
XCTAssert (kIOHIDEventFieldTargetBrightness == base::kIOHIDEventFieldTargetBrightness, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldTargetBrightness, base::kIOHIDEventFieldTargetBrightness);
XCTAssert (kIOHIDEventFieldTransitionTime == base::kIOHIDEventFieldTransitionTime, "Field token value:0x%x expected:0x%x", kIOHIDEventFieldTransitionTime, base::kIOHIDEventFieldTransitionTime);

XCTAssert (offsetof(IOHIDVendorDefinedEventData,usagePage) == offsetof(base::IOHIDVendorDefinedEventData,usagePage), "Offset:%lu expected:%lu", offsetof(IOHIDVendorDefinedEventData,usagePage), offsetof(base::IOHIDVendorDefinedEventData,usagePage));
XCTAssert (offsetof(IOHIDVendorDefinedEventData,usage) == offsetof(base::IOHIDVendorDefinedEventData,usage), "Offset:%lu expected:%lu", offsetof(IOHIDVendorDefinedEventData,usage), offsetof(base::IOHIDVendorDefinedEventData,usage));
XCTAssert (offsetof(IOHIDVendorDefinedEventData,version) == offsetof(base::IOHIDVendorDefinedEventData,version), "Offset:%lu expected:%lu", offsetof(IOHIDVendorDefinedEventData,version), offsetof(base::IOHIDVendorDefinedEventData,version));
XCTAssert (offsetof(IOHIDVendorDefinedEventData,length) == offsetof(base::IOHIDVendorDefinedEventData,length), "Offset:%lu expected:%lu", offsetof(IOHIDVendorDefinedEventData,length), offsetof(base::IOHIDVendorDefinedEventData,length));
XCTAssert (offsetof(IOHIDVendorDefinedEventData,data) == offsetof(base::IOHIDVendorDefinedEventData,data), "Offset:%lu expected:%lu", offsetof(IOHIDVendorDefinedEventData,data), offsetof(base::IOHIDVendorDefinedEventData,data));
XCTAssert (offsetof(IOHIDKeyboardEventData,usagePage) == offsetof(base::IOHIDKeyboardEventData,usagePage), "Offset:%lu expected:%lu", offsetof(IOHIDKeyboardEventData,usagePage), offsetof(base::IOHIDKeyboardEventData,usagePage));
XCTAssert (offsetof(IOHIDKeyboardEventData,usage) == offsetof(base::IOHIDKeyboardEventData,usage), "Offset:%lu expected:%lu", offsetof(IOHIDKeyboardEventData,usage), offsetof(base::IOHIDKeyboardEventData,usage));
XCTAssert (offsetof(IOHIDKeyboardEventData,down) == offsetof(base::IOHIDKeyboardEventData,down), "Offset:%lu expected:%lu", offsetof(IOHIDKeyboardEventData,down), offsetof(base::IOHIDKeyboardEventData,down));
XCTAssert (offsetof(IOHIDKeyboardEventData,pressCount) == offsetof(base::IOHIDKeyboardEventData,pressCount), "Offset:%lu expected:%lu", offsetof(IOHIDKeyboardEventData,pressCount), offsetof(base::IOHIDKeyboardEventData,pressCount));
XCTAssert (offsetof(IOHIDUnicodeEventData,encoding) == offsetof(base::IOHIDUnicodeEventData,encoding), "Offset:%lu expected:%lu", offsetof(IOHIDUnicodeEventData,encoding), offsetof(base::IOHIDUnicodeEventData,encoding));
XCTAssert (offsetof(IOHIDUnicodeEventData,quality) == offsetof(base::IOHIDUnicodeEventData,quality), "Offset:%lu expected:%lu", offsetof(IOHIDUnicodeEventData,quality), offsetof(base::IOHIDUnicodeEventData,quality));
XCTAssert (offsetof(IOHIDUnicodeEventData,length) == offsetof(base::IOHIDUnicodeEventData,length), "Offset:%lu expected:%lu", offsetof(IOHIDUnicodeEventData,length), offsetof(base::IOHIDUnicodeEventData,length));
XCTAssert (offsetof(IOHIDUnicodeEventData,payload) == offsetof(base::IOHIDUnicodeEventData,payload), "Offset:%lu expected:%lu", offsetof(IOHIDUnicodeEventData,payload), offsetof(base::IOHIDUnicodeEventData,payload));
XCTAssert (offsetof(IOHIDLEDEventData,mask) == offsetof(base::IOHIDLEDEventData,mask), "Offset:%lu expected:%lu", offsetof(IOHIDLEDEventData,mask), offsetof(base::IOHIDLEDEventData,mask));
XCTAssert (offsetof(IOHIDLEDEventData,number) == offsetof(base::IOHIDLEDEventData,number), "Offset:%lu expected:%lu", offsetof(IOHIDLEDEventData,number), offsetof(base::IOHIDLEDEventData,number));
XCTAssert (offsetof(IOHIDLEDEventData,state) == offsetof(base::IOHIDLEDEventData,state), "Offset:%lu expected:%lu", offsetof(IOHIDLEDEventData,state), offsetof(base::IOHIDLEDEventData,state));
XCTAssert (offsetof(IOHIDRotationEventData,position.x) == offsetof(base::IOHIDRotationEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDRotationEventData,position.x), offsetof(base::IOHIDRotationEventData,position.x));
XCTAssert (offsetof(IOHIDRotationEventData,position.y) == offsetof(base::IOHIDRotationEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDRotationEventData,position.y), offsetof(base::IOHIDRotationEventData,position.y));
XCTAssert (offsetof(IOHIDRotationEventData,position.z) == offsetof(base::IOHIDRotationEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDRotationEventData,position.z), offsetof(base::IOHIDRotationEventData,position.z));
XCTAssert (offsetof(IOHIDVelocityEventData,position.x) == offsetof(base::IOHIDVelocityEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDVelocityEventData,position.x), offsetof(base::IOHIDVelocityEventData,position.x));
XCTAssert (offsetof(IOHIDVelocityEventData,position.y) == offsetof(base::IOHIDVelocityEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDVelocityEventData,position.y), offsetof(base::IOHIDVelocityEventData,position.y));
XCTAssert (offsetof(IOHIDVelocityEventData,position.z) == offsetof(base::IOHIDVelocityEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDVelocityEventData,position.z), offsetof(base::IOHIDVelocityEventData,position.z));
XCTAssert (offsetof(IOHIDTranslationEventData,position.x) == offsetof(base::IOHIDTranslationEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDTranslationEventData,position.x), offsetof(base::IOHIDTranslationEventData,position.x));
XCTAssert (offsetof(IOHIDTranslationEventData,position.y) == offsetof(base::IOHIDTranslationEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDTranslationEventData,position.y), offsetof(base::IOHIDTranslationEventData,position.y));
XCTAssert (offsetof(IOHIDTranslationEventData,position.z) == offsetof(base::IOHIDTranslationEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDTranslationEventData,position.z), offsetof(base::IOHIDTranslationEventData,position.z));
XCTAssert (offsetof(IOHIDScrollEventData,position.x) == offsetof(base::IOHIDScrollEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDScrollEventData,position.x), offsetof(base::IOHIDScrollEventData,position.x));
XCTAssert (offsetof(IOHIDScrollEventData,position.y) == offsetof(base::IOHIDScrollEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDScrollEventData,position.y), offsetof(base::IOHIDScrollEventData,position.y));
XCTAssert (offsetof(IOHIDScrollEventData,position.z) == offsetof(base::IOHIDScrollEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDScrollEventData,position.z), offsetof(base::IOHIDScrollEventData,position.z));
XCTAssert (offsetof(IOHIDScaleEventData,position.x) == offsetof(base::IOHIDScaleEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDScaleEventData,position.x), offsetof(base::IOHIDScaleEventData,position.x));
XCTAssert (offsetof(IOHIDScaleEventData,position.y) == offsetof(base::IOHIDScaleEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDScaleEventData,position.y), offsetof(base::IOHIDScaleEventData,position.y));
XCTAssert (offsetof(IOHIDScaleEventData,position.z) == offsetof(base::IOHIDScaleEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDScaleEventData,position.z), offsetof(base::IOHIDScaleEventData,position.z));
XCTAssert (offsetof(IOHIDOrientationEventData,orientation.polar.x) == offsetof(base::IOHIDOrientationEventData,orientation.polar.x), "Offset:%lu expected:%lu", offsetof(IOHIDOrientationEventData,orientation.polar.x), offsetof(base::IOHIDOrientationEventData,orientation.polar.x));
XCTAssert (offsetof(IOHIDOrientationEventData,orientation.polar.y) == offsetof(base::IOHIDOrientationEventData,orientation.polar.y), "Offset:%lu expected:%lu", offsetof(IOHIDOrientationEventData,orientation.polar.y), offsetof(base::IOHIDOrientationEventData,orientation.polar.y));
XCTAssert (offsetof(IOHIDOrientationEventData,orientation.polar.z) == offsetof(base::IOHIDOrientationEventData,orientation.polar.z), "Offset:%lu expected:%lu", offsetof(IOHIDOrientationEventData,orientation.polar.z), offsetof(base::IOHIDOrientationEventData,orientation.polar.z));
XCTAssert (offsetof(IOHIDAccelerometerEventData,position.x) == offsetof(base::IOHIDAccelerometerEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDAccelerometerEventData,position.x), offsetof(base::IOHIDAccelerometerEventData,position.x));
XCTAssert (offsetof(IOHIDAccelerometerEventData,position.y) == offsetof(base::IOHIDAccelerometerEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDAccelerometerEventData,position.y), offsetof(base::IOHIDAccelerometerEventData,position.y));
XCTAssert (offsetof(IOHIDAccelerometerEventData,position.z) == offsetof(base::IOHIDAccelerometerEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDAccelerometerEventData,position.z), offsetof(base::IOHIDAccelerometerEventData,position.z));
XCTAssert (offsetof(IOHIDAccelerometerEventData,motionType) == offsetof(base::IOHIDAccelerometerEventData,motionType), "Offset:%lu expected:%lu", offsetof(IOHIDAccelerometerEventData,motionType), offsetof(base::IOHIDAccelerometerEventData,motionType));
XCTAssert (offsetof(IOHIDAccelerometerEventData,motionSubType) == offsetof(base::IOHIDAccelerometerEventData,motionSubType), "Offset:%lu expected:%lu", offsetof(IOHIDAccelerometerEventData,motionSubType), offsetof(base::IOHIDAccelerometerEventData,motionSubType));
XCTAssert (offsetof(IOHIDAccelerometerEventData,motionSequence) == offsetof(base::IOHIDAccelerometerEventData,motionSequence), "Offset:%lu expected:%lu", offsetof(IOHIDAccelerometerEventData,motionSequence), offsetof(base::IOHIDAccelerometerEventData,motionSequence));
XCTAssert (offsetof(IOHIDGyroEventData,position.x) == offsetof(base::IOHIDGyroEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDGyroEventData,position.x), offsetof(base::IOHIDGyroEventData,position.x));
XCTAssert (offsetof(IOHIDGyroEventData,position.y) == offsetof(base::IOHIDGyroEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDGyroEventData,position.y), offsetof(base::IOHIDGyroEventData,position.y));
XCTAssert (offsetof(IOHIDGyroEventData,position.z) == offsetof(base::IOHIDGyroEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDGyroEventData,position.z), offsetof(base::IOHIDGyroEventData,position.z));
XCTAssert (offsetof(IOHIDGyroEventData,motionType) == offsetof(base::IOHIDGyroEventData,motionType), "Offset:%lu expected:%lu", offsetof(IOHIDGyroEventData,motionType), offsetof(base::IOHIDGyroEventData,motionType));
XCTAssert (offsetof(IOHIDGyroEventData,motionSubType) == offsetof(base::IOHIDGyroEventData,motionSubType), "Offset:%lu expected:%lu", offsetof(IOHIDGyroEventData,motionSubType), offsetof(base::IOHIDGyroEventData,motionSubType));
XCTAssert (offsetof(IOHIDGyroEventData,motionSequence) == offsetof(base::IOHIDGyroEventData,motionSequence), "Offset:%lu expected:%lu", offsetof(IOHIDGyroEventData,motionSequence), offsetof(base::IOHIDGyroEventData,motionSequence));
XCTAssert (offsetof(IOHIDCompassEventData,position.x) == offsetof(base::IOHIDCompassEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDCompassEventData,position.x), offsetof(base::IOHIDCompassEventData,position.x));
XCTAssert (offsetof(IOHIDCompassEventData,position.y) == offsetof(base::IOHIDCompassEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDCompassEventData,position.y), offsetof(base::IOHIDCompassEventData,position.y));
XCTAssert (offsetof(IOHIDCompassEventData,position.z) == offsetof(base::IOHIDCompassEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDCompassEventData,position.z), offsetof(base::IOHIDCompassEventData,position.z));
XCTAssert (offsetof(IOHIDCompassEventData,motionType) == offsetof(base::IOHIDCompassEventData,motionType), "Offset:%lu expected:%lu", offsetof(IOHIDCompassEventData,motionType), offsetof(base::IOHIDCompassEventData,motionType));
XCTAssert (offsetof(IOHIDCompassEventData,motionSubType) == offsetof(base::IOHIDCompassEventData,motionSubType), "Offset:%lu expected:%lu", offsetof(IOHIDCompassEventData,motionSubType), offsetof(base::IOHIDCompassEventData,motionSubType));
XCTAssert (offsetof(IOHIDCompassEventData,motionSequence) == offsetof(base::IOHIDCompassEventData,motionSequence), "Offset:%lu expected:%lu", offsetof(IOHIDCompassEventData,motionSequence), offsetof(base::IOHIDCompassEventData,motionSequence));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,level) == offsetof(base::IOHIDAmbientLightSensorEventData,level), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,level), offsetof(base::IOHIDAmbientLightSensorEventData,level));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,ch0) == offsetof(base::IOHIDAmbientLightSensorEventData,ch0), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,ch0), offsetof(base::IOHIDAmbientLightSensorEventData,ch0));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,ch1) == offsetof(base::IOHIDAmbientLightSensorEventData,ch1), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,ch1), offsetof(base::IOHIDAmbientLightSensorEventData,ch1));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,ch2) == offsetof(base::IOHIDAmbientLightSensorEventData,ch2), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,ch2), offsetof(base::IOHIDAmbientLightSensorEventData,ch2));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,ch3) == offsetof(base::IOHIDAmbientLightSensorEventData,ch3), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,ch3), offsetof(base::IOHIDAmbientLightSensorEventData,ch3));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,brightnessChanged) == offsetof(base::IOHIDAmbientLightSensorEventData,brightnessChanged), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,brightnessChanged), offsetof(base::IOHIDAmbientLightSensorEventData,brightnessChanged));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,colorSpace) == offsetof(base::IOHIDAmbientLightSensorEventData,colorSpace), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,colorSpace), offsetof(base::IOHIDAmbientLightSensorEventData,colorSpace));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,colorComponent0) == offsetof(base::IOHIDAmbientLightSensorEventData,colorComponent0), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,colorComponent0), offsetof(base::IOHIDAmbientLightSensorEventData,colorComponent0));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,colorComponent1) == offsetof(base::IOHIDAmbientLightSensorEventData,colorComponent1), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,colorComponent1), offsetof(base::IOHIDAmbientLightSensorEventData,colorComponent1));
XCTAssert (offsetof(IOHIDAmbientLightSensorEventData,colorComponent2) == offsetof(base::IOHIDAmbientLightSensorEventData,colorComponent2), "Offset:%lu expected:%lu", offsetof(IOHIDAmbientLightSensorEventData,colorComponent2), offsetof(base::IOHIDAmbientLightSensorEventData,colorComponent2));
XCTAssert (offsetof(IOHIDTemperatureEventData,level) == offsetof(base::IOHIDTemperatureEventData,level), "Offset:%lu expected:%lu", offsetof(IOHIDTemperatureEventData,level), offsetof(base::IOHIDTemperatureEventData,level));
XCTAssert (offsetof(IOHIDProximityEventData,detectionMask) == offsetof(base::IOHIDProximityEventData,detectionMask), "Offset:%lu expected:%lu", offsetof(IOHIDProximityEventData,detectionMask), offsetof(base::IOHIDProximityEventData,detectionMask));
XCTAssert (offsetof(IOHIDProximityEventData,level) == offsetof(base::IOHIDProximityEventData,level), "Offset:%lu expected:%lu", offsetof(IOHIDProximityEventData,level), offsetof(base::IOHIDProximityEventData,level));
XCTAssert (offsetof(IOHIDProgressEventData,eventType) == offsetof(base::IOHIDProgressEventData,eventType), "Offset:%lu expected:%lu", offsetof(IOHIDProgressEventData,eventType), offsetof(base::IOHIDProgressEventData,eventType));
XCTAssert (offsetof(IOHIDProgressEventData,level) == offsetof(base::IOHIDProgressEventData,level), "Offset:%lu expected:%lu", offsetof(IOHIDProgressEventData,level), offsetof(base::IOHIDProgressEventData,level));
XCTAssert (offsetof(IOHIDBiometricEventData,eventType) == offsetof(base::IOHIDBiometricEventData,eventType), "Offset:%lu expected:%lu", offsetof(IOHIDBiometricEventData,eventType), offsetof(base::IOHIDBiometricEventData,eventType));
XCTAssert (offsetof(IOHIDBiometricEventData,level) == offsetof(base::IOHIDBiometricEventData,level), "Offset:%lu expected:%lu", offsetof(IOHIDBiometricEventData,level), offsetof(base::IOHIDBiometricEventData,level));
XCTAssert (offsetof(IOHIDBiometricEventData,usagePage) == offsetof(base::IOHIDBiometricEventData,usagePage), "Offset:%lu expected:%lu", offsetof(IOHIDBiometricEventData,usagePage), offsetof(base::IOHIDBiometricEventData,usagePage));
XCTAssert (offsetof(IOHIDBiometricEventData,usage) == offsetof(base::IOHIDBiometricEventData,usage), "Offset:%lu expected:%lu", offsetof(IOHIDBiometricEventData,usage), offsetof(base::IOHIDBiometricEventData,usage));
XCTAssert (offsetof(IOHIDBiometricEventData,tapCount) == offsetof(base::IOHIDBiometricEventData,tapCount), "Offset:%lu expected:%lu", offsetof(IOHIDBiometricEventData,tapCount), offsetof(base::IOHIDBiometricEventData,tapCount));
XCTAssert (offsetof(IOHIDButtonEventData,mask) == offsetof(base::IOHIDButtonEventData,mask), "Offset:%lu expected:%lu", offsetof(IOHIDButtonEventData,mask), offsetof(base::IOHIDButtonEventData,mask));
XCTAssert (offsetof(IOHIDButtonEventData,pressure) == offsetof(base::IOHIDButtonEventData,pressure), "Offset:%lu expected:%lu", offsetof(IOHIDButtonEventData,pressure), offsetof(base::IOHIDButtonEventData,pressure));
XCTAssert (offsetof(IOHIDButtonEventData,number) == offsetof(base::IOHIDButtonEventData,number), "Offset:%lu expected:%lu", offsetof(IOHIDButtonEventData,number), offsetof(base::IOHIDButtonEventData,number));
XCTAssert (offsetof(IOHIDButtonEventData,clickCount) == offsetof(base::IOHIDButtonEventData,clickCount), "Offset:%lu expected:%lu", offsetof(IOHIDButtonEventData,clickCount), offsetof(base::IOHIDButtonEventData,clickCount));
XCTAssert (offsetof(IOHIDButtonEventData,state) == offsetof(base::IOHIDButtonEventData,state), "Offset:%lu expected:%lu", offsetof(IOHIDButtonEventData,state), offsetof(base::IOHIDButtonEventData,state));
XCTAssert (offsetof(IOHIDPointerEventData,position.x) == offsetof(base::IOHIDPointerEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDPointerEventData,position.x), offsetof(base::IOHIDPointerEventData,position.x));
XCTAssert (offsetof(IOHIDPointerEventData,position.y) == offsetof(base::IOHIDPointerEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDPointerEventData,position.y), offsetof(base::IOHIDPointerEventData,position.y));
XCTAssert (offsetof(IOHIDPointerEventData,position.z) == offsetof(base::IOHIDPointerEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDPointerEventData,position.z), offsetof(base::IOHIDPointerEventData,position.z));
XCTAssert (offsetof(IOHIDPointerEventData,button.mask) == offsetof(base::IOHIDPointerEventData,button.mask), "Offset:%lu expected:%lu", offsetof(IOHIDPointerEventData,button.mask), offsetof(base::IOHIDPointerEventData,button.mask));
XCTAssert (offsetof(IOHIDMultiAxisPointerEventData,position.x) == offsetof(base::IOHIDMultiAxisPointerEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDMultiAxisPointerEventData,position.x), offsetof(base::IOHIDMultiAxisPointerEventData,position.x));
XCTAssert (offsetof(IOHIDMultiAxisPointerEventData,position.y) == offsetof(base::IOHIDMultiAxisPointerEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDMultiAxisPointerEventData,position.y), offsetof(base::IOHIDMultiAxisPointerEventData,position.y));
XCTAssert (offsetof(IOHIDMultiAxisPointerEventData,position.z) == offsetof(base::IOHIDMultiAxisPointerEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDMultiAxisPointerEventData,position.z), offsetof(base::IOHIDMultiAxisPointerEventData,position.z));
XCTAssert (offsetof(IOHIDMultiAxisPointerEventData,button.mask) == offsetof(base::IOHIDMultiAxisPointerEventData,button.mask), "Offset:%lu expected:%lu", offsetof(IOHIDMultiAxisPointerEventData,button.mask), offsetof(base::IOHIDMultiAxisPointerEventData,button.mask));
XCTAssert (offsetof(IOHIDMultiAxisPointerEventData,rotation.x) == offsetof(base::IOHIDMultiAxisPointerEventData,rotation.x), "Offset:%lu expected:%lu", offsetof(IOHIDMultiAxisPointerEventData,rotation.x), offsetof(base::IOHIDMultiAxisPointerEventData,rotation.x));
XCTAssert (offsetof(IOHIDMultiAxisPointerEventData,rotation.y) == offsetof(base::IOHIDMultiAxisPointerEventData,rotation.y), "Offset:%lu expected:%lu", offsetof(IOHIDMultiAxisPointerEventData,rotation.y), offsetof(base::IOHIDMultiAxisPointerEventData,rotation.y));
XCTAssert (offsetof(IOHIDMultiAxisPointerEventData,rotation.z) == offsetof(base::IOHIDMultiAxisPointerEventData,rotation.z), "Offset:%lu expected:%lu", offsetof(IOHIDMultiAxisPointerEventData,rotation.z), offsetof(base::IOHIDMultiAxisPointerEventData,rotation.z));
XCTAssert (offsetof(IOHIDDigitizerEventData,position.x) == offsetof(base::IOHIDDigitizerEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,position.x), offsetof(base::IOHIDDigitizerEventData,position.x));
XCTAssert (offsetof(IOHIDDigitizerEventData,position.y) == offsetof(base::IOHIDDigitizerEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,position.y), offsetof(base::IOHIDDigitizerEventData,position.y));
XCTAssert (offsetof(IOHIDDigitizerEventData,position.z) == offsetof(base::IOHIDDigitizerEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,position.z), offsetof(base::IOHIDDigitizerEventData,position.z));
XCTAssert (offsetof(IOHIDDigitizerEventData,transducerIndex) == offsetof(base::IOHIDDigitizerEventData,transducerIndex), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,transducerIndex), offsetof(base::IOHIDDigitizerEventData,transducerIndex));
XCTAssert (offsetof(IOHIDDigitizerEventData,transducerType) == offsetof(base::IOHIDDigitizerEventData,transducerType), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,transducerType), offsetof(base::IOHIDDigitizerEventData,transducerType));
XCTAssert (offsetof(IOHIDDigitizerEventData,identity) == offsetof(base::IOHIDDigitizerEventData,identity), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,identity), offsetof(base::IOHIDDigitizerEventData,identity));
XCTAssert (offsetof(IOHIDDigitizerEventData,eventMask) == offsetof(base::IOHIDDigitizerEventData,eventMask), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,eventMask), offsetof(base::IOHIDDigitizerEventData,eventMask));
XCTAssert (offsetof(IOHIDDigitizerEventData,childEventMask) == offsetof(base::IOHIDDigitizerEventData,childEventMask), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,childEventMask), offsetof(base::IOHIDDigitizerEventData,childEventMask));
XCTAssert (offsetof(IOHIDDigitizerEventData,buttonMask) == offsetof(base::IOHIDDigitizerEventData,buttonMask), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,buttonMask), offsetof(base::IOHIDDigitizerEventData,buttonMask));
XCTAssert (offsetof(IOHIDDigitizerEventData,pressure) == offsetof(base::IOHIDDigitizerEventData,pressure), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,pressure), offsetof(base::IOHIDDigitizerEventData,pressure));
XCTAssert (offsetof(IOHIDDigitizerEventData,auxPressure) == offsetof(base::IOHIDDigitizerEventData,auxPressure), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,auxPressure), offsetof(base::IOHIDDigitizerEventData,auxPressure));
XCTAssert (offsetof(IOHIDDigitizerEventData,twist) == offsetof(base::IOHIDDigitizerEventData,twist), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,twist), offsetof(base::IOHIDDigitizerEventData,twist));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientationType) == offsetof(base::IOHIDDigitizerEventData,orientationType), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientationType), offsetof(base::IOHIDDigitizerEventData,orientationType));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.tilt.x) == offsetof(base::IOHIDDigitizerEventData,orientation.tilt.x), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.tilt.x), offsetof(base::IOHIDDigitizerEventData,orientation.tilt.x));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.tilt.y) == offsetof(base::IOHIDDigitizerEventData,orientation.tilt.y), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.tilt.y), offsetof(base::IOHIDDigitizerEventData,orientation.tilt.y));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.polar.altitude) == offsetof(base::IOHIDDigitizerEventData,orientation.polar.altitude), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.polar.altitude), offsetof(base::IOHIDDigitizerEventData,orientation.polar.altitude));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.polar.azimuth) == offsetof(base::IOHIDDigitizerEventData,orientation.polar.azimuth), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.polar.azimuth), offsetof(base::IOHIDDigitizerEventData,orientation.polar.azimuth));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.polar.quality) == offsetof(base::IOHIDDigitizerEventData,orientation.polar.quality), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.polar.quality), offsetof(base::IOHIDDigitizerEventData,orientation.polar.quality));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.polar.density) == offsetof(base::IOHIDDigitizerEventData,orientation.polar.density), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.polar.density), offsetof(base::IOHIDDigitizerEventData,orientation.polar.density));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.polar.majorRadius) == offsetof(base::IOHIDDigitizerEventData,orientation.polar.majorRadius), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.polar.majorRadius), offsetof(base::IOHIDDigitizerEventData,orientation.polar.majorRadius));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.polar.minorRadius) == offsetof(base::IOHIDDigitizerEventData,orientation.polar.minorRadius), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.polar.minorRadius), offsetof(base::IOHIDDigitizerEventData,orientation.polar.minorRadius));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.quality.quality) == offsetof(base::IOHIDDigitizerEventData,orientation.quality.quality), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.quality.quality), offsetof(base::IOHIDDigitizerEventData,orientation.quality.quality));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.quality.density) == offsetof(base::IOHIDDigitizerEventData,orientation.quality.density), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.quality.density), offsetof(base::IOHIDDigitizerEventData,orientation.quality.density));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.quality.irregularity) == offsetof(base::IOHIDDigitizerEventData,orientation.quality.irregularity), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.quality.irregularity), offsetof(base::IOHIDDigitizerEventData,orientation.quality.irregularity));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.quality.majorRadius) == offsetof(base::IOHIDDigitizerEventData,orientation.quality.majorRadius), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.quality.majorRadius), offsetof(base::IOHIDDigitizerEventData,orientation.quality.majorRadius));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.quality.minorRadius) == offsetof(base::IOHIDDigitizerEventData,orientation.quality.minorRadius), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.quality.minorRadius), offsetof(base::IOHIDDigitizerEventData,orientation.quality.minorRadius));
XCTAssert (offsetof(IOHIDDigitizerEventData,orientation.quality.accuracy) == offsetof(base::IOHIDDigitizerEventData,orientation.quality.accuracy), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,orientation.quality.accuracy), offsetof(base::IOHIDDigitizerEventData,orientation.quality.accuracy));
XCTAssert (offsetof(IOHIDDigitizerEventData,generationCount) == offsetof(base::IOHIDDigitizerEventData,generationCount), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,generationCount), offsetof(base::IOHIDDigitizerEventData,generationCount));
XCTAssert (offsetof(IOHIDDigitizerEventData,willUpdateMask) == offsetof(base::IOHIDDigitizerEventData,willUpdateMask), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,willUpdateMask), offsetof(base::IOHIDDigitizerEventData,willUpdateMask));
XCTAssert (offsetof(IOHIDDigitizerEventData,didUpdateMask) == offsetof(base::IOHIDDigitizerEventData,didUpdateMask), "Offset:%lu expected:%lu", offsetof(IOHIDDigitizerEventData,didUpdateMask), offsetof(base::IOHIDDigitizerEventData,didUpdateMask));
XCTAssert (offsetof(IOHIDNavigationSwipeEventData,position.x) == offsetof(base::IOHIDNavigationSwipeEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDNavigationSwipeEventData,position.x), offsetof(base::IOHIDNavigationSwipeEventData,position.x));
XCTAssert (offsetof(IOHIDNavigationSwipeEventData,position.y) == offsetof(base::IOHIDNavigationSwipeEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDNavigationSwipeEventData,position.y), offsetof(base::IOHIDNavigationSwipeEventData,position.y));
XCTAssert (offsetof(IOHIDNavigationSwipeEventData,position.z) == offsetof(base::IOHIDNavigationSwipeEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDNavigationSwipeEventData,position.z), offsetof(base::IOHIDNavigationSwipeEventData,position.z));
XCTAssert (offsetof(IOHIDNavigationSwipeEventData,swipeMask) == offsetof(base::IOHIDNavigationSwipeEventData,swipeMask), "Offset:%lu expected:%lu", offsetof(IOHIDNavigationSwipeEventData,swipeMask), offsetof(base::IOHIDNavigationSwipeEventData,swipeMask));
XCTAssert (offsetof(IOHIDNavigationSwipeEventData,gestureMotion) == offsetof(base::IOHIDNavigationSwipeEventData,gestureMotion), "Offset:%lu expected:%lu", offsetof(IOHIDNavigationSwipeEventData,gestureMotion), offsetof(base::IOHIDNavigationSwipeEventData,gestureMotion));
XCTAssert (offsetof(IOHIDNavigationSwipeEventData,flavor) == offsetof(base::IOHIDNavigationSwipeEventData,flavor), "Offset:%lu expected:%lu", offsetof(IOHIDNavigationSwipeEventData,flavor), offsetof(base::IOHIDNavigationSwipeEventData,flavor));
XCTAssert (offsetof(IOHIDNavigationSwipeEventData,progress) == offsetof(base::IOHIDNavigationSwipeEventData,progress), "Offset:%lu expected:%lu", offsetof(IOHIDNavigationSwipeEventData,progress), offsetof(base::IOHIDNavigationSwipeEventData,progress));
XCTAssert (offsetof(IOHIDDockSwipeEventData,position.x) == offsetof(base::IOHIDDockSwipeEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDDockSwipeEventData,position.x), offsetof(base::IOHIDDockSwipeEventData,position.x));
XCTAssert (offsetof(IOHIDDockSwipeEventData,position.y) == offsetof(base::IOHIDDockSwipeEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDDockSwipeEventData,position.y), offsetof(base::IOHIDDockSwipeEventData,position.y));
XCTAssert (offsetof(IOHIDDockSwipeEventData,position.z) == offsetof(base::IOHIDDockSwipeEventData,position.z), "Offset:%lu expected:%lu", offsetof(IOHIDDockSwipeEventData,position.z), offsetof(base::IOHIDDockSwipeEventData,position.z));
XCTAssert (offsetof(IOHIDDockSwipeEventData,swipeMask) == offsetof(base::IOHIDDockSwipeEventData,swipeMask), "Offset:%lu expected:%lu", offsetof(IOHIDDockSwipeEventData,swipeMask), offsetof(base::IOHIDDockSwipeEventData,swipeMask));
XCTAssert (offsetof(IOHIDDockSwipeEventData,gestureMotion) == offsetof(base::IOHIDDockSwipeEventData,gestureMotion), "Offset:%lu expected:%lu", offsetof(IOHIDDockSwipeEventData,gestureMotion), offsetof(base::IOHIDDockSwipeEventData,gestureMotion));
XCTAssert (offsetof(IOHIDDockSwipeEventData,flavor) == offsetof(base::IOHIDDockSwipeEventData,flavor), "Offset:%lu expected:%lu", offsetof(IOHIDDockSwipeEventData,flavor), offsetof(base::IOHIDDockSwipeEventData,flavor));
XCTAssert (offsetof(IOHIDDockSwipeEventData,progress) == offsetof(base::IOHIDDockSwipeEventData,progress), "Offset:%lu expected:%lu", offsetof(IOHIDDockSwipeEventData,progress), offsetof(base::IOHIDDockSwipeEventData,progress));
XCTAssert (offsetof(IOHIDFluidTouchGestureEventData,position.x) == offsetof(base::IOHIDFluidTouchGestureEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDFluidTouchGestureEventData,position.x), offsetof(base::IOHIDFluidTouchGestureEventData,position.x));
XCTAssert (offsetof(IOHIDFluidTouchGestureEventData,position.y) == offsetof(base::IOHIDFluidTouchGestureEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDFluidTouchGestureEventData,position.y), offsetof(base::IOHIDFluidTouchGestureEventData,position.y));
XCTAssert (offsetof(IOHIDFluidTouchGestureEventData,swipeMask) == offsetof(base::IOHIDFluidTouchGestureEventData,swipeMask), "Offset:%lu expected:%lu", offsetof(IOHIDFluidTouchGestureEventData,swipeMask), offsetof(base::IOHIDFluidTouchGestureEventData,swipeMask));
XCTAssert (offsetof(IOHIDFluidTouchGestureEventData,gestureMotion) == offsetof(base::IOHIDFluidTouchGestureEventData,gestureMotion), "Offset:%lu expected:%lu", offsetof(IOHIDFluidTouchGestureEventData,gestureMotion), offsetof(base::IOHIDFluidTouchGestureEventData,gestureMotion));
XCTAssert (offsetof(IOHIDFluidTouchGestureEventData,flavor) == offsetof(base::IOHIDFluidTouchGestureEventData,flavor), "Offset:%lu expected:%lu", offsetof(IOHIDFluidTouchGestureEventData,flavor), offsetof(base::IOHIDFluidTouchGestureEventData,flavor));
XCTAssert (offsetof(IOHIDFluidTouchGestureEventData,progress) == offsetof(base::IOHIDFluidTouchGestureEventData,progress), "Offset:%lu expected:%lu", offsetof(IOHIDFluidTouchGestureEventData,progress), offsetof(base::IOHIDFluidTouchGestureEventData,progress));
XCTAssert (offsetof(IOHIDBoundaryScrollEventData,position.x) == offsetof(base::IOHIDBoundaryScrollEventData,position.x), "Offset:%lu expected:%lu", offsetof(IOHIDBoundaryScrollEventData,position.x), offsetof(base::IOHIDBoundaryScrollEventData,position.x));
XCTAssert (offsetof(IOHIDBoundaryScrollEventData,position.y) == offsetof(base::IOHIDBoundaryScrollEventData,position.y), "Offset:%lu expected:%lu", offsetof(IOHIDBoundaryScrollEventData,position.y), offsetof(base::IOHIDBoundaryScrollEventData,position.y));
XCTAssert (offsetof(IOHIDBoundaryScrollEventData,swipeMask) == offsetof(base::IOHIDBoundaryScrollEventData,swipeMask), "Offset:%lu expected:%lu", offsetof(IOHIDBoundaryScrollEventData,swipeMask), offsetof(base::IOHIDBoundaryScrollEventData,swipeMask));
XCTAssert (offsetof(IOHIDBoundaryScrollEventData,gestureMotion) == offsetof(base::IOHIDBoundaryScrollEventData,gestureMotion), "Offset:%lu expected:%lu", offsetof(IOHIDBoundaryScrollEventData,gestureMotion), offsetof(base::IOHIDBoundaryScrollEventData,gestureMotion));
XCTAssert (offsetof(IOHIDBoundaryScrollEventData,flavor) == offsetof(base::IOHIDBoundaryScrollEventData,flavor), "Offset:%lu expected:%lu", offsetof(IOHIDBoundaryScrollEventData,flavor), offsetof(base::IOHIDBoundaryScrollEventData,flavor));
XCTAssert (offsetof(IOHIDBoundaryScrollEventData,progress) == offsetof(base::IOHIDBoundaryScrollEventData,progress), "Offset:%lu expected:%lu", offsetof(IOHIDBoundaryScrollEventData,progress), offsetof(base::IOHIDBoundaryScrollEventData,progress));
XCTAssert (offsetof(IOHIDSymbolicHotKeyEventData,hotKey) == offsetof(base::IOHIDSymbolicHotKeyEventData,hotKey), "Offset:%lu expected:%lu", offsetof(IOHIDSymbolicHotKeyEventData,hotKey), offsetof(base::IOHIDSymbolicHotKeyEventData,hotKey));
XCTAssert (offsetof(IOHIDPowerEventData,measurement) == offsetof(base::IOHIDPowerEventData,measurement), "Offset:%lu expected:%lu", offsetof(IOHIDPowerEventData,measurement), offsetof(base::IOHIDPowerEventData,measurement));
XCTAssert (offsetof(IOHIDPowerEventData,powerType) == offsetof(base::IOHIDPowerEventData,powerType), "Offset:%lu expected:%lu", offsetof(IOHIDPowerEventData,powerType), offsetof(base::IOHIDPowerEventData,powerType));
XCTAssert (offsetof(IOHIDPowerEventData,powerSubType) == offsetof(base::IOHIDPowerEventData,powerSubType), "Offset:%lu expected:%lu", offsetof(IOHIDPowerEventData,powerSubType), offsetof(base::IOHIDPowerEventData,powerSubType));
XCTAssert (offsetof(IOHIDAtmosphericPressureEventData,level) == offsetof(base::IOHIDAtmosphericPressureEventData,level), "Offset:%lu expected:%lu", offsetof(IOHIDAtmosphericPressureEventData,level), offsetof(base::IOHIDAtmosphericPressureEventData,level));
XCTAssert (offsetof(IOHIDAtmosphericPressureEventData,sequence) == offsetof(base::IOHIDAtmosphericPressureEventData,sequence), "Offset:%lu expected:%lu", offsetof(IOHIDAtmosphericPressureEventData,sequence), offsetof(base::IOHIDAtmosphericPressureEventData,sequence));
XCTAssert (offsetof(IOHIDForceEventData,behavior) == offsetof(base::IOHIDForceEventData,behavior), "Offset:%lu expected:%lu", offsetof(IOHIDForceEventData,behavior), offsetof(base::IOHIDForceEventData,behavior));
XCTAssert (offsetof(IOHIDForceEventData,progress) == offsetof(base::IOHIDForceEventData,progress), "Offset:%lu expected:%lu", offsetof(IOHIDForceEventData,progress), offsetof(base::IOHIDForceEventData,progress));
XCTAssert (offsetof(IOHIDForceEventData,stage) == offsetof(base::IOHIDForceEventData,stage), "Offset:%lu expected:%lu", offsetof(IOHIDForceEventData,stage), offsetof(base::IOHIDForceEventData,stage));
XCTAssert (offsetof(IOHIDForceEventData,stageProgress) == offsetof(base::IOHIDForceEventData,stageProgress), "Offset:%lu expected:%lu", offsetof(IOHIDForceEventData,stageProgress), offsetof(base::IOHIDForceEventData,stageProgress));
XCTAssert (offsetof(IOHIDMotionActivityEventData,activityType) == offsetof(base::IOHIDMotionActivityEventData,activityType), "Offset:%lu expected:%lu", offsetof(IOHIDMotionActivityEventData,activityType), offsetof(base::IOHIDMotionActivityEventData,activityType));
XCTAssert (offsetof(IOHIDMotionActivityEventData,confidence) == offsetof(base::IOHIDMotionActivityEventData,confidence), "Offset:%lu expected:%lu", offsetof(IOHIDMotionActivityEventData,confidence), offsetof(base::IOHIDMotionActivityEventData,confidence));
XCTAssert (offsetof(IOHIDMotionGestureEventData,gestureType) == offsetof(base::IOHIDMotionGestureEventData,gestureType), "Offset:%lu expected:%lu", offsetof(IOHIDMotionGestureEventData,gestureType), offsetof(base::IOHIDMotionGestureEventData,gestureType));
XCTAssert (offsetof(IOHIDMotionGestureEventData,progress) == offsetof(base::IOHIDMotionGestureEventData,progress), "Offset:%lu expected:%lu", offsetof(IOHIDMotionGestureEventData,progress), offsetof(base::IOHIDMotionGestureEventData,progress));
XCTAssert (offsetof(IOHIDGameControllerEventData,controllerType) == offsetof(base::IOHIDGameControllerEventData,controllerType), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,controllerType), offsetof(base::IOHIDGameControllerEventData,controllerType));
XCTAssert (offsetof(IOHIDGameControllerEventData,dpad.up) == offsetof(base::IOHIDGameControllerEventData,dpad.up), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,dpad.up), offsetof(base::IOHIDGameControllerEventData,dpad.up));
XCTAssert (offsetof(IOHIDGameControllerEventData,dpad.down) == offsetof(base::IOHIDGameControllerEventData,dpad.down), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,dpad.down), offsetof(base::IOHIDGameControllerEventData,dpad.down));
XCTAssert (offsetof(IOHIDGameControllerEventData,dpad.left) == offsetof(base::IOHIDGameControllerEventData,dpad.left), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,dpad.left), offsetof(base::IOHIDGameControllerEventData,dpad.left));
XCTAssert (offsetof(IOHIDGameControllerEventData,dpad.right) == offsetof(base::IOHIDGameControllerEventData,dpad.right), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,dpad.right), offsetof(base::IOHIDGameControllerEventData,dpad.right));
XCTAssert (offsetof(IOHIDGameControllerEventData,face.x) == offsetof(base::IOHIDGameControllerEventData,face.x), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,face.x), offsetof(base::IOHIDGameControllerEventData,face.x));
XCTAssert (offsetof(IOHIDGameControllerEventData,face.y) == offsetof(base::IOHIDGameControllerEventData,face.y), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,face.y), offsetof(base::IOHIDGameControllerEventData,face.y));
XCTAssert (offsetof(IOHIDGameControllerEventData,face.a) == offsetof(base::IOHIDGameControllerEventData,face.a), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,face.a), offsetof(base::IOHIDGameControllerEventData,face.a));
XCTAssert (offsetof(IOHIDGameControllerEventData,face.b) == offsetof(base::IOHIDGameControllerEventData,face.b), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,face.b), offsetof(base::IOHIDGameControllerEventData,face.b));
XCTAssert (offsetof(IOHIDGameControllerEventData,joystick.x) == offsetof(base::IOHIDGameControllerEventData,joystick.x), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,joystick.x), offsetof(base::IOHIDGameControllerEventData,joystick.x));
XCTAssert (offsetof(IOHIDGameControllerEventData,joystick.y) == offsetof(base::IOHIDGameControllerEventData,joystick.y), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,joystick.y), offsetof(base::IOHIDGameControllerEventData,joystick.y));
XCTAssert (offsetof(IOHIDGameControllerEventData,joystick.z) == offsetof(base::IOHIDGameControllerEventData,joystick.z), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,joystick.z), offsetof(base::IOHIDGameControllerEventData,joystick.z));
XCTAssert (offsetof(IOHIDGameControllerEventData,joystick.rz) == offsetof(base::IOHIDGameControllerEventData,joystick.rz), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,joystick.rz), offsetof(base::IOHIDGameControllerEventData,joystick.rz));
XCTAssert (offsetof(IOHIDGameControllerEventData,shoulder.l1) == offsetof(base::IOHIDGameControllerEventData,shoulder.l1), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,shoulder.l1), offsetof(base::IOHIDGameControllerEventData,shoulder.l1));
XCTAssert (offsetof(IOHIDGameControllerEventData,shoulder.l2) == offsetof(base::IOHIDGameControllerEventData,shoulder.l2), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,shoulder.l2), offsetof(base::IOHIDGameControllerEventData,shoulder.l2));
XCTAssert (offsetof(IOHIDGameControllerEventData,shoulder.r1) == offsetof(base::IOHIDGameControllerEventData,shoulder.r1), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,shoulder.r1), offsetof(base::IOHIDGameControllerEventData,shoulder.r1));
XCTAssert (offsetof(IOHIDGameControllerEventData,shoulder.r2) == offsetof(base::IOHIDGameControllerEventData,shoulder.r2), "Offset:%lu expected:%lu", offsetof(IOHIDGameControllerEventData,shoulder.r2), offsetof(base::IOHIDGameControllerEventData,shoulder.r2));
XCTAssert (offsetof(IOHIDHumidityEventData,rh) == offsetof(base::IOHIDHumidityEventData,rh), "Offset:%lu expected:%lu", offsetof(IOHIDHumidityEventData,rh), offsetof(base::IOHIDHumidityEventData,rh));
XCTAssert (offsetof(IOHIDHumidityEventData,sequence) == offsetof(base::IOHIDHumidityEventData,sequence), "Offset:%lu expected:%lu", offsetof(IOHIDHumidityEventData,sequence), offsetof(base::IOHIDHumidityEventData,sequence));
XCTAssert (offsetof(IOHIDBrightnessEventData,currentBrightness) == offsetof(base::IOHIDBrightnessEventData,currentBrightness), "Offset:%lu expected:%lu", offsetof(IOHIDBrightnessEventData,currentBrightness), offsetof(base::IOHIDBrightnessEventData,currentBrightness));
XCTAssert (offsetof(IOHIDBrightnessEventData,targetBrightness) == offsetof(base::IOHIDBrightnessEventData,targetBrightness), "Offset:%lu expected:%lu", offsetof(IOHIDBrightnessEventData,targetBrightness), offsetof(base::IOHIDBrightnessEventData,targetBrightness));
XCTAssert (offsetof(IOHIDBrightnessEventData,transitionTime) == offsetof(base::IOHIDBrightnessEventData,transitionTime), "Offset:%lu expected:%lu", offsetof(IOHIDBrightnessEventData,transitionTime), offsetof(base::IOHIDBrightnessEventData,transitionTime));


#endif /* TestHIDEventCompatibility_h */