anchor.diff:          testSyntheticEventDefaults(e);
         });
   
  -      test('merges values as expected', () {
  -        final element = InputElement()
  -          ..name = 'test'
  -          ..value = 'test value';
  -        final baseEvent = createSyntheticFocusEvent(
  -          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 = createSyntheticFocusEvent(
  -          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 = createSyntheticFocusEvent(
  +            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 = createSyntheticFocusEvent(
  +            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 = createSyntheticFocusEvent(
  +            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 = createSyntheticFocusEvent(baseEvent: baseEvent);
  +          testSyntheticEventBaseForMergeTests(newEvent);
  +        });
         });
       });
   
  
positive.code:         expect(e.touches, isNull);
        });
  
        test('merges values as expected', () {
          final element = InputElement()
            ..name = 'test'
            ..value = 'test value';
          final baseEvent = createSyntheticTouchEvent(
            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,
            changedTouches: testString + '1',
            ctrlKey: true,
            metaKey: true,
            shiftKey: true,
            targetTouches: testString + '2',
            touches: testString + '3',
          );
          testSyntheticEventBaseForMergeTests(baseEvent);
          expect(baseEvent.altKey, true);
          expect(baseEvent.changedTouches, testString + '1');
          expect(baseEvent.ctrlKey, true);
          expect(baseEvent.metaKey, true);
          expect(baseEvent.shiftKey, true);
          expect(baseEvent.targetTouches, testString + '2');
          expect(baseEvent.touches, testString + '3');
  
          final newElement = DivElement();
          final newEvent = createSyntheticTouchEvent(
            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,
            changedTouches: updatedTestString + '1',
            ctrlKey: false,
            metaKey: false,
            shiftKey: false,
            targetTouches: updatedTestString + '2',
            touches: updatedTestString + '3',
          );
  
          testSyntheticEventBaseAfterMerge(newEvent);
          expect(newEvent.altKey, isFalse);
          expect(newEvent.changedTouches, updatedTestString + '1');
          expect(newEvent.ctrlKey, isFalse);
          expect(newEvent.metaKey, isFalse);
          expect(newEvent.shiftKey, isFalse);
          expect(newEvent.targetTouches, updatedTestString + '2');
          expect(newEvent.touches, updatedTestString + '3');
        });
      });
  
  
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');
          });
        });
      });
  
  