public interface DestinationType {
    Map<String, String> getAttributes();

    void setAttributes(Map<String, String> attributes);
} 

public class SourceType  implements DestinationType{
    Map<String, String> attributes;

    public Map<String, String> getAttributes() {
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }
} 

@Mapper(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_DEFAULT)
public interface MyMapper{

    MyMapper INSTANCE = Mappers.getMapper( MyMapper.class );

    void update(@MappingTarget DestinationType destination, SourceType source);
}

  public void shouldGenerateUpdateMethod() {
      DestinationType target = new SourceType();
      SourceType source = new SourceType();
      MyMapper.INSTANCE.update(target , source);
      assertThat(target.getAttributes()).isNotEqualTo(null);
  }

    public void update(DestinationType destination, SourceType source) {
        if ( source == null ) {
            return;
        }

        if ( destination.getAttributes() != null ) {
            Map<String, String> map = source.getAttributes();
            if ( map != null ) {
                destination.getAttributes().clear();
                destination.getAttributes().putAll( map );
            }
            else {
                destination.setAttributes( new LinkedHashMap<String, String>() );
            }
        }
        else {
            Map<String, String> map = source.getAttributes();
            if ( map != null ) {
                destination.setAttributes( new LinkedHashMap<String, String>( map ) );
            }
            // Why is there no esle branch here?
            // else {
            //   destination.setAttributes( new LinkedHashMap<String, String>() ) 
            //};
        }
    }