anchor.diff:          expect(e.shiftKey, isFalse);
         });
   
  -      test('merges values as expected', () {
  -        final element = InputElement()
  -          ..name = 'test'
  -          ..value = 'test value';
  -        final baseEvent = createSyntheticMouseEvent(
  -          bubbles: true,
  -          cancelable: false,
  -          currentTarget: element,
  -          defaultPrevented: true,
  -          preventDefault: null,
  -          stopPropagation: null,
  -          eventPhase: 0,
  -          isTrusted: true,
  -          nativeEvent: 'string',
  -          target: element,
  -          timeStamp: 100,
  -          type: 'non-default',
  -          altKey: true,
  -          button: 1,
  -          buttons: 2,
  -          clientX: 100,
  -          clientY: 200,
  -          ctrlKey: true,
  -          dataTransfer: SyntheticDataTransfer(testString, null, null, null),
  -          metaKey: true,
  -          pageX: 300,
  -          pageY: 400,
  -          relatedTarget: testString,
  -          screenX: 500,
  -          screenY: 600,
  -          shiftKey: true,
  -        );
  -        testSyntheticEventBaseForMergeTests(baseEvent);
  -        expect(baseEvent.altKey, isTrue);
  -        expect(baseEvent.button, 1);
  -        expect(baseEvent.buttons, 2);
  -        expect(baseEvent.clientX, 100);
  -        expect(baseEvent.clientY, 200);
  -        expect(baseEvent.ctrlKey, isTrue);
  -        expect(baseEvent.dataTransfer.dropEffect, testString);
  -        expect(baseEvent.metaKey, isTrue);
  -        expect(baseEvent.pageX, 300);
  -        expect(baseEvent.pageY, 400);
  -        expect(baseEvent.relatedTarget, testString);
  -        expect(baseEvent.screenX, 500);
  -        expect(baseEvent.screenY, 600);
  -        expect(baseEvent.shiftKey, isTrue);
  -
  -        final newElement = DivElement();
  -        final newEvent = createSyntheticMouseEvent(
  -          baseEvent: baseEvent,
  -          bubbles: false,
  -          cancelable: true,
  -          currentTarget: newElement,
  -          defaultPrevented: false,
  -          preventDefault: () => mergeTestCounter++,
  -          stopPropagation: () => mergeTestCounter++,
  -          eventPhase: 2,
  -          isTrusted: false,
  -          nativeEvent: 'updated string',
  -          target: newElement,
  -          timeStamp: 200,
  -          type: 'updated non-default',
  -          altKey: false,
  -          button: 2,
  -          buttons: 3,
  -          clientX: 200,
  -          clientY: 300,
  -          ctrlKey: false,
  -          dataTransfer: SyntheticDataTransfer(updatedTestString, null, null, null),
  -          metaKey: false,
  -          pageX: 400,
  -          pageY: 500,
  -          relatedTarget: updatedTestString,
  -          screenX: 600,
  -          screenY: 700,
  -          shiftKey: false,
  -        );
  -
  -        testSyntheticEventBaseAfterMerge(newEvent);
  -        expect(newEvent.altKey, isFalse);
  -        expect(newEvent.button, 2);
  -        expect(newEvent.buttons, 3);
  -        expect(newEvent.clientX, 200);
  -        expect(newEvent.clientY, 300);
  -        expect(newEvent.ctrlKey, isFalse);
  -        expect(newEvent.dataTransfer.dropEffect, updatedTestString);
  -        expect(newEvent.metaKey, isFalse);
  -        expect(newEvent.pageX, 400);
  -        expect(newEvent.pageY, 500);
  -        expect(newEvent.relatedTarget, updatedTestString);
  -        expect(newEvent.screenX, 600);
  -        expect(newEvent.screenY, 700);
  -        expect(newEvent.shiftKey, isFalse);
  +      group('merges values as expected', () {
  +        test('', () {
  +          final element = InputElement()
  +            ..name = 'test'
  +            ..value = 'test value';
  +          final baseEvent = createSyntheticMouseEvent(
  +            bubbles: true,
  +            cancelable: false,
  +            currentTarget: element,
  +            defaultPrevented: true,
  +            preventDefault: null,
  +            stopPropagation: null,
  +            eventPhase: 0,
  +            isTrusted: true,
  +            nativeEvent: 'string',
  +            target: element,
  +            timeStamp: 100,
  +            type: 'non-default',
  +            altKey: true,
  +            button: 1,
  +            buttons: 2,
  +            clientX: 100,
  +            clientY: 200,
  +            ctrlKey: true,
  +            dataTransfer: SyntheticDataTransfer(testString, null, null, null),
  +            metaKey: true,
  +            pageX: 300,
  +            pageY: 400,
  +            relatedTarget: testString,
  +            screenX: 500,
  +            screenY: 600,
  +            shiftKey: true,
  +          );
  +          testSyntheticEventBaseForMergeTests(baseEvent);
  +          expect(baseEvent.altKey, isTrue);
  +          expect(baseEvent.button, 1);
  +          expect(baseEvent.buttons, 2);
  +          expect(baseEvent.clientX, 100);
  +          expect(baseEvent.clientY, 200);
  +          expect(baseEvent.ctrlKey, isTrue);
  +          expect(baseEvent.dataTransfer.dropEffect, testString);
  +          expect(baseEvent.metaKey, isTrue);
  +          expect(baseEvent.pageX, 300);
  +          expect(baseEvent.pageY, 400);
  +          expect(baseEvent.relatedTarget, testString);
  +          expect(baseEvent.screenX, 500);
  +          expect(baseEvent.screenY, 600);
  +          expect(baseEvent.shiftKey, isTrue);
  +
  +          final newElement = DivElement();
  +          final newEvent = createSyntheticMouseEvent(
  +            baseEvent: baseEvent,
  +            bubbles: false,
  +            cancelable: true,
  +            currentTarget: newElement,
  +            defaultPrevented: false,
  +            preventDefault: () => mergeTestCounter++,
  +            stopPropagation: () => mergeTestCounter++,
  +            eventPhase: 2,
  +            isTrusted: false,
  +            nativeEvent: 'updated string',
  +            target: newElement,
  +            timeStamp: 200,
  +            type: 'updated non-default',
  +            altKey: false,
  +            button: 2,
  +            buttons: 3,
  +            clientX: 200,
  +            clientY: 300,
  +            ctrlKey: false,
  +            dataTransfer: SyntheticDataTransfer(updatedTestString, null, null, null),
  +            metaKey: false,
  +            pageX: 400,
  +            pageY: 500,
  +            relatedTarget: updatedTestString,
  +            screenX: 600,
  +            screenY: 700,
  +            shiftKey: false,
  +          );
  +
  +          testSyntheticEventBaseAfterMerge(newEvent);
  +          expect(newEvent.altKey, isFalse);
  +          expect(newEvent.button, 2);
  +          expect(newEvent.buttons, 3);
  +          expect(newEvent.clientX, 200);
  +          expect(newEvent.clientY, 300);
  +          expect(newEvent.ctrlKey, isFalse);
  +          expect(newEvent.dataTransfer.dropEffect, updatedTestString);
  +          expect(newEvent.metaKey, isFalse);
  +          expect(newEvent.pageX, 400);
  +          expect(newEvent.pageY, 500);
  +          expect(newEvent.relatedTarget, updatedTestString);
  +          expect(newEvent.screenX, 600);
  +          expect(newEvent.screenY, 700);
  +          expect(newEvent.shiftKey, isFalse);
  +        });
  +
  +        test('when the named parameters are null', () {
  +          final element = InputElement()
  +            ..name = 'test'
  +            ..value = 'test value';
  +          final baseEvent = createSyntheticMouseEvent(
  +            bubbles: true,
  +            cancelable: false,
  +            currentTarget: element,
  +            defaultPrevented: true,
  +            preventDefault: null,
  +            stopPropagation: null,
  +            eventPhase: 0,
  +            isTrusted: true,
  +            nativeEvent: 'string',
  +            target: element,
  +            timeStamp: 100,
  +            type: 'non-default',
  +            altKey: true,
  +            button: 1,
  +            buttons: 2,
  +            clientX: 100,
  +            clientY: 200,
  +            ctrlKey: true,
  +            dataTransfer: SyntheticDataTransfer(testString, null, null, null),
  +            metaKey: true,
  +            pageX: 300,
  +            pageY: 400,
  +            relatedTarget: testString,
  +            screenX: 500,
  +            screenY: 600,
  +            shiftKey: true,
  +          );
  +          testSyntheticEventBaseForMergeTests(baseEvent);
  +          expect(baseEvent.altKey, isTrue);
  +          expect(baseEvent.button, 1);
  +          expect(baseEvent.buttons, 2);
  +          expect(baseEvent.clientX, 100);
  +          expect(baseEvent.clientY, 200);
  +          expect(baseEvent.ctrlKey, isTrue);
  +          expect(baseEvent.dataTransfer.dropEffect, testString);
  +          expect(baseEvent.metaKey, isTrue);
  +          expect(baseEvent.pageX, 300);
  +          expect(baseEvent.pageY, 400);
  +          expect(baseEvent.relatedTarget, testString);
  +          expect(baseEvent.screenX, 500);
  +          expect(baseEvent.screenY, 600);
  +          expect(baseEvent.shiftKey, isTrue);
  +
  +          final newEvent = createSyntheticMouseEvent(baseEvent: baseEvent);
  +          testSyntheticEventBaseForMergeTests(newEvent);
  +          expect(newEvent.altKey, isTrue);
  +          expect(newEvent.button, 1);
  +          expect(newEvent.buttons, 2);
  +          expect(newEvent.clientX, 100);
  +          expect(newEvent.clientY, 200);
  +          expect(newEvent.ctrlKey, isTrue);
  +          expect(newEvent.dataTransfer.dropEffect, testString);
  +          expect(newEvent.metaKey, isTrue);
  +          expect(newEvent.pageX, 300);
  +          expect(newEvent.pageY, 400);
  +          expect(newEvent.relatedTarget, testString);
  +          expect(newEvent.screenX, 500);
  +          expect(newEvent.screenY, 600);
  +          expect(newEvent.shiftKey, isTrue);
  +        });
         });
       });
   
  
