diff --git a/src/echarts.js b/src/echarts.js
index c2e4c1b258798b4836bfba6c3c2abc68178cff50..170857d26ff81e1359a2071217936e45394a6163 100644
--- a/src/echarts.js
+++ b/src/echarts.js
@@ -686,6 +686,7 @@ define(function (require) {
                 model = componentType;
             }
 
+            // Consider: id same and type changed.
             var viewId = model.id + '_' + model.type;
             var view = viewMap[viewId];
             if (!view) {
diff --git a/src/model/Global.js b/src/model/Global.js
index dcf203a0cb1102dabfd5406189cc68fba1035957..cc8910f87d12b812319051aec588ebb6906006dc 100644
--- a/src/model/Global.js
+++ b/src/model/Global.js
@@ -131,79 +131,67 @@ define(function (require) {
             function visitComponent(mainType, dependencies) {
                 var newCptOptionList = newOption[mainType];
 
-                newCptOptionList
-                    ? handleNew.call(this, mainType, newCptOptionList, dependencies)
-                    : handleNoNew.call(this, mainType);
-
-                // Backup series for filtering.
-                if (mainType === 'series') {
-                    this._seriesIndices = createSeriesIndices(componentsMap.series);
-                }
-            }
-
-            function handleNoNew(mainType) {
-                // Possible when using removeEdgeAndAdd in topologicalTravel
-                // and ComponentModel.getAllClassMainTypes
-                each(componentsMap[mainType], function (cpt) {
-                    cpt.mergeOption({}, this);
-                }, this);
-            }
-
-            function handleNew(mainType, newCptOptionList, dependencies) {
-                // Normalize
                 if (!(zrUtil.isArray(newCptOptionList))) {
-                    newCptOptionList = [newCptOptionList];
-                }
-                if (!componentsMap[mainType]) {
-                    componentsMap[mainType] = [];
+                    newCptOptionList = newCptOptionList ? [newCptOptionList] : [];
                 }
 
-                var existComponents = mappingToExists(
-                    componentsMap[mainType], newCptOptionList
-                );
+                var mapResult = mappingToExists(componentsMap[mainType], newCptOptionList);
 
-                var keyInfoList = makeKeyInfo(
-                    mainType, newCptOptionList, existComponents
-                );
+                makeKeyInfo(mainType, mapResult);
 
                 var dependentModels = getComponentsByTypes(
                     componentsMap, dependencies
                 );
 
                 option[mainType] = [];
+                componentsMap[mainType] = [];
 
-                each(newCptOptionList, function (newCptOption, index) {
-                    if (!isObject(newCptOption)) {
-                        return;
-                    }
-
-                    var componentModel = existComponents[index];
+                each(mapResult, function (resultItem, index) {
+                    var componentModel = resultItem.exist;
+                    var newCptOption = resultItem.option;
 
-                    var ComponentModelClass = ComponentModel.getClass(
-                        mainType, keyInfoList[index].subType, true
+                    zrUtil.assert(
+                        isObject(newCptOption) || componentModel,
+                        'Empty component definition'
                     );
 
-                    if (componentModel && componentModel instanceof ComponentModelClass) {
-                        componentModel.mergeOption(newCptOption, this);
+                    // Consider where is no new option and should be merged using {},
+                    // see removeEdgeAndAdd in topologicalTravel and
+                    // ComponentModel.getAllClassMainTypes.
+                    if (!newCptOption) {
+                        componentModel.mergeOption({}, this);
                     }
                     else {
-                        // PENDING Global as parent ?
-                        componentModel = new ComponentModelClass(
-                            newCptOption, this, this,
-                            zrUtil.extend(
-                                {
-                                    dependentModels: dependentModels,
-                                    componentIndex: index
-                                },
-                                keyInfoList[index]
-                            )
+                        var ComponentModelClass = ComponentModel.getClass(
+                            mainType, resultItem.keyInfo.subType, true
                         );
-                        componentsMap[mainType][index] = componentModel;
+
+                        if (componentModel && componentModel instanceof ComponentModelClass) {
+                            componentModel.mergeOption(newCptOption, this);
+                        }
+                        else {
+                            // PENDING Global as parent ?
+                            componentModel = new ComponentModelClass(
+                                newCptOption, this, this,
+                                zrUtil.extend(
+                                    {
+                                        dependentModels: dependentModels,
+                                        componentIndex: index
+                                    },
+                                    resultItem.keyInfo
+                                )
+                            );
+                        }
                     }
 
-                    // Keep option
+                    componentsMap[mainType][index] = componentModel;
                     option[mainType][index] = componentModel.option;
                 }, this);
+
+                // Backup series for filtering.
+                if (mainType === 'series') {
+                    this._seriesIndices = createSeriesIndices(componentsMap.series);
+                }
             }
         },
 
@@ -595,46 +583,69 @@ define(function (require) {
     /**
      * @inner
      */
-    function mappingToExists(existComponents, newComponentOptionList) {
-        existComponents = (existComponents || []).slice();
-        var result = [];
+    function mappingToExists(existCpts, newCptOptions) {
+        // Mapping by the order by original option (but not order of
+        // new option) in merge mode. Because we should ensure
+        // some specified index (like xAxisIndex) is consistent with
+        // original option, which is easy to understand, espatially in
+        // media query. And in most case, merge option is used to
+        // update partial option but not be expected to change order.
+        newCptOptions = (newCptOptions || []).slice();
+
+        var result = map(existCpts || [], function (cpt, index) {
+            return {exist: cpt};
+        });
 
-        // Mapping by id if specified.
-        each(newComponentOptionList, function (componentOption, index) {
-            if (!isObject(componentOption) || !componentOption.id) {
+        // Mapping by id or name if specified.
+        each(newCptOptions, function (cptOption, index) {
+            if (!isObject(cptOption)) {
                 return;
             }
-            for (var i = 0, len = existComponents.length; i < len; i++) {
-                if (existComponents[i].id === componentOption.id) {
-                    result[index] = existComponents.splice(i, 1)[0];
-                    return;
+            for (var i = 0; i < result.length; i++) {
+                var exist = result[i].exist;
+                if (!result[i].option // Consider name: two map to one.
+                    && (
+                        // id has highest priority.
+                        (cptOption.id != null && exist.id === cptOption.id + '')
+                        || (cptOption.name != null
+                            && !isIdInner(cptOption)
+                            && !isIdInner(exist)
+                            && exist.name === cptOption.name + ''
+                        )
+                    )
+                ) {
+                    result[i].option = cptOption;
+                    newCptOptions[index] = null;
+                    break;
                 }
             }
         });
 
-        // Mapping by name if specified.
-        each(newComponentOptionList, function (componentOption, index) {
-            if (!isObject(componentOption)
-                || !componentOption.name
-                || hasInnerId(componentOption)
-            ) {
+        // Otherwise mapping by index.
+        each(newCptOptions, function (cptOption, index) {
+            if (!isObject(cptOption)) {
                 return;
             }
-            for (var i = 0, len = existComponents.length; i < len; i++) {
-                if (existComponents[i].name === componentOption.name) {
-                    result[index] = existComponents.splice(i, 1)[0];
-                    return;
+
+            var i = 0;
+            for (; i < result.length; i++) {
+                var exist = result[i].exist;
+                if (!result[i].option
+                    && !isIdInner(exist)
+                    // Caution:
+                    // Do not overwrite id. But name can be overwritten,
+                    // because axis use name as 'show label text'.
+                    // 'exist' always has id and name and we dont
+                    // need to check it.
+                    && cptOption.id == null
+                ) {
+                    result[i].option = cptOption;
+                    break;
                 }
             }
-        });
 
-        // Otherwise mapping by index.
-        each(newComponentOptionList, function (componentOption, index) {
-            if (!result[index]
-                && existComponents[index]
-                && !hasInnerId(componentOption)
-            ) {
-                result[index] = existComponents[index];
+            if (i >= result.length) {
+                result.push({option: cptOption});
             }
         });
 
@@ -644,95 +655,81 @@ define(function (require) {
     /**
      * @inner
      */
-    function makeKeyInfo(mainType, newCptOptionList, existComponents) {
+    function makeKeyInfo(mainType, mapResult) {
         // We use this id to hash component models and view instances
         // in echarts. id can be specified by user, or auto generated.
 
-        // The id generation rule ensures when setOption are called in
-        // no-merge mode, new model is able to replace old model, and
-        // new view instance are able to mapped to old instance.
-        // So we generate id by name and type.
+        // The id generation rule ensures new view instance are able
+        // to mapped to old instance when setOption are called in
+        // no-merge mode. So we generate model id by name and plus
+        // type in view id.
 
         // name can be duplicated among components, which is convenient
         // to specify multi components (like series) by one name.
 
-        // raw option should not be modified. for example, xxx.name might
-        // be rendered, so default name ('') should not be replaced by
-        // generated name. So we use keyInfoList wrap key info.
-        var keyInfoList = [];
+        // Ensure that each id is distinct.
+        var idMap = {};
 
-        // We use a prefix when generating name or id to prevent
-        // user using the generated name or id directly.
-        var prefix = '\0';
+        each(mapResult, function (item, index) {
+            var existCpt = item.exist;
+            var opt = item.option;
 
-        // Ensure that each id is distinct.
-        var idSet = {};
+            zrUtil.assert(
+                !opt || opt.id == null || !idMap[opt.id],
+                'id duplicates: ' + (opt && opt.id)
+            );
 
-        // key: name, value: count by single name.
-        var nameCount = {};
+            existCpt && (idMap[existCpt.id] = item);
+            opt && (idMap[opt.id] = item);
 
-        // Complete subType
-        each(newCptOptionList, function (opt, index) {
-            if (!isObject(opt)) {
-                return;
+            // Complete subType
+            if (isObject(opt)) {
+                var subType = determineSubType(mainType, opt, existCpt);
+                item.keyInfo = {mainType: mainType, subType: subType};
             }
-            var existCpt = existComponents[index];
-            var subType = determineSubType(mainType, opt, existCpt);
-            var item = {mainType: mainType, subType: subType};
-            keyInfoList[index] = item;
         });
 
-        function eachOpt(cb) {
-            each(newCptOptionList, function (opt, index) {
-                if (!isObject(opt)) {
-                    return;
-                }
-                var existCpt = existComponents[index];
-                var item = keyInfoList[index];
-                var fullType = mainType + '.' + item.subType;
-                cb(item, opt, existCpt, fullType);
-            });
-        }
+        // Make name and id.
+        each(mapResult, function (item, index) {
+            var existCpt = item.exist;
+            var opt = item.option;
+            var keyInfo = item.keyInfo;
+
+            if (!isObject(opt)) {
+                return;
+            }
 
-        // Make name
-        eachOpt(function (item, opt, existCpt, fullType) {
-            item.name = existCpt
+            // name can be overwitten. Consider case: axis.name = '20km'.
+            // But id generated by name will not be changed, which affect
+            // only in that case: setOption with 'not merge mode' and view
+            // instance will be recreated, which can be accepted.
+            keyInfo.name = opt.name != null
+                ? opt.name + ''
+                : existCpt
                 ? existCpt.name
-                : opt.name != null
-                ? opt.name
-                : prefix + '-';
-            // init nameCount
-            nameCount[item.name] = 0;
-        });
+                : '\0-';
 
-        // Make id
-        eachOpt(function (item, opt, existCpt, fullType) {
-            var itemName = item.name;
-
-            item.id = existCpt
-                ? existCpt.id
-                : opt.id != null
-                ? opt.id
-                // (1) Using delimiter to escapse dulipcation.
-                // (2) Using type tu ensure that view with different
-                //     type will not be mapped.
-                // (3) Consider this situatoin:
-                //      optionA: [{name: 'a'}, {name: 'a'}, {..}]
-                //      optionB [{..}, {name: 'a'}, {name: 'a'}]
-                //     Using nameCount to ensure that series with
-                //     the same name between optionA and optionB
-                //     can be mapped.
-                : prefix + [fullType, itemName, nameCount[itemName]++].join('|');
-
-            if (idSet[item.id]) {
-                // FIXME
-                // how to throw
-                throw new Error('id duplicates: ' + item.id);
+            if (existCpt) {
+                keyInfo.id = existCpt.id;
+            }
+            else if (opt.id != null) {
+                keyInfo.id = opt.id + '';
+            }
+            else {
+                // Consider this situatoin:
+                //  optionA: [{name: 'a'}, {name: 'a'}, {..}]
+                //  optionB [{..}, {name: 'a'}, {name: 'a'}]
+                // Series with the same name between optionA and optionB
+                // should be mapped.
+                var idNum = 0;
+                do {
+                    keyInfo.id = '\0' + keyInfo.name + '\0' + idNum++;
+                }
+                while (idMap[keyInfo.id]);
             }
-            idSet[item.id] = 1;
-        });
 
-        return keyInfoList;
+            idMap[keyInfo.id] = item;
+        });
     }
 
     /**
@@ -775,11 +772,9 @@ define(function (require) {
     /**
      * @inner
      */
-    function hasInnerId(componentOption) {
-        return componentOption.id
-            // FIXME
-            // Where to put this constant.
-            && (componentOption.id + '').indexOf('\0_ec_\0') === 0;
+    function isIdInner(cptOption) {
+        // FIXME: Where to put this constant.
+        return cptOption && cptOption.id && (cptOption.id + '').indexOf('\0_ec_\0') === 0;
     }
 
     /**
diff --git a/src/util/component.js b/src/util/component.js
index 26e6662fa18f91c39c48ecdc57b043398a8c6824..f6ab02ad52f1b37c2a5fdabca52c1ddbde8b702b 100644
--- a/src/util/component.js
+++ b/src/util/component.js
@@ -106,7 +106,7 @@ define(function(require) {
                 }
             }
 
-            // Consider this case: legend depends series, we call
+            // Consider this case: legend depends on series, and we call
             // chart.setOption({series: [...]}), where only series is in option.
             // If we do not have 'removeEdgeAndAdd', legendModel.mergeOption will
             // not be called, but only sereis.mergeOption is called. Thus legend
diff --git a/src/util/layout.js b/src/util/layout.js
index 64364cb89b8b58bf4d62105fcbbaeff6ad13dcfe..f2dd4fdc2c83b0866315f1e52ce115c8fa7e073d 100644
--- a/src/util/layout.js
+++ b/src/util/layout.js
@@ -289,11 +289,11 @@ define(function(require) {
      *
      * @param {Object} targetOption
      * @param {Object} newOption
-     * @param {Object} [opt]
+     * @param {Object|string} [opt]
      * @param {boolean} [opt.ignoreSize=false] Some component must has width and height.
      */
     layout.mergeLayoutParam = function (targetOption, newOption, opt) {
-        opt = opt || {};
+        !zrUtil.isObject(opt) && (opt = {});
         var hNames = ['width', 'left', 'right']; // Order by priority.
         var vNames = ['height', 'top', 'bottom']; // Order by priority.
         var hResult = merge(hNames);
diff --git a/test/ut/all.js b/test/ut/all.js
index e860b0dcf134acce7d9cc32841fbbdc89383b3ed..18c65423427e30d1bf8680faa69429b2d758d4b7 100755
--- a/test/ut/all.js
+++ b/test/ut/all.js
@@ -4,5 +4,6 @@ document.write('<script src="ut/core/utHelper.js"><\/script>');
 document.write('<script src="ut/spec/util/graphic.js"><\/script>');
 document.write('<script src="ut/spec/util/model.js"><\/script>');
 document.write('<script src="ut/spec/model/Component.js"><\/script>');
+document.write('<script src="ut/spec/model/Global.js"><\/script>');
 
 document.write('<script src="ut/spec/data/List.js"><\/script>');
diff --git a/test/ut/spec/.jshintrc b/test/ut/spec/.jshintrc
new file mode 100644
index 0000000000000000000000000000000000000000..4f891219b6013fadce5a5282f4e709a73f711247
--- /dev/null
+++ b/test/ut/spec/.jshintrc
@@ -0,0 +1,61 @@
+{
+    "bitwise": false,
+    "camelcase": true,
+    "curly": true,
+    "es3": true,
+    "eqeqeq": true,
+    "forin": true,
+    "freeze": true,
+    "immed": true,
+    "latedef": "nofunc",
+    "newcap": true,
+    "noarg": true,
+    "noempty": true,
+    "nonbsp": true,
+    "nonew": true,
+    "plusplus": false,
+    "quotmark": "single",
+    "undef": true,
+    "predef": ["define", "require", "describe", "expect", "it"],
+    "unused": "vars",
+    "strict": false,
+    "maxparams": 20,
+    "maxdepth": 6,
+    "maxlen": 120,
+
+    "asi": false,
+    "boss": true,
+    "debug": false,
+    "eqnull": true,
+    "esnext": false,
+    "evil": false,
+    "expr": true,
+    "funcscope": false,
+    "globalstrict": false,
+    "iterator": false,
+    "lastsemic": false,
+    "laxbreak": true,
+    "laxcomma": false,
+    "loopfunc": false,
+    "multistr": false,
+    "notypeof": false,
+    "proto": false,
+    "scripturl": false,
+    "shadow": true,
+    "sub": true,
+    "supernew": false,
+    "validthis": true,
+
+    "browser": true,
+    "jasmine": true,
+    "couch": false,
+    "devel": true,
+    "dojo": false,
+    "jquery": false,
+    "mootools": false,
+    "node": true,
+    "nonstandard": true,
+    "prototypejs": false,
+    "rhino": false,
+    "wsh": true
+}
diff --git a/test/ut/spec/model/Global.js b/test/ut/spec/model/Global.js
new file mode 100755
index 0000000000000000000000000000000000000000..5c433266b43f5f7f528c318beca0b569171cf399
--- /dev/null
+++ b/test/ut/spec/model/Global.js
@@ -0,0 +1,817 @@
+describe('modelAndOptionMapping', function() {
+
+    var utHelper = window.utHelper;
+    var el;
+    var chart;
+
+    beforeEach(function (done) {
+        window.jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
+
+        if (el) {
+            document.body.removeChild(el);
+        }
+        if (chart) {
+            chart.dispose();
+        }
+
+        el = document.createElement('div');
+        document.body.appendChild(el);
+
+        utHelper.resetPackageLoader(done);
+    });
+
+    function testCase(name, doTest) {
+        it(name, function (done) {
+            window.require(
+                [
+                    'echarts',
+                    'echarts/component/grid',
+                    'echarts/chart/line',
+                    'echarts/chart/pie',
+                    'echarts/chart/bar',
+                    'echarts/component/toolbox',
+                    'echarts/component/dataZoom'
+                ],
+                function (echarts) {
+                    chart = echarts.init(el, null, {renderer: 'canvas'});
+                    doTest(chart, echarts);
+                    done();
+                }
+            );
+        });
+    }
+    function xtestCase() {} // jshint ignore:line
+
+    function getData0(chart, seriesIndex) {
+        return getSeries(chart, seriesIndex).getData().get('y', 0);
+    }
+
+    function getSeries(chart, seriesIndex) {
+        return chart.getModel().getComponent('series', seriesIndex);
+    }
+
+    function getModel(chart, type, index) {
+        return chart.getModel().getComponent(type, index);
+    }
+
+    function countSeries(chart) {
+        return countModel(chart, 'series');
+    }
+
+    function countModel(chart, type) {
+        // FIXME
+        // access private
+        return chart.getModel()._componentsMap[type].length;
+    }
+
+    function getChartView(chart, series) {
+        return chart._chartsMap[series.__viewId];
+    }
+
+    function countChartViews(chart) {
+        return chart._chartsViews.length;
+    }
+
+    function saveOrigins(chart) {
+        var count = countSeries(chart);
+        var origins = [];
+        for (var i = 0; i < count; i++) {
+            var series = getSeries(chart, i);
+            origins.push({
+                model: series,
+                view: getChartView(chart, series)
+            });
+        }
+        return origins;
+    }
+
+    function modelEqualsToOrigin(idxList, origins, boolResult) {
+        for (var i = 0; i < idxList.length; i++) {
+            var idx = idxList[i];
+            expect(origins[idx].model === getSeries(chart, idx)).toEqual(boolResult);
+        }
+    }
+
+    function viewEqualsToOrigin(idxList, origins, boolResult) {
+        for (var i = 0; i < idxList.length; i++) {
+            var idx = idxList[i];
+            expect(
+                origins[idx].view === getChartView(chart, getSeries(chart, idx))
+            ).toEqual(boolResult);
+        }
+    }
+
+
+
+    describe('idNoNameNo', function () {
+
+        testCase('sameTypeNotMerge', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22]},
+                    {type: 'line', data: [33]}
+                ]
+            };
+            chart.setOption(option);
+
+            // Not merge
+            var origins = saveOrigins(chart);
+            chart.setOption(option, true);
+            expect(countChartViews(chart)).toEqual(3);
+            expect(countSeries(chart)).toEqual(3);
+            modelEqualsToOrigin([0, 1, 2], origins, false);
+            viewEqualsToOrigin([0, 1, 2], origins, true);
+        });
+
+        testCase('sameTypeMergeFull', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22]},
+                    {type: 'line', data: [33]}
+                ]
+            };
+            chart.setOption(option);
+
+            // Merge
+            var origins = saveOrigins(chart);
+            chart.setOption({
+                series: [
+                    {type: 'line', data: [111]},
+                    {type: 'line', data: [222]},
+                    {type: 'line', data: [333]}
+                ]
+            });
+
+            expect(countSeries(chart)).toEqual(3);
+            expect(countChartViews(chart)).toEqual(3);
+            expect(getData0(chart, 0)).toEqual(111);
+            expect(getData0(chart, 1)).toEqual(222);
+            expect(getData0(chart, 2)).toEqual(333);
+            viewEqualsToOrigin([0, 1, 2], origins, true);
+            modelEqualsToOrigin([0, 1, 2], origins, true);
+        });
+
+        testCase('sameTypeMergePartial', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22]},
+                    {type: 'line', data: [33]}
+                ]
+            };
+            chart.setOption(option);
+
+            // Merge
+            var origins = saveOrigins(chart);
+            chart.setOption({
+                series: [
+                    {type: 'line', data: [22222]}
+                ]
+            });
+
+            expect(countSeries(chart)).toEqual(3);
+            expect(countChartViews(chart)).toEqual(3);
+            expect(getData0(chart, 0)).toEqual(22222);
+            expect(getData0(chart, 1)).toEqual(22);
+            expect(getData0(chart, 2)).toEqual(33);
+            viewEqualsToOrigin([0, 1, 2], origins, true);
+            modelEqualsToOrigin([0, 1, 2], origins, true);
+        });
+
+        testCase('differentTypeMerge', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22]},
+                    {type: 'line', data: [33]}
+                ]
+            };
+            chart.setOption(option);
+
+            // Merge
+            var origins = saveOrigins(chart);
+            chart.setOption({
+                series: [
+                    {type: 'line', data: [111]},
+                    {type: 'bar', data: [222]},
+                    {type: 'line', data: [333]}
+                ]
+            });
+
+            expect(countSeries(chart)).toEqual(3);
+            expect(countChartViews(chart)).toEqual(3);
+            expect(getData0(chart, 0)).toEqual(111);
+            expect(getData0(chart, 1)).toEqual(222);
+            expect(getData0(chart, 2)).toEqual(333);
+            expect(getSeries(chart, 1).type === 'series.bar').toEqual(true);
+            modelEqualsToOrigin([0, 2], origins, true);
+            modelEqualsToOrigin([1], origins, false);
+            viewEqualsToOrigin([0, 2], origins, true);
+            viewEqualsToOrigin([1], origins, false);
+        });
+
+    });
+
+
+
+
+
+    describe('idSpecified', function () {
+
+        testCase('sameTypeNotMerge', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], id: 20},
+                    {type: 'line', data: [33], id: 30},
+                    {type: 'line', data: [44]},
+                    {type: 'line', data: [55]}
+                ]
+            };
+            chart.setOption(option);
+
+            expect(countSeries(chart)).toEqual(5);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(getData0(chart, 0)).toEqual(11);
+            expect(getData0(chart, 1)).toEqual(22);
+            expect(getData0(chart, 2)).toEqual(33);
+            expect(getData0(chart, 3)).toEqual(44);
+            expect(getData0(chart, 4)).toEqual(55);
+
+            var origins = saveOrigins(chart);
+            chart.setOption(option, true);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(countSeries(chart)).toEqual(5);
+
+            modelEqualsToOrigin([0, 1, 2, 3, 4], origins, false);
+            viewEqualsToOrigin([0, 1, 2, 3, 4], origins, true);
+        });
+
+        testCase('sameTypeMerge', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], id: 20},
+                    {type: 'line', data: [33], id: 30},
+                    {type: 'line', data: [44]},
+                    {type: 'line', data: [55]}
+                ]
+            };
+            chart.setOption(option);
+
+            var origins = saveOrigins(chart);
+            chart.setOption(option);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(countSeries(chart)).toEqual(5);
+
+            modelEqualsToOrigin([0, 1, 2, 3, 4], origins, true);
+            viewEqualsToOrigin([0, 1, 2, 3, 4], origins, true);
+        });
+
+        testCase('differentTypeNotMerge', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], id: 20},
+                    {type: 'line', data: [33], id: 30},
+                    {type: 'line', data: [44]},
+                    {type: 'line', data: [55]}
+                ]
+            };
+            chart.setOption(option);
+
+            var origins = saveOrigins(chart);
+            var option2 = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'bar', data: [22], id: 20},
+                    {type: 'line', data: [33], id: 30},
+                    {type: 'bar', data: [44]},
+                    {type: 'line', data: [55]}
+                ]
+            };
+            chart.setOption(option2, true);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(countSeries(chart)).toEqual(5);
+
+            modelEqualsToOrigin([0, 1, 2, 3, 4], origins, false);
+            viewEqualsToOrigin([0, 2, 4], origins, true);
+            viewEqualsToOrigin([1, 3], origins, false);
+        });
+
+        testCase('differentTypeMergeFull', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], id: 20},
+                    {type: 'line', data: [33], id: 30, name: 'a'},
+                    {type: 'line', data: [44]},
+                    {type: 'line', data: [55]}
+                ]
+            };
+            chart.setOption(option);
+
+            var origins = saveOrigins(chart);
+            var option2 = {
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'bar', data: [22], id: 20, name: 'a'},
+                    {type: 'line', data: [33], id: 30},
+                    {type: 'bar', data: [44]},
+                    {type: 'line', data: [55]}
+                ]
+            };
+            chart.setOption(option2);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(countSeries(chart)).toEqual(5);
+
+            modelEqualsToOrigin([0, 2, 4], origins, true);
+            modelEqualsToOrigin([1, 3], origins, false);
+            viewEqualsToOrigin([0, 2, 4], origins, true);
+            viewEqualsToOrigin([1, 3], origins, false);
+        });
+
+        testCase('differentTypeMergePartial1', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], id: 20},
+                    {type: 'line', data: [33]},
+                    {type: 'line', data: [44], id: 40},
+                    {type: 'line', data: [55]}
+                ]
+            };
+            chart.setOption(option);
+
+            var origins = saveOrigins(chart);
+            var option2 = {
+                series: [
+                    {type: 'bar', data: [444], id: 40},
+                    {type: 'line', data: [333]},
+                    {type: 'line', data: [222], id: 20}
+                ]
+            };
+            chart.setOption(option2);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(countSeries(chart)).toEqual(5);
+
+            expect(getData0(chart, 0)).toEqual(333);
+            expect(getData0(chart, 1)).toEqual(222);
+            expect(getData0(chart, 2)).toEqual(33);
+            expect(getData0(chart, 3)).toEqual(444);
+            expect(getData0(chart, 4)).toEqual(55);
+            modelEqualsToOrigin([0, 1, 2, 4], origins, true);
+            modelEqualsToOrigin([3], origins, false);
+            viewEqualsToOrigin([0, 1, 2, 4], origins, true);
+            viewEqualsToOrigin([3], origins, false);
+        });
+
+        testCase('differentTypeMergePartial2', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], id: 20}
+                ]
+            };
+            chart.setOption(option);
+
+            var option2 = {
+                series: [
+                    {type: 'bar', data: [444], id: 40},
+                    {type: 'line', data: [333]},
+                    {type: 'line', data: [222], id: 20},
+                    {type: 'line', data: [111]}
+                ]
+            };
+            chart.setOption(option2);
+            expect(countChartViews(chart)).toEqual(4);
+            expect(countSeries(chart)).toEqual(4);
+
+            expect(getData0(chart, 0)).toEqual(333);
+            expect(getData0(chart, 1)).toEqual(222);
+            expect(getData0(chart, 2)).toEqual(444);
+            expect(getData0(chart, 3)).toEqual(111);
+        });
+
+
+        testCase('mergePartialDoNotMapToOtherId', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11], id: 10},
+                    {type: 'line', data: [22], id: 20}
+                ]
+            };
+            chart.setOption(option);
+
+            var option2 = {
+                series: [
+                    {type: 'bar', data: [444], id: 40},
+                ]
+            };
+            chart.setOption(option2);
+            expect(countChartViews(chart)).toEqual(3);
+            expect(countSeries(chart)).toEqual(3);
+
+            expect(getData0(chart, 0)).toEqual(11);
+            expect(getData0(chart, 1)).toEqual(22);
+            expect(getData0(chart, 2)).toEqual(444);
+        });
+
+
+        testCase('idDuplicate', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11], id: 10},
+                    {type: 'line', data: [22], id: 10}
+                ]
+            };
+
+            expect(function () {
+                chart.setOption(option);
+            }).toThrowError(/duplicate/);
+        });
+
+
+    });
+
+
+
+
+
+
+
+
+
+
+    describe('noIdButNameExists', function () {
+
+        testCase('sameTypeNotMerge', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], name: 'a'},
+                    {type: 'line', data: [33], name: 'b'},
+                    {type: 'line', data: [44]},
+                    {type: 'line', data: [55], name: 'a'}
+                ]
+            };
+            chart.setOption(option);
+
+            expect(getSeries(chart, 1)).not.toEqual(getSeries(chart, 4));
+
+
+            expect(countSeries(chart)).toEqual(5);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(getData0(chart, 0)).toEqual(11);
+            expect(getData0(chart, 1)).toEqual(22);
+            expect(getData0(chart, 2)).toEqual(33);
+            expect(getData0(chart, 3)).toEqual(44);
+            expect(getData0(chart, 4)).toEqual(55);
+
+            var origins = saveOrigins(chart);
+            chart.setOption(option, true);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(countSeries(chart)).toEqual(5);
+
+            modelEqualsToOrigin([0, 1, 2, 3, 4], origins, false);
+            viewEqualsToOrigin([0, 1, 2, 3, 4], origins, true);
+        });
+
+        testCase('sameTypeMerge', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], name: 'a'},
+                    {type: 'line', data: [33], name: 'b'},
+                    {type: 'line', data: [44]},
+                    {type: 'line', data: [55], name: 'a'}
+                ]
+            };
+            chart.setOption(option);
+
+            var origins = saveOrigins(chart);
+            chart.setOption(option);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(countSeries(chart)).toEqual(5);
+
+            modelEqualsToOrigin([0, 1, 2, 3, 4], origins, true);
+            viewEqualsToOrigin([0, 1, 2, 3, 4], origins, true);
+        });
+
+        testCase('differentTypeNotMerge', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], name: 'a'},
+                    {type: 'line', data: [33], name: 'b'},
+                    {type: 'line', data: [44]},
+                    {type: 'line', data: [55], name: 'a'}
+                ]
+            };
+            chart.setOption(option);
+
+            var origins = saveOrigins(chart);
+            var option2 = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'bar', data: [22], name: 'a'},
+                    {type: 'line', data: [33], name: 'b'},
+                    {type: 'bar', data: [44]},
+                    {type: 'line', data: [55], name: 'a'}
+                ]
+            };
+            chart.setOption(option2, true);
+            expect(countChartViews(chart)).toEqual(5);
+            expect(countSeries(chart)).toEqual(5);
+
+            modelEqualsToOrigin([0, 1, 2, 3, 4], origins, false);
+            viewEqualsToOrigin([0, 2, 4], origins, true);
+            viewEqualsToOrigin([1, 3], origins, false);
+        });
+
+        testCase('differentTypeMergePartialOneMapTwo', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], name: 'a'},
+                    {type: 'line', data: [33]},
+                    {type: 'line', data: [44], name: 'b'},
+                    {type: 'line', data: [55], name: 'a'}
+                ]
+            };
+            chart.setOption(option);
+
+            var origins = saveOrigins(chart);
+            var option2 = {
+                series: [
+                    {type: 'bar', data: [444], id: 40},
+                    {type: 'line', data: [333]},
+                    {type: 'bar', data: [222], name: 'a'}
+                ]
+            };
+            chart.setOption(option2);
+            expect(countChartViews(chart)).toEqual(6);
+            expect(countSeries(chart)).toEqual(6);
+
+            expect(getData0(chart, 0)).toEqual(333);
+            expect(getData0(chart, 1)).toEqual(222);
+            expect(getData0(chart, 2)).toEqual(33);
+            expect(getData0(chart, 3)).toEqual(44);
+            expect(getData0(chart, 4)).toEqual(55);
+            expect(getData0(chart, 5)).toEqual(444);
+            modelEqualsToOrigin([0, 2, 3, 4], origins, true);
+            modelEqualsToOrigin([1], origins, false);
+            viewEqualsToOrigin([0, 2, 3, 4], origins, true);
+            viewEqualsToOrigin([1], origins, false);
+        });
+
+        testCase('differentTypeMergePartialTwoMapOne', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22], name: 'a'}
+                ]
+            };
+            chart.setOption(option);
+
+            var option2 = {
+                series: [
+                    {type: 'bar', data: [444], name: 'a'},
+                    {type: 'line', data: [333]},
+                    {type: 'line', data: [222], name: 'a'},
+                    {type: 'line', data: [111]}
+                ]
+            };
+            chart.setOption(option2);
+            expect(countChartViews(chart)).toEqual(4);
+            expect(countSeries(chart)).toEqual(4);
+
+            expect(getData0(chart, 0)).toEqual(333);
+            expect(getData0(chart, 1)).toEqual(444);
+            expect(getData0(chart, 2)).toEqual(222);
+            expect(getData0(chart, 3)).toEqual(111);
+        });
+
+        testCase('mergePartialCanMapToOtherName', function (chart, echarts) {
+            // Consider case: axis.name = 'some label', which can be overwritten.
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11], name: 10},
+                    {type: 'line', data: [22], name: 20}
+                ]
+            };
+            chart.setOption(option);
+
+            var option2 = {
+                series: [
+                    {type: 'bar', data: [444], name: 40},
+                    {type: 'bar', data: [999], name: 40},
+                    {type: 'bar', data: [777], id: 70}
+                ]
+            };
+            chart.setOption(option2);
+            expect(countChartViews(chart)).toEqual(3);
+            expect(countSeries(chart)).toEqual(3);
+
+            expect(getData0(chart, 0)).toEqual(444);
+            expect(getData0(chart, 1)).toEqual(999);
+            expect(getData0(chart, 2)).toEqual(777);
+        });
+
+    });
+
+
+
+
+
+
+    describe('ohters', function () {
+
+        testCase('aBugCase', function (chart, echarts) {
+            var option = {
+                series: [
+                    {
+                        type:'pie',
+                        radius: ['20%', '25%'],
+                        center:['20%', '20%'],
+                        avoidLabelOverlap: true,
+                        hoverAnimation :false,
+                        label: {
+                            normal: {
+                                show: true,
+                                position: 'center',
+                                textStyle: {
+                                    fontSize: '30',
+                                    fontWeight: 'bold'
+                                }
+                            },
+                            emphasis: {
+                                show: true
+                            }
+                        },
+                        data:[
+                            {value:135, name:'视频广告'},
+                            {value:1548}
+                        ]
+                    }
+                ]
+            };
+            chart.setOption(option);
+
+            chart.setOption({
+                series: [
+                    {
+                        type:'pie',
+                        radius: ['20%', '25%'],
+                        center: ['20%', '20%'],
+                        avoidLabelOverlap: true,
+                        hoverAnimation: false,
+                        label: {
+                            normal: {
+                                show: true,
+                                position: 'center',
+                                textStyle: {
+                                    fontSize: '30',
+                                    fontWeight: 'bold'
+                                }
+                            }
+                        },
+                        data: [
+                            {value:135, name:'视频广告'},
+                            {value:1548}
+                        ]
+                    },
+                    {
+                        type:'pie',
+                        radius: ['20%', '25%'],
+                        center: ['60%', '20%'],
+                        avoidLabelOverlap: true,
+                        hoverAnimation: false,
+                        label: {
+                            normal: {
+                                show: true,
+                                position: 'center',
+                                textStyle: {
+                                    fontSize: '30',
+                                    fontWeight: 'bold'
+                                }
+                            }
+                        },
+                        data: [
+                            {value:135, name:'视频广告'},
+                            {value:1548}
+                        ]
+                    }
+                ]
+            }, true);
+
+            expect(countChartViews(chart)).toEqual(2);
+            expect(countSeries(chart)).toEqual(2);
+        });
+
+        testCase('color', function (chart, echarts) {
+            var option = {
+                backgroundColor: 'rgba(1,1,1,1)',
+                xAxis: {data: ['a']},
+                yAxis: {},
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22]},
+                    {type: 'line', data: [33]}
+                ]
+            };
+            chart.setOption(option);
+            expect(chart._model.option.backgroundColor).toEqual('rgba(1,1,1,1)');
+
+            // Not merge
+            chart.setOption({
+                backgroundColor: '#fff'
+            }, true);
+
+            expect(chart._model.option.backgroundColor).toEqual('#fff');
+        });
+
+        testCase('innerId', function (chart, echarts) {
+            var option = {
+                xAxis: {data: ['a']},
+                yAxis: {},
+                toolbox: {
+                    feature: {
+                        dataZoom: {}
+                    }
+                },
+                dataZoom: [
+                    {type: 'inside', id: 'a'},
+                    {type: 'slider', id: 'b'}
+                ],
+                series: [
+                    {type: 'line', data: [11]},
+                    {type: 'line', data: [22]}
+                ]
+            };
+            chart.setOption(option);
+
+            expect(countModel(chart, 'dataZoom')).toEqual(4);
+            expect(getModel(chart, 'dataZoom', 0).id).toEqual('a');
+            expect(getModel(chart, 'dataZoom', 1).id).toEqual('b');
+
+            // Merge
+            chart.setOption({
+                dataZoom: [
+                    {type: 'slider', id: 'c'},
+                    {type: 'slider', name: 'x'}
+                ]
+            });
+
+            expect(countModel(chart, 'dataZoom')).toEqual(5);
+            expect(getModel(chart, 'dataZoom', 0).id).toEqual('a');
+            expect(getModel(chart, 'dataZoom', 1).id).toEqual('b');
+            expect(getModel(chart, 'dataZoom', 4).id).toEqual('c');
+        });
+
+    });
+
+
+});