anchor.diff:          testSyntheticEventDefaults(e);
         });
   
  -      test('merges values as expected', () {
  -        final element = InputElement()
  -          ..name = 'test'
  -          ..value = 'test value';
  -        final baseEvent = createSyntheticFormEvent(
  -          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',
  -        );
  -        testSyntheticEventBaseForMergeTests(baseEvent);
  -
  -        final newElement = DivElement();
  -        final newEvent = createSyntheticFormEvent(
  -          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',
  -        );
  -
  -        testSyntheticEventBaseAfterMerge(newEvent);
  +      group('merges values as expected', () {
  +        test('', () {
  +          final element = InputElement()
  +            ..name = 'test'
  +            ..value = 'test value';
  +          final baseEvent = createSyntheticFormEvent(
  +            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',
  +          );
  +          testSyntheticEventBaseForMergeTests(baseEvent);
  +
  +          final newElement = DivElement();
  +          final newEvent = createSyntheticFormEvent(
  +            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',
  +          );
  +
  +          testSyntheticEventBaseAfterMerge(newEvent);
  +        });
  +
  +        test('when the named parameters are null', () {
  +          final element = InputElement()
  +            ..name = 'test'
  +            ..value = 'test value';
  +          final baseEvent = createSyntheticFormEvent(
  +            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',
  +          );
  +          testSyntheticEventBaseForMergeTests(baseEvent);
  +
  +          final newEvent = createSyntheticFormEvent(baseEvent: baseEvent);
  +          testSyntheticEventBaseForMergeTests(newEvent);
  +        });
         });
       });
   
  
positive.code:         expect(e.isPrimary, isNull);
        });
  
        test('merges values as expected', () {
          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);
        });
      });
  
  
negative.code:         expect(e.pseudoElement, isNull);
        });
  
        group('merges values as expected', () {
          test('', () {
            final element = InputElement()
              ..name = 'test'
              ..value = 'test value';
            final baseEvent = createSyntheticTransitionEvent(
              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',
              propertyName: testString + '1',
              elapsedTime: 200,
              pseudoElement: testString + '2',
            );
            testSyntheticEventBaseForMergeTests(baseEvent);
            expect(baseEvent.propertyName, testString + '1');
            expect(baseEvent.elapsedTime, 200);
            expect(baseEvent.pseudoElement, testString + '2');
  
            final newElement = DivElement();
            final newEvent = createSyntheticTransitionEvent(
              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',
              propertyName: updatedTestString + '1',
              elapsedTime: 300,
              pseudoElement: updatedTestString + '2',
            );
  
            testSyntheticEventBaseAfterMerge(newEvent);
            expect(newEvent.propertyName, updatedTestString + '1');
            expect(newEvent.elapsedTime, 300);
            expect(newEvent.pseudoElement, updatedTestString + '2');
          });
  
          test('when the named parameters are null', () {
            final element = InputElement()
              ..name = 'test'
              ..value = 'test value';
            final baseEvent = createSyntheticTransitionEvent(
              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',
              propertyName: testString + '1',
              elapsedTime: 200,
              pseudoElement: testString + '2',
            );
            testSyntheticEventBaseForMergeTests(baseEvent);
            expect(baseEvent.propertyName, testString + '1');
            expect(baseEvent.elapsedTime, 200);
            expect(baseEvent.pseudoElement, testString + '2');
  
            final newEvent = createSyntheticTransitionEvent(baseEvent: baseEvent);
            testSyntheticEventBaseForMergeTests(newEvent);
            expect(newEvent.propertyName, testString + '1');
            expect(newEvent.elapsedTime, 200);
            expect(newEvent.pseudoElement, testString + '2');
          });
        });
      });
  
  