positive.code:         expect(e.pseudoElement, isNull);
        });
  
        test('merges values as expected', () {
          final element = InputElement()
            ..name = 'test'
            ..value = 'test value';
          final baseEvent = createSyntheticAnimationEvent(
            bubbles: true,
            cancelable: false,
            currentTarget: element,
            defaultPrevented: true,
            preventDefault: null,
            stopPropagation: null,
            eventPhase: 0,
            isTrusted: true,
            nativeEvent: 'string',
            target: element,
            timeStamp: 100,
            type: 'non-default',
            animationName: testString + '1',
            elapsedTime: 200,
            pseudoElement: testString + '2',
          );
          testSyntheticEventBaseForMergeTests(baseEvent);
          expect(baseEvent.animationName, testString + '1');
          expect(baseEvent.elapsedTime, 200);
          expect(baseEvent.pseudoElement, testString + '2');
  
          final newElement = DivElement();
          final newEvent = createSyntheticAnimationEvent(
            baseEvent: baseEvent,
            bubbles: false,
            cancelable: true,
            currentTarget: newElement,
            defaultPrevented: false,
            preventDefault: () => mergeTestCounter++,
            stopPropagation: () => mergeTestCounter++,
            eventPhase: 2,
            isTrusted: false,
            nativeEvent: 'updated string',
            target: newElement,
            timeStamp: 200,
            type: 'updated non-default',
            animationName: updatedTestString + '1',
            elapsedTime: 300,
            pseudoElement: updatedTestString + '2',
          );
  
          testSyntheticEventBaseAfterMerge(newEvent);
          expect(newEvent.animationName, updatedTestString + '1');
          expect(newEvent.elapsedTime, 300);
          expect(newEvent.pseudoElement, updatedTestString + '2');
        });
      });
  
  
negative.code:         expect(e.isPrimary, isNull);
        });
  
        group('merges values as expected', () {
          test('', () {
            final element = InputElement()
              ..name = 'test'
              ..value = 'test value';
            final baseEvent = createSyntheticPointerEvent(
              bubbles: true,
              cancelable: false,
              currentTarget: element,
              defaultPrevented: true,
              preventDefault: null,
              stopPropagation: null,
              eventPhase: 0,
              isTrusted: true,
              nativeEvent: 'string',
              target: element,
              timeStamp: 100,
              type: 'non-default',
              pointerId: 1,
              width: 2,
              height: 3,
              pressure: 4,
              tangentialPressure: 5,
              tiltX: 6,
              tiltY: 7,
              twist: 8,
              pointerType: testString,
              isPrimary: false,
            );
            testSyntheticEventBaseForMergeTests(baseEvent);
            expect(baseEvent.pointerId, 1);
            expect(baseEvent.width, 2);
            expect(baseEvent.height, 3);
            expect(baseEvent.pressure, 4);
            expect(baseEvent.tangentialPressure, 5);
            expect(baseEvent.tiltX, 6);
            expect(baseEvent.tiltY, 7);
            expect(baseEvent.twist, 8);
            expect(baseEvent.pointerType, testString);
            expect(baseEvent.isPrimary, isFalse);
  
            final newElement = DivElement();
            final newEvent = createSyntheticPointerEvent(
              baseEvent: baseEvent,
              bubbles: false,
              cancelable: true,
              currentTarget: newElement,
              defaultPrevented: false,
              preventDefault: () => mergeTestCounter++,
              stopPropagation: () => mergeTestCounter++,
              eventPhase: 2,
              isTrusted: false,
              nativeEvent: 'updated string',
              target: newElement,
              timeStamp: 200,
              type: 'updated non-default',
              pointerId: 2,
              width: 3,
              height: 4,
              pressure: 5,
              tangentialPressure: 6,
              tiltX: 7,
              tiltY: 8,
              twist: 9,
              pointerType: updatedTestString,
              isPrimary: true,
            );
  
            testSyntheticEventBaseAfterMerge(newEvent);
            expect(newEvent.pointerId, 2);
            expect(newEvent.width, 3);
            expect(newEvent.height, 4);
            expect(newEvent.pressure, 5);
            expect(newEvent.tangentialPressure, 6);
            expect(newEvent.tiltX, 7);
            expect(newEvent.tiltY, 8);
            expect(newEvent.twist, 9);
            expect(newEvent.pointerType, updatedTestString);
            expect(newEvent.isPrimary, isTrue);
          });
  
          test('when the named parameters are null', () {
            final element = InputElement()
              ..name = 'test'
              ..value = 'test value';
            final baseEvent = createSyntheticPointerEvent(
              bubbles: true,
              cancelable: false,
              currentTarget: element,
              defaultPrevented: true,
              preventDefault: null,
              stopPropagation: null,
              eventPhase: 0,
              isTrusted: true,
              nativeEvent: 'string',
              target: element,
              timeStamp: 100,
              type: 'non-default',
              pointerId: 1,
              width: 2,
              height: 3,
              pressure: 4,
              tangentialPressure: 5,
              tiltX: 6,
              tiltY: 7,
              twist: 8,
              pointerType: testString,
              isPrimary: false,
            );
            testSyntheticEventBaseForMergeTests(baseEvent);
            expect(baseEvent.pointerId, 1);
            expect(baseEvent.width, 2);
            expect(baseEvent.height, 3);
            expect(baseEvent.pressure, 4);
            expect(baseEvent.tangentialPressure, 5);
            expect(baseEvent.tiltX, 6);
            expect(baseEvent.tiltY, 7);
            expect(baseEvent.twist, 8);
            expect(baseEvent.pointerType, testString);
            expect(baseEvent.isPrimary, isFalse);
  
            final newEvent = createSyntheticPointerEvent(baseEvent: baseEvent);
            testSyntheticEventBaseForMergeTests(newEvent);
            expect(newEvent.pointerId, 1);
            expect(newEvent.width, 2);
            expect(newEvent.height, 3);
            expect(newEvent.pressure, 4);
            expect(newEvent.tangentialPressure, 5);
            expect(newEvent.tiltX, 6);
            expect(newEvent.tiltY, 7);
            expect(newEvent.twist, 8);
            expect(newEvent.pointerType, testString);
            expect(newEvent.isPrimary, isFalse);
          });
        });
      });
  
  