first commit

libraries/framework/vendor/plugins/c3charts/spec/api.data-spec.js

@@ -0,0 +1,170 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 api data', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 5000, 2000, 1000, 4000, 1500, 2500]
+            ],
+            names: {
+                data1: 'Data Name 1',
+                data2: 'Data Name 2'
+            },
+            colors: {
+                data1: '#FF0000',
+                data2: '#00FF00'
+            },
+            axes: {
+                data1: 'y',
+                data2: 'y2'
+            }
+        },
+        axis: {
+            y2: {
+                show: true
+            }
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('data()', function () {
+
+        it('should return all of data if no argument given', function () {
+            var results = chart.data(),
+                expected = ['data1', 'data2'];
+            results.forEach(function (result, i) {
+                expect(result.id).toBe(expected[i]);
+            });
+        });
+
+        it('should return specifid data if string argument given', function () {
+            var results = chart.data('data1');
+            expect(results.length).toBe(1);
+            expect(results[0].id).toBe('data1');
+        });
+
+        it('should return specifid data if array argument given', function () {
+            var results = chart.data(['data1', 'data2']);
+            expect(results.length).toBe(2);
+            expect(results[0].id).toBe('data1');
+            expect(results[1].id).toBe('data2');
+        });
+
+    });
+
+    describe('data.shown()', function () {
+
+        it('should return only shown targets', function () {
+            var results;
+            chart.hide('data1');
+            results = chart.data.shown();
+            expect(results.length).toBe(1);
+            expect(results[0].id).toBe('data2');
+        });
+
+    });
+
+    describe('data.values()', function () {
+
+        it('should return values for specified target', function () {
+            var values = chart.data.values('data1'),
+                expectedValues = [30, 200, 100, 400, 150, 250];
+            expect(values.length).toBe(6);
+            values.forEach(function (v, i) {
+                expect(v).toBe(expectedValues[i]);
+            });
+        });
+
+        it('should return null when no args', function () {
+            var values = chart.data.values();
+            expect(values).toBeNull();
+        });
+
+    });
+
+    describe('data.names()', function () {
+
+        it('should return data.names specified as argument', function () {
+            var results = chart.data.names();
+            expect(results.data1).toBe('Data Name 1');
+            expect(results.data2).toBe('Data Name 2');
+        });
+
+        it('should return data.names specified as api', function () {
+            var results = chart.data.names({
+                data1: 'New Data Name 1',
+                data2: 'New Data Name 2'
+            });
+            expect(results.data1).toBe('New Data Name 1');
+            expect(results.data2).toBe('New Data Name 2');
+        });
+
+        it('should set data.names specified as api', function () {
+            expect(d3.select('.c3-legend-item-data1 text').text()).toBe("New Data Name 1");
+            expect(d3.select('.c3-legend-item-data2 text').text()).toBe("New Data Name 2");
+        });
+
+    });
+
+    describe('data.colors()', function () {
+
+        it('should return data.colors specified as argument', function () {
+            var results = chart.data.colors();
+            expect(results.data1).toBe('#FF0000');
+            expect(results.data2).toBe('#00FF00');
+        });
+
+        it('should return data.colors specified as api', function () {
+            var results = chart.data.colors({
+                data1: '#00FF00',
+                data2: '#FF0000'
+            });
+            expect(results.data1).toBe('#00FF00');
+            expect(results.data2).toBe('#FF0000');
+        });
+
+        it('should set data.colors specified as api', function () {
+            expect(d3.select('.c3-line-data1').style('stroke')).toBe("#00ff00");
+            expect(d3.select('.c3-line-data2').style('stroke')).toBe("#ff0000");
+            expect(d3.select('.c3-legend-item-data1 .c3-legend-item-tile').style('fill')).toBe("#00ff00");
+            expect(d3.select('.c3-legend-item-data2 .c3-legend-item-tile').style('fill')).toBe("#ff0000");
+        });
+
+    });
+
+    describe('data.axes()', function () {
+
+        it('should return data.axes specified as argument', function () {
+            var results = chart.data.axes();
+            expect(results.data1).toBe('y');
+            expect(results.data2).toBe('y2');
+            expect(d3.select('.c3-axis-y g.tick text').text()).toBe('0');
+            expect(d3.select('.c3-axis-y2 g.tick text').text()).toBe('1000');
+        });
+
+        it('should return data.axes specified as api', function () {
+            var results = chart.data.axes({
+                data1: 'y2',
+                data2: 'y'
+            });
+            expect(results.data1).toBe('y2');
+            expect(results.data2).toBe('y');
+            expect(d3.select('.c3-axis-y g.tick text').text()).toBe('1000');
+            expect(d3.select('.c3-axis-y2 g.tick text').text()).toBe('0');
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/api.focus-spec.js

@@ -0,0 +1,433 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 api load', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400],
+                ['data2', 1000, 800, 500, 2000],
+                ['data3', 5000, 2000, 1000, 4000]
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('focus', function () {
+
+        it('should focus all targets', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus();
+            setTimeout(function () {
+                var targets = main.select('.c3-chart-line.c3-target'),
+                    legendItems = legend.select('.c3-legend-item');
+                targets.each(function () {
+                    var line = d3.select(this);
+                    expect(line.classed('c3-focused')).toBeTruthy();
+                });
+                legendItems.each(function () {
+                    var item = d3.select(this);
+                    expect(item.classed('c3-legend-item-focused')).toBeTruthy();
+                });
+                done();
+            }, 500);
+        });
+
+        it('should focus one target', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus('data2');
+            setTimeout(function () {
+                var targets = {
+                    data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                    data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                    data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                },
+                legendItems = {
+                    data1: legend.select('.c3-legend-item-data1'),
+                    data2: legend.select('.c3-legend-item-data2'),
+                    data3: legend.select('.c3-legend-item-data3')
+                };
+                expect(targets.data1.classed('c3-focused')).toBeFalsy();
+                expect(targets.data2.classed('c3-focused')).toBeTruthy();
+                expect(targets.data3.classed('c3-focused')).toBeFalsy();
+                expect(legendItems.data1.classed('c3-legend-item-focused')).toBeFalsy();
+                expect(legendItems.data2.classed('c3-legend-item-focused')).toBeTruthy();
+                expect(legendItems.data3.classed('c3-legend-item-focused')).toBeFalsy();
+                done();
+            }, 500);
+        });
+
+        it('should focus multiple targets', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus(['data1', 'data2']);
+            setTimeout(function () {
+                var targets = {
+                    data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                    data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                    data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                },
+                legendItems = {
+                    data1: legend.select('.c3-legend-item-data1'),
+                    data2: legend.select('.c3-legend-item-data2'),
+                    data3: legend.select('.c3-legend-item-data3')
+                };
+                expect(targets.data1.classed('c3-focused')).toBeTruthy();
+                expect(targets.data2.classed('c3-focused')).toBeTruthy();
+                expect(targets.data3.classed('c3-focused')).toBeFalsy();
+                expect(legendItems.data1.classed('c3-legend-item-focused')).toBeTruthy();
+                expect(legendItems.data2.classed('c3-legend-item-focused')).toBeTruthy();
+                expect(legendItems.data3.classed('c3-legend-item-focused')).toBeFalsy();
+                done();
+            }, 500);
+        });
+
+    });
+
+    describe('defocus', function () {
+
+        it('should defocus all targets', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.defocus();
+            setTimeout(function () {
+                var targets = main.select('.c3-chart-line.c3-target'),
+                    legendItems = legend.select('.c3-legend-item');
+                targets.each(function () {
+                    var line = d3.select(this);
+                    expect(line.classed('c3-focused')).toBeFalsy();
+                    expect(line.classed('c3-defocused')).toBeTruthy();
+                });
+                legendItems.each(function () {
+                    var item = d3.select(this);
+                    expect(item.classed('c3-legend-item-focused')).toBeFalsy();
+                    expect(+item.style('opacity')).toBeCloseTo(0.3);
+                });
+                done();
+            }, 500);
+        });
+
+        it('should defocus one target', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.defocus('data2');
+            setTimeout(function () {
+                var targets = {
+                    data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                    data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                    data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                },
+                legendItems = {
+                    data1: legend.select('.c3-legend-item-data1'),
+                    data2: legend.select('.c3-legend-item-data2'),
+                    data3: legend.select('.c3-legend-item-data3')
+                };
+                expect(targets.data1.classed('c3-defocused')).toBeFalsy();
+                expect(targets.data2.classed('c3-defocused')).toBeTruthy();
+                expect(targets.data3.classed('c3-defocused')).toBeFalsy();
+                expect(legendItems.data1.classed('c3-legend-item-focused')).toBeFalsy();
+                expect(legendItems.data2.classed('c3-legend-item-focused')).toBeFalsy();
+                expect(legendItems.data3.classed('c3-legend-item-focused')).toBeFalsy();
+                expect(+legendItems.data1.style('opacity')).toBeCloseTo(1);
+                expect(+legendItems.data2.style('opacity')).toBeCloseTo(0.3);
+                expect(+legendItems.data3.style('opacity')).toBeCloseTo(1);
+                done();
+            }, 500);
+        });
+
+        it('should defocus multiple targets', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.defocus(['data1', 'data2']);
+            setTimeout(function () {
+                var targets = {
+                    data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                    data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                    data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                },
+                legendItems = {
+                    data1: legend.select('.c3-legend-item-data1'),
+                    data2: legend.select('.c3-legend-item-data2'),
+                    data3: legend.select('.c3-legend-item-data3')
+                };
+                expect(targets.data1.classed('c3-defocused')).toBeTruthy();
+                expect(targets.data2.classed('c3-defocused')).toBeTruthy();
+                expect(targets.data3.classed('c3-defocused')).toBeFalsy();
+                expect(legendItems.data1.classed('c3-legend-item-focused')).toBeFalsy();
+                expect(legendItems.data2.classed('c3-legend-item-focused')).toBeFalsy();
+                expect(legendItems.data3.classed('c3-legend-item-focused')).toBeFalsy();
+                expect(+legendItems.data1.style('opacity')).toBeCloseTo(0.3);
+                expect(+legendItems.data2.style('opacity')).toBeCloseTo(0.3);
+                expect(+legendItems.data3.style('opacity')).toBeCloseTo(1);
+                done();
+            }, 500);
+        });
+
+        it('should defocus multiple targets after focused', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus();
+            setTimeout(function () {
+                chart.defocus(['data1', 'data2']);
+                setTimeout(function () {
+                    var targets = {
+                        data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                        data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                        data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                    },
+                    legendItems = {
+                        data1: legend.select('.c3-legend-item-data1'),
+                        data2: legend.select('.c3-legend-item-data2'),
+                        data3: legend.select('.c3-legend-item-data3')
+                    };
+                    expect(targets.data1.classed('c3-defocused')).toBeTruthy();
+                    expect(targets.data2.classed('c3-defocused')).toBeTruthy();
+                    expect(targets.data3.classed('c3-defocused')).toBeFalsy();
+                    expect(legendItems.data1.classed('c3-legend-item-focused')).toBeFalsy();
+                    expect(legendItems.data2.classed('c3-legend-item-focused')).toBeFalsy();
+                    expect(legendItems.data3.classed('c3-legend-item-focused')).toBeTruthy();
+                    expect(+legendItems.data1.style('opacity')).toBeCloseTo(0.3);
+                    expect(+legendItems.data2.style('opacity')).toBeCloseTo(0.3);
+                    expect(+legendItems.data3.style('opacity')).toBeCloseTo(1);
+                    done();
+                }, 500);
+            });
+        }, 500);
+
+    });
+
+    describe('revert', function () {
+
+        it('should revert all targets after focus', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus();
+            setTimeout(function () {
+                chart.revert();
+                setTimeout(function () {
+                    var targets = main.select('.c3-chart-line.c3-target'),
+                        legendItems = legend.select('.c3-legend-item');
+                    targets.each(function () {
+                        var line = d3.select(this);
+                        expect(line.classed('c3-focused')).toBeFalsy();
+                    });
+                    legendItems.each(function () {
+                        var item = d3.select(this);
+                        expect(+item.style('opacity')).toBeCloseTo(1);
+                    });
+                    done();
+                }, 500);
+            }, 500);
+        });
+
+        it('should revert all targets after defocus', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.defocus();
+            setTimeout(function () {
+                chart.revert();
+                setTimeout(function () {
+                    var targets = main.select('.c3-chart-line.c3-target'),
+                        legendItems = legend.select('.c3-legend-item');
+                    targets.each(function () {
+                        var line = d3.select(this);
+                        expect(line.classed('c3-defocused')).toBeFalsy();
+                    });
+                    legendItems.each(function () {
+                        var item = d3.select(this);
+                        expect(+item.style('opacity')).toBeCloseTo(1);
+                    });
+                    done();
+                }, 500);
+            }, 500);
+        });
+
+        it('should revert one target after focus', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus();
+            setTimeout(function () {
+                chart.revert('data2');
+                setTimeout(function () {
+                    var targets = {
+                        data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                        data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                        data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                    },
+                    legendItems = {
+                        data1: legend.select('.c3-legend-item-data1'),
+                        data2: legend.select('.c3-legend-item-data2'),
+                        data3: legend.select('.c3-legend-item-data3')
+                    };
+                    expect(targets.data1.classed('c3-focused')).toBeTruthy();
+                    expect(targets.data2.classed('c3-focused')).toBeFalsy();
+                    expect(targets.data3.classed('c3-focused')).toBeTruthy();
+                    expect(+legendItems.data1.style('opacity')).toBeCloseTo(1);
+                    expect(+legendItems.data2.style('opacity')).toBeCloseTo(1);
+                    expect(+legendItems.data3.style('opacity')).toBeCloseTo(1);
+                    done();
+                }, 500);
+            }, 500);
+        });
+
+        it('should revert one target after defocus', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.defocus();
+            setTimeout(function () {
+                chart.revert('data2');
+                setTimeout(function () {
+                    var targets = {
+                        data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                        data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                        data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                    },
+                    legendItems = {
+                        data1: legend.select('.c3-legend-item-data1'),
+                        data2: legend.select('.c3-legend-item-data2'),
+                        data3: legend.select('.c3-legend-item-data3')
+                    };
+                    expect(targets.data1.classed('c3-defocused')).toBeTruthy();
+                    expect(targets.data2.classed('c3-defocused')).toBeFalsy();
+                    expect(targets.data3.classed('c3-defocused')).toBeTruthy();
+                    expect(+legendItems.data1.style('opacity')).toBeCloseTo(0.3);
+                    expect(+legendItems.data2.style('opacity')).toBeCloseTo(1);
+                    expect(+legendItems.data3.style('opacity')).toBeCloseTo(0.3);
+                    done();
+                }, 500);
+            }, 500);
+        });
+
+        it('should focus multiple targets after focus', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus();
+            setTimeout(function () {
+                chart.revert(['data1', 'data2']);
+                setTimeout(function () {
+                    var targets = {
+                        data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                        data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                        data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                    },
+                    legendItems = {
+                        data1: legend.select('.c3-legend-item-data1'),
+                        data2: legend.select('.c3-legend-item-data2'),
+                        data3: legend.select('.c3-legend-item-data3')
+                    };
+                    expect(targets.data1.classed('c3-focused')).toBeFalsy();
+                    expect(targets.data2.classed('c3-focused')).toBeFalsy();
+                    expect(targets.data3.classed('c3-focused')).toBeTruthy();
+                    expect(+legendItems.data1.style('opacity')).toBeCloseTo(1);
+                    expect(+legendItems.data2.style('opacity')).toBeCloseTo(1);
+                    expect(+legendItems.data3.style('opacity')).toBeCloseTo(1);
+                    done();
+                }, 500);
+            }, 500);
+        });
+
+        it('should focus multiple targets after defocus', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.defocus();
+            setTimeout(function () {
+                chart.revert(['data1', 'data2']);
+                setTimeout(function () {
+                    var targets = {
+                        data1: main.select('.c3-chart-line.c3-target.c3-target-data1'),
+                        data2: main.select('.c3-chart-line.c3-target.c3-target-data2'),
+                        data3: main.select('.c3-chart-line.c3-target.c3-target-data3')
+                    },
+                    legendItems = {
+                        data1: legend.select('.c3-legend-item-data1'),
+                        data2: legend.select('.c3-legend-item-data2'),
+                        data3: legend.select('.c3-legend-item-data3')
+                    };
+                    expect(targets.data1.classed('c3-defocused')).toBeFalsy();
+                    expect(targets.data2.classed('c3-defocused')).toBeFalsy();
+                    expect(targets.data3.classed('c3-defocused')).toBeTruthy();
+                    expect(+legendItems.data1.style('opacity')).toBeCloseTo(1);
+                    expect(+legendItems.data2.style('opacity')).toBeCloseTo(1);
+                    expect(+legendItems.data3.style('opacity')).toBeCloseTo(0.3);
+                    done();
+                }, 500);
+            }, 500);
+        });
+
+    });
+
+    describe('when legend.show = false', function () {
+
+        it('should update args to hide legend', function () {
+            args.legend = {
+                show: false
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should focus all targets without showing legend', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus();
+            setTimeout(function () {
+                var targets = main.select('.c3-chart-line.c3-target'),
+                    legendItems = legend.select('.c3-legend-item');
+                targets.each(function () {
+                    var line = d3.select(this);
+                    expect(line.classed('c3-focused')).toBeTruthy();
+                });
+                expect(legendItems.size()).toBeCloseTo(0);
+                done();
+            }, 500);
+        });
+
+        it('should defocus all targets without showing legend', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.defocus();
+            setTimeout(function () {
+                var targets = main.select('.c3-chart-line.c3-target'),
+                    legendItems = legend.select('.c3-legend-item');
+                targets.each(function () {
+                    var line = d3.select(this);
+                    expect(line.classed('c3-defocused')).toBeTruthy();
+                });
+                expect(legendItems.size()).toBeCloseTo(0);
+                done();
+            }, 500);
+        });
+
+        it('should revert all targets after focus', function (done) {
+            var main = chart.internal.main,
+                legend = chart.internal.legend;
+            chart.focus();
+            setTimeout(function () {
+                chart.revert();
+                setTimeout(function () {
+                    var targets = main.select('.c3-chart-line.c3-target'),
+                        legendItems = legend.select('.c3-legend-item');
+                    targets.each(function () {
+                        var line = d3.select(this);
+                        expect(line.classed('c3-focused')).toBeFalsy();
+                    });
+                    expect(legendItems.size()).toBeCloseTo(0);
+                    done();
+                }, 500);
+            }, 500);
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/api.grid-spec.js

@@ -0,0 +1,122 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 api grid', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250]
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('ygrid.add and ygrid.remove', function () {
+
+        it('should update y grids', function (done) {
+            var main = chart.internal.main,
+                expectedGrids = [
+                    {
+                        value: 100,
+                        text: 'Pressure Low'
+                    },
+                    {
+                        value: 200,
+                        text: 'Pressure High'
+                    }
+                ],
+                grids;
+
+            // Call ygrids.add
+            chart.ygrids.add(expectedGrids);
+            setTimeout(function () {
+                grids = main.selectAll('.c3-ygrid-line');
+                expect(grids.size()).toBe(expectedGrids.length);
+                grids.each(function (d, i) {
+                    var y = +d3.select(this).select('line').attr('y1'),
+                        text = d3.select(this).select('text').text(),
+                        expectedY = Math.round(chart.internal.y(expectedGrids[i].value)),
+                        expectedText = expectedGrids[i].text;
+                    expect(y).toBe(expectedY);
+                    expect(text).toBe(expectedText);
+                });
+
+                // Call ygrids.remove
+                chart.ygrids.remove(expectedGrids);
+                setTimeout(function () {
+                    grids = main.selectAll('.c3-ygrid-line');
+                    expect(grids.size()).toBe(0);
+                }, 500);
+
+            }, 500);
+
+            setTimeout(function () {
+                done();
+            }, 1200);
+        });
+
+        it("should update x ygrids even if it's zoomed", function (done) {
+            var main = chart.internal.main,
+                expectedGrids = [
+                    {
+                        value: 0,
+                        text: 'Pressure Low'
+                    },
+                    {
+                        value: 1,
+                        text: 'Pressure High'
+                    }
+                ],
+                grids, domain;
+
+            chart.zoom([0, 2]);
+            setTimeout(function () {
+
+                // Call xgrids
+                chart.xgrids(expectedGrids);
+                setTimeout(function () {
+                    grids = main.selectAll('.c3-xgrid-line');
+                    expect(grids.size()).toBe(expectedGrids.length);
+                    grids.each(function (d, i) {
+                        var x = +d3.select(this).select('line').attr('x1'),
+                            text = d3.select(this).select('text').text(),
+                            expectedX = Math.round(chart.internal.x(expectedGrids[i].value)),
+                            expectedText = expectedGrids[i].text;
+                        expect(x).toBe(expectedX);
+                        expect(text).toBe(expectedText);
+                    });
+
+                    // check if it was not rescaled
+                    domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeLessThan(0);
+                    expect(domain[1]).toBeGreaterThan(400);
+
+                    // Call xgrids.remove
+                    chart.xgrids.remove(expectedGrids);
+                    setTimeout(function () {
+                        grids = main.selectAll('.c3-xgrid-line');
+                        expect(grids.size()).toBe(0);
+                    }, 500); // for xgrids.remove()
+
+                }, 500); // for xgrids()
+
+            }, 500); // for zoom
+
+            setTimeout(function () {
+                done();
+            }, 1700);
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/api.load-spec.js

@@ -0,0 +1,124 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 api load', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 5000, 2000, 1000, 4000, 1500, 2500]
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('indexed data', function () {
+
+        describe('as column', function () {
+
+            it('should load additional data', function (done) {
+                var main = chart.internal.main,
+                    legend = chart.internal.legend;
+                chart.load({
+                    columns: [
+                        ['data3', 800, 500, 900, 500, 1000, 700]
+                    ]
+                });
+                setTimeout(function () {
+                    var target = main.select('.c3-chart-line.c3-target.c3-target-data3'),
+                        legendItem = legend.select('.c3-legend-item.c3-legend-item-data3');
+                    expect(target.size()).toBe(1);
+                    expect(legendItem.size()).toBe(1);
+                    done();
+                }, 500);
+            });
+
+        });
+
+    });
+
+    describe('category data', function () {
+
+        it('should update arg to category data', function () {
+            args = {
+                data: {
+                    x: 'x',
+                    columns: [
+                        ['x', 'cat1', 'cat2', 'cat3', 'cat4', 'cat5', 'cat6'],
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                        ['data2', 5000, 2000, 1000, 4000, 1500, 2500]
+                    ]
+                },
+                axis: {
+                    x: {
+                        type: 'category'
+                    }
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        describe('as column', function () {
+
+            it('should load additional data', function (done) {
+                var main = chart.internal.main,
+                    legend = chart.internal.legend;
+                chart.load({
+                    columns: [
+                        ['data3', 800, 500, 900, 500, 1000, 700]
+                    ]
+                });
+                setTimeout(function () {
+                    var target = main.select('.c3-chart-line.c3-target.c3-target-data3'),
+                        legendItem = legend.select('.c3-legend-item.c3-legend-item-data3'),
+                        tickTexts = main.selectAll('.c3-axis-x g.tick text'),
+                        expected = ['cat1', 'cat2', 'cat3', 'cat4', 'cat5', 'cat6'];
+                    expect(target.size()).toBe(1);
+                    expect(legendItem.size()).toBe(1);
+                    tickTexts.each(function (d, i) {
+                        var text = d3.select(this).select('tspan').text();
+                        expect(text).toBe(expected[i]);
+                    });
+                    done();
+                }, 500);
+            });
+
+            it('should load additional data', function (done) {
+                var main = chart.internal.main,
+                    legend = chart.internal.legend;
+                chart.load({
+                    columns: [
+                        ['x', 'new1', 'new2', 'new3', 'new4', 'new5', 'new6'],
+                        ['data3', 800, 500, 900, 500, 1000, 700]
+                    ]
+                });
+                setTimeout(function () {
+                    var target = main.select('.c3-chart-line.c3-target.c3-target-data3'),
+                        legendItem = legend.select('.c3-legend-item.c3-legend-item-data3'),
+                        tickTexts = main.selectAll('.c3-axis-x g.tick text'),
+                        expected = ['new1', 'new2', 'new3', 'new4', 'new5', 'new6'];
+                    expect(target.size()).toBe(1);
+                    expect(legendItem.size()).toBe(1);
+                    tickTexts.each(function (d, i) {
+                        var text = d3.select(this).select('tspan').text();
+                        expect(text).toBe(expected[i]);
+                    });
+                    done();
+                }, 500);
+            });
+
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/api.zoom-spec.js

@@ -0,0 +1,126 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 api zoom', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', 150, 120, 110, 140, 115, 125]
+            ]
+        },
+        zoom: {
+            enabled: true
+        }
+    };
+
+    beforeEach(function (done) {
+        if (typeof chart === 'undefined') {
+            window.initDom();
+        }
+        chart = window.c3.generate(args);
+        d3 = chart.internal.d3;
+//        chart.internal.d3.select('.jasmine_html-reporter').style('display', 'none');
+
+        window.setTimeout(function () {
+            done();
+        }, 10);
+    });
+
+    describe('zoom', function () {
+
+        it('should be zoomed properly', function () {
+            var target = [3, 5], domain;
+            chart.zoom(target);
+            domain = chart.internal.x.domain();
+            expect(domain[0]).toBe(target[0]);
+            expect(domain[1]).toBe(target[1]);
+        });
+
+        it('should be zoomed properly again', function () {
+            var target = [1, 4], domain;
+            chart.zoom(target);
+            domain = chart.internal.x.domain();
+            expect(domain[0]).toBe(target[0]);
+            expect(domain[1]).toBe(target[1]);
+        });
+
+        it('should load timeseries data', function () {
+            args = {
+                data: {
+                    x: 'date',
+                    columns: [
+                        ['date', '2014-01-01', '2014-01-02', '2014-08-01', '2014-10-19'],
+                        ['data1', 30, 200, 100, 400]
+                    ]
+                },
+                axis: {
+                    x: {
+                        type: 'timeseries'
+                    }
+                },
+                zoom: {
+                    enabled: true
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should be zoomed properly', function () {
+            var target = [new Date(2014, 7, 1), new Date(2014, 8, 1)], domain;
+            chart.zoom(target);
+            domain = chart.internal.x.domain();
+            expect(+domain[0]).toBe(+target[0]);
+            expect(+domain[1]).toBe(+target[1]);
+        });
+
+        it('should be zoomed properly', function () {
+            var target = ['2014-08-01', '2014-09-01'], domain;
+            chart.zoom(target);
+            domain = chart.internal.x.domain();
+            expect(+domain[0]).toBe(+chart.internal.parseDate(target[0]));
+            expect(+domain[1]).toBe(+chart.internal.parseDate(target[1]));
+        });
+
+    });
+
+    describe('unzoom', function () {
+
+        it('should load indexed data', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, 200, 100, 400, 150, 250]
+                    ]
+                },
+                zoom: {
+                    enabled: true
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should be unzoomed properly', function () {
+            var target = [1, 4], orginal = chart.internal.x.domain(), domain;
+
+            chart.zoom(target);
+            domain = chart.internal.x.domain();
+            expect(domain[0]).toBe(target[0]);
+            expect(domain[1]).toBe(target[1]);
+
+            chart.unzoom();
+            domain = chart.internal.x.domain();
+            expect(domain[0]).toBe(orginal[0]);
+            expect(domain[1]).toBe(orginal[1]);
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/arc-spec.js

@@ -0,0 +1,78 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart axis', function () {
+    'use strict';
+
+    var chart, d3, args;
+
+    beforeEach(function (done) {
+        if (typeof chart === 'undefined') {
+            window.initDom();
+        }
+        chart = window.c3.generate(args);
+        d3 = chart.internal.d3;
+        chart.internal.d3.select('.jasmine_html-reporter')
+            .style('position', 'absolute')
+            .style('right', 0);
+
+        window.setTimeout(function () {
+            done();
+        }, 50);
+    });
+
+    describe('show pie chart', function () {
+
+        args = {
+            data: {
+                columns: [
+                    ['data1', 30],
+                    ['data2', 150],
+                    ['data3', 120]
+                ],
+                type: 'pie'
+            }
+        };
+
+        it('should have correct classes', function () {
+            var chartArc = d3.select('.c3-chart-arcs'),
+            arcs = {
+                data1: chartArc.select('.c3-chart-arc.c3-target.c3-target-data1')
+                    .select('g.c3-shapes.c3-shapes-data1.c3-arcs.c3-arcs-data1')
+                    .select('path.c3-shape.c3-shape.c3-arc.c3-arc-data1'),
+                data2: chartArc.select('.c3-chart-arc.c3-target.c3-target-data2')
+                    .select('g.c3-shapes.c3-shapes-data2.c3-arcs.c3-arcs-data2')
+                    .select('path.c3-shape.c3-shape.c3-arc.c3-arc-data2'),
+                data3: chartArc.select('.c3-chart-arc.c3-target.c3-target-data3')
+                    .select('g.c3-shapes.c3-shapes-data3.c3-arcs.c3-arcs-data3')
+                    .select('path.c3-shape.c3-shape.c3-arc.c3-arc-data3')
+            };
+            expect(arcs.data1.size()).toBe(1);
+            expect(arcs.data2.size()).toBe(1);
+            expect(arcs.data3.size()).toBe(1);
+        });
+
+        it('should have correct d', function () {
+            expect(d3.select('.c3-arc-data1').attr('d')).toMatch(/M-124\..+,-171\..+A211\..+,211\..+ 0 0,1 -3\..+,-211\..+L0,0Z/);
+            expect(d3.select('.c3-arc-data2').attr('d')).toMatch(/M1\..+,-211\..+A211\..+,211\..+ 0 0,1 1\..+,211\..+L0,0Z/);
+            expect(d3.select('.c3-arc-data3').attr('d')).toMatch(/M1\..+,211\..+A211\..+,211\..+ 0 0,1 -124\..+,-171\..+L0,0Z/);
+        });
+
+        it('should set args with data id that can be converted to a color', function () {
+            args.data.columns = [
+                ['black', 30],
+                ['data2', 150],
+                ['data3', 120]
+            ];
+            expect(true).toBeTruthy();
+        });
+
+        it('should have correct d even if data id can be converted to a color', function () {
+            expect(d3.select('.c3-arc-black').attr('d')).toMatch(/M-124\..+,-171\..+A211\..+,211\..+ 0 0,1 -3\..+,-211\..+L0,0Z/);
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/axis-spec.js

@@ -0,0 +1,767 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart axis', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', 150, 120, 110, 140, 115, 125]
+            ]
+        },
+        axis: {
+            y: {
+                tick: {
+                    values: null,
+                    count: undefined
+                }
+            },
+            y2: {
+                tick: {
+                    values: null,
+                    count: undefined
+                }
+            }
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('axis.y.tick.count', function () {
+
+        var i = 1;
+
+        beforeEach(function () {
+            args.axis.y.tick.count = i++;
+            chart = window.c3.generate(args);
+        });
+
+        it('should have only 1 tick on y axis', function () {
+            var ticksSize = d3.select('.c3-axis-y').selectAll('g.tick').size();
+            expect(ticksSize).toBe(1);
+        });
+
+        it('should have 2 ticks on y axis', function () {
+            var ticksSize = d3.select('.c3-axis-y').selectAll('g.tick').size();
+            expect(ticksSize).toBe(2);
+        });
+
+        it('should have 3 ticks on y axis', function () {
+            var ticksSize = d3.select('.c3-axis-y').selectAll('g.tick').size();
+            expect(ticksSize).toBe(3);
+        });
+
+    });
+
+    describe('axis.y.tick.values', function () {
+
+        var values = [100, 500];
+
+        beforeEach(function () {
+            args.axis.y.tick.values = values;
+            chart = window.c3.generate(args);
+        });
+
+        it('should have only 2 tick on y axis', function () {
+            var ticksSize = d3.select('.c3-axis-y').selectAll('g.tick').size();
+            expect(ticksSize).toBe(2);
+        });
+
+        it('should have specified tick texts', function () {
+            d3.select('.c3-axis-y').selectAll('g.tick').each(function (d, i) {
+                var text = d3.select(this).select('text').text();
+                expect(+text).toBe(values[i]);
+            });
+        });
+
+    });
+
+    describe('axis y timeseries', function () {
+
+        var args = {
+            data: {
+                columns: [
+                    ["times", 60000, 120000, 180000, 240000]
+                ]
+            },
+            axis: {
+                y: {
+                    type : 'timeseries',
+                    tick: {
+                        time: {
+                        }
+                    }
+                }
+            }
+        };
+
+        beforeEach(function () {
+            chart = window.c3.generate(args);
+        });
+
+        it('should have 7 ticks on y axis', function () {
+            var ticksSize = d3.select('.c3-axis-y').selectAll('g.tick').size();
+            expect(ticksSize).toBe(7); // the count starts at initial value and increments by the set interval
+        });
+
+        it('should have specified 30 second intervals', function () {
+            var prevValue;
+            d3.select('.c3-axis-y').selectAll('g.tick').each(function (d, i) {
+                if (i !== 0) {
+                    var result = d - prevValue;
+                    expect(result).toEqual(30000); // expressed in milliseconds
+                }
+                prevValue = d;
+            });
+        });
+
+        it('should update args to set axis.y.time', function () {
+            args.axis.y.tick.time = {
+                value : 'seconds',
+                interval : 60
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should have 4 ticks on y axis', function () {
+            var ticksSize = d3.select('.c3-axis-y').selectAll('g.tick').size();
+            expect(ticksSize).toBe(4); // the count starts at initial value and increments by the set interval
+        });
+
+        it('should have specified 60 second intervals', function () {
+            var prevValue;
+            d3.select('.c3-axis-y').selectAll('g.tick').each(function (d, i) {
+                if (i !== 0) {
+                    var result = d - prevValue;
+                    expect(result).toEqual(60000); // expressed in milliseconds
+                }
+                prevValue = d;
+            });
+        });
+    });
+
+    describe('axis.x.tick.width', function () {
+
+        describe('indexed x axis and y/y2 axis', function () {
+
+            describe('not rotated', function () {
+
+                it('should update args successfully', function () {
+                    args = {
+                        data: {
+                            columns: [
+                                ['data1', 30, 200, 100, 400, 150, 250],
+                                ['data2', 50, 20, 10, 40, 15, 25]
+                            ],
+                            axes: {
+                                data2: 'y2'
+                            }
+                        },
+                        axis: {
+                            y2: {
+                                show: true
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should construct indexed x axis properly', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-x').selectAll('g.tick'),
+                        expectedX = '0',
+                        expectedDy = '.71em';
+                    expect(ticks.size()).toBe(6);
+                    ticks.each(function (d, i) {
+                        var tspans = d3.select(this).selectAll('tspan');
+                        expect(tspans.size()).toBe(1);
+                        tspans.each(function () {
+                            var tspan = d3.select(this);
+                            expect(tspan.text()).toBe(i + '');
+                            expect(tspan.attr('x')).toBe(expectedX);
+                            expect(tspan.attr('dy')).toBe(expectedDy);
+                        });
+                    });
+                });
+
+                it('should set axis.x.tick.format', function () {
+                    args.axis.x = {
+                        tick: {
+                            format: function () {
+                                return 'very long tick text on x axis';
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should split x axis tick text to multiple lines', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-x').selectAll('g.tick'),
+                        expectedTexts = ['very long tick text', 'on x axis'],
+                        expectedX = '0';
+                    expect(ticks.size()).toBe(6);
+                    ticks.each(function () {
+                        var tspans = d3.select(this).selectAll('tspan');
+                        expect(tspans.size()).toBe(2);
+                        tspans.each(function (d, i) {
+                            var tspan = d3.select(this);
+                            expect(tspan.text()).toBe(expectedTexts[i]);
+                            expect(tspan.attr('x')).toBe(expectedX);
+                            if (i === 0) {
+                                expect(tspan.attr('dy')).toBe('.71em');
+                            } else {
+                                expect(tspan.attr('dy')).toBeGreaterThan(8);
+                            }
+                        });
+                    });
+                });
+
+                it('should construct y axis properly', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-y').selectAll('g.tick'),
+                        expectedX = '-9',
+                        expectedDy = '3';
+                    expect(ticks.size()).toBe(9);
+                    ticks.each(function (d) {
+                        var tspans = d3.select(this).selectAll('tspan');
+                        expect(tspans.size()).toBe(1);
+                        tspans.each(function () {
+                            var tspan = d3.select(this);
+                            expect(tspan.text()).toBe(d + '');
+                            expect(tspan.attr('x')).toBe(expectedX);
+                            expect(tspan.attr('dy')).toBe(expectedDy);
+                        });
+                    });
+                });
+
+                it('should construct y2 axis properly', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-y2').selectAll('g.tick'),
+                        expectedX = '9',
+                        expectedDy = '3';
+                    expect(ticks.size()).toBe(9);
+                    ticks.each(function (d) {
+                        var tspans = d3.select(this).selectAll('tspan');
+                        expect(tspans.size()).toBe(1);
+                        tspans.each(function () {
+                            var tspan = d3.select(this);
+                            expect(tspan.text()).toBe(d + '');
+                            expect(tspan.attr('x')).toBe(expectedX);
+                            expect(tspan.attr('dy')).toBe(expectedDy);
+                        });
+                    });
+                });
+
+                it('should set big values in y', function () {
+                    args.data.columns = [
+                        ['data1', 3000000000000000, 200, 100, 400, 150, 250],
+                        ['data2', 50, 20, 10, 40, 15, 25]
+                    ];
+                    expect(true).toBeTruthy();
+                });
+
+                it('should not split y axis tick text to multiple lines', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-y2').selectAll('g.tick');
+                    ticks.each(function () {
+                        var tspans = d3.select(this).selectAll('tspan');
+                        expect(tspans.size()).toBe(1);
+                    });
+                });
+
+            });
+
+            describe('rotated', function () {
+
+                it('should update args to rotate axis', function () {
+                    args.axis.rotated = true;
+                    expect(true).toBeTruthy();
+                });
+
+                it('should split x axis tick text to multiple lines', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-x').selectAll('g.tick'),
+                        expectedTexts = ['very long tick', 'text on x axis'],
+                        expectedX = '-9';
+                    expect(ticks.size()).toBe(6);
+                    ticks.each(function () {
+                        var tspans = d3.select(this).selectAll('tspan');
+                        expect(tspans.size()).toBe(2);
+                        tspans.each(function (d, i) {
+                            var tspan = d3.select(this);
+                            expect(tspan.text()).toBe(expectedTexts[i]);
+                            expect(tspan.attr('x')).toBe(expectedX);
+                            if (i === 0) {
+                                expect(tspan.attr('dy')).toBeLessThan(0);
+                            } else {
+                                expect(tspan.attr('dy')).toBeGreaterThan(9);
+                            }
+                        });
+                    });
+                });
+
+                it('should not split y axis tick text to multiple lines', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-y').selectAll('g.tick'),
+                        expectedTexts = [
+                            '0',
+                            '500000000000000',
+                            '1000000000000000',
+                            '1500000000000000',
+                            '2000000000000000',
+                            '2500000000000000',
+                            '3000000000000000'
+                        ],
+                        expectedX = '0',
+                        expectedDy = '.71em';
+                    expect(ticks.size()).toBe(7);
+                    ticks.each(function (d, i) {
+                        var tspans = d3.select(this).selectAll('tspan');
+                        expect(tspans.size()).toBe(1);
+                        tspans.each(function () {
+                            var tspan = d3.select(this);
+                            expect(tspan.text()).toBe(expectedTexts[i]);
+                            expect(tspan.attr('x')).toBe(expectedX);
+                            expect(tspan.attr('dy')).toBe(expectedDy);
+                        });
+                    });
+                });
+
+            });
+        });
+
+        describe('category axis', function () {
+
+            describe('not rotated', function () {
+
+                it('should update args successfully', function () {
+                    args = {
+                        data: {
+                            x: 'x',
+                            columns: [
+                                ['x', 'this is a very long tick text on category axis', 'cat1', 'cat2', 'cat3', 'cat4', 'cat5'],
+                                ['data1', 30, 200, 100, 400, 150, 250],
+                                ['data2', 50, 20, 10, 40, 15, 25]
+                            ]
+                        },
+                        axis: {
+                            x: {
+                                type: 'category'
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should locate ticks properly', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-x').selectAll('g.tick');
+                    ticks.each(function (d, i) {
+                        var tspans = d3.select(this).selectAll('tspan'),
+                            expectedX = '0',
+                            expectedDy = '.71em';
+                        if (i > 0) { // i === 0 should be checked in next test
+                            expect(tspans.size()).toBe(1);
+                            tspans.each(function () {
+                                var tspan = d3.select(this);
+                                expect(tspan.attr('x')).toBe(expectedX);
+                                expect(tspan.attr('dy')).toBe(expectedDy);
+                            });
+                        }
+                    });
+                });
+
+                it('should split tick text properly', function () {
+                    var tick = chart.internal.main.select('.c3-axis-x').select('g.tick'),
+                        tspans = tick.selectAll('tspan'),
+                        expectedTickTexts = [
+                            'this is a very',
+                            'long tick text',
+                            'on category',
+                            'axis',
+                        ],
+                        expectedX = '0';
+                    expect(tspans.size()).toBe(4);
+                    tspans.each(function (d, i) {
+                        var tspan = d3.select(this);
+                        expect(tspan.text()).toBe(expectedTickTexts[i]);
+                        expect(tspan.attr('x')).toBe(expectedX);
+                        // unable to define pricise number because it differs depends on environment..
+                        if (i === 0) {
+                            expect(tspan.attr('dy')).toBe('.71em');
+                        } else {
+                            expect(tspan.attr('dy')).toBeGreaterThan(8);
+                        }
+                    });
+                });
+            });
+
+            describe('rotated', function () {
+
+                it('should update args to rotate axis', function () {
+                    args.axis.rotated = true;
+                    expect(true).toBeTruthy();
+                });
+
+                it('should locate ticks on rotated axis properly', function () {
+                    var ticks = chart.internal.main.select('.c3-axis-x').selectAll('g.tick');
+                    ticks.each(function (d, i) {
+                        var tspans = d3.select(this).selectAll('tspan'),
+                            expectedX = '-9',
+                            expectedDy = '3';
+                        if (i > 0) { // i === 0 should be checked in next test
+                            expect(tspans.size()).toBe(1);
+                            tspans.each(function () {
+                                var tspan = d3.select(this);
+                                expect(tspan.attr('x')).toBe(expectedX);
+                                expect(tspan.attr('dy')).toBe(expectedDy);
+                            });
+                        }
+                    });
+                });
+
+                it('should split tick text on rotated axis properly', function () {
+                    var tick = chart.internal.main.select('.c3-axis-x').select('g.tick'),
+                        tspans = tick.selectAll('tspan'),
+                        expectedTickTexts = [
+                            'this is a very',
+                            'long tick text on',
+                            'category axis'
+                        ],
+                        expectedX = '-9';
+                    expect(tspans.size()).toBe(3);
+                    tspans.each(function (d, i) {
+                        var tspan = d3.select(this);
+                        expect(tspan.text()).toBe(expectedTickTexts[i]);
+                        expect(tspan.attr('x')).toBe(expectedX);
+                        // unable to define pricise number because it differs depends on environment..
+                        if (i === 0) {
+                            expect(tspan.attr('dy')).toBeLessThan(0);
+                        } else {
+                            expect(tspan.attr('dy')).toBeGreaterThan(8);
+                        }
+                    });
+                });
+
+            });
+
+            describe('option used', function () {
+
+                describe('as null', function () {
+
+                    it('should update args not to split ticks', function () {
+                        args.axis.x.tick = {
+                            multiline: false
+                        };
+                        expect(true).toBeTruthy();
+                    });
+
+                    it('should split x tick', function () {
+                        var tick = chart.internal.main.select('.c3-axis-x').select('g.tick'),
+                            tspans = tick.selectAll('tspan');
+                        expect(tspans.size()).toBe(1);
+                    });
+
+                });
+
+                describe('as value', function () {
+
+                    it('should update args not to split ticks', function () {
+                        args.axis.x.tick = {
+                            width: 150
+                        };
+                        expect(true).toBeTruthy();
+                    });
+
+                    it('should split x tick to 2 lines properly', function () {
+                        var tick = chart.internal.main.select('.c3-axis-x').select('g.tick'),
+                            tspans = tick.selectAll('tspan'),
+                            expectedTickTexts = [
+                                'this is a very long tick',
+                                'text on category axis'
+                            ],
+                            expectedX = '-9';
+                        expect(tspans.size()).toBe(2);
+                        tspans.each(function (d, i) {
+                            var tspan = d3.select(this);
+                            expect(tspan.text()).toBe(expectedTickTexts[i]);
+                            expect(tspan.attr('x')).toBe(expectedX);
+                            // unable to define pricise number because it differs depends on environment..
+                            if (i === 0) {
+                                expect(tspan.attr('dy')).toBeLessThan(0);
+                            } else {
+                                expect(tspan.attr('dy')).toBeGreaterThan(8);
+                            }
+                        });
+                    });
+                });
+            });
+        });
+
+        describe('with axis.x.tick.format', function () {
+
+            it('should update args to use axis.x.tick.format', function () {
+                args.axis.x.tick.format = function () {
+                    return ['this is a very long tick text', 'on category axis'];
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should have multiline tick text', function () {
+                var tick = chart.internal.main.select('.c3-axis-x').select('g.tick'),
+                    tspans = tick.selectAll('tspan'),
+                    expectedTickTexts = ['this is a very long tick text', 'on category axis'];
+                expect(tspans.size()).toBe(2);
+                tspans.each(function (d, i) {
+                    var tspan = d3.select(this);
+                    expect(tspan.text()).toBe(expectedTickTexts[i]);
+                });
+            });
+
+        });
+    });
+
+    describe('axis.x.tick.rotate', function () {
+
+        describe('not rotated', function () {
+
+            it('should update args successfully', function () {
+                args = {
+                    data: {
+                        x: 'x',
+                        columns: [
+                            ['x', 'category 1', 'category 2', 'category 3', 'category 4', 'category 5', 'category 6'],
+                            ['data1', 30, 200, 100, 400, 150, 250],
+                            ['data2', 50, 20, 10, 40, 15, 25]
+                        ]
+                    },
+                    axis: {
+                        x: {
+                            type: 'category',
+                            tick: {
+                                rotate: 60
+                            }
+                        }
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should rotate tick texts', function () {
+                chart.internal.main.selectAll('.c3-axis-x g.tick').each(function () {
+                    var tick = d3.select(this),
+                        text = tick.select('text'),
+                        tspan = text.select('tspan');
+                    expect(text.attr('transform')).toBe('rotate(60)');
+                    expect(text.attr('y')).toBe('1.5');
+                    expect(tspan.attr('dx')).toBe('6.928203230275509');
+                });
+            });
+
+            it('should have automatically calculated x axis height', function () {
+                var box = chart.internal.main.select('.c3-axis-x').node().getBoundingClientRect();
+                expect(box.height).toBeGreaterThan(50);
+            });
+
+        });
+    });
+
+    describe('axis.x.tick.fit', function () {
+
+        describe('axis.x.tick.fit = true', function () {
+
+            it('should set args for indexed data', function () {
+                args = {
+                    data: {
+                        columns: [
+                            ['data1', 30, 200, 100, 400, 150, 250],
+                            ['data2', 50, 20, 10, 40, 15, 25],
+                            ['data3', 150, 120, 110, 140, 115, 125]
+                        ]
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should show fitted ticks on indexed data', function () {
+                var ticks = chart.internal.main.selectAll('.c3-axis-x g.tick');
+                expect(ticks.size()).toBe(6);
+            });
+
+            it('should set args for x-based data', function () {
+                args = {
+                    data: {
+                        x: 'x',
+                        columns: [
+                            ['x', 10, 20, 100, 110, 200, 1000],
+                            ['data1', 30, 200, 100, 400, 150, 250],
+                            ['data2', 50, 20, 10, 40, 15, 25],
+                            ['data3', 150, 120, 110, 140, 115, 125]
+                        ]
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should show fitted ticks on indexed data', function () {
+                var ticks = chart.internal.main.selectAll('.c3-axis-x g.tick');
+                expect(ticks.size()).toBe(6);
+            });
+
+            it('should show fitted ticks after hide and show', function () {
+                chart.hide();
+                chart.show();
+                var ticks = chart.internal.main.selectAll('.c3-axis-x g.tick');
+                expect(ticks.size()).toBe(6);
+            });
+
+        });
+
+        describe('axis.x.tick.fit = false', function () {
+
+            it('should set args for indexed data', function () {
+                args = {
+                    data: {
+                        columns: [
+                            ['data1', 30, 200, 100, 400, 150, 250],
+                            ['data2', 50, 20, 10, 40, 15, 25],
+                            ['data3', 150, 120, 110, 140, 115, 125]
+                        ]
+                    },
+                    axis: {
+                        x: {
+                            tick: {
+                                fit: false
+                            }
+                        }
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should show fitted ticks on indexed data', function () {
+                var ticks = chart.internal.main.selectAll('.c3-axis-x g.tick');
+                expect(ticks.size()).toBe(11);
+            });
+
+            it('should set args for x-based data', function () {
+                args.data = {
+                    x: 'x',
+                    columns: [
+                        ['x', 10, 20, 100, 110, 200, 1000],
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                        ['data2', 50, 20, 10, 40, 15, 25],
+                        ['data3', 150, 120, 110, 140, 115, 125]
+                    ]
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should show fitted ticks on indexed data', function () {
+                var ticks = chart.internal.main.selectAll('.c3-axis-x g.tick');
+                expect(ticks.size()).toBe(10);
+            });
+
+            it('should show fitted ticks after hide and show', function () {
+                chart.hide();
+                chart.show();
+                var ticks = chart.internal.main.selectAll('.c3-axis-x g.tick');
+                expect(ticks.size()).toBe(10);
+            });
+
+        });
+    });
+
+    describe('axis.y.inner', function () {
+
+        it('should update args', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                        ['data2', 50, 20, 10, 40, 15, 25]
+                    ]
+                },
+                axis: {
+                    y: {
+                        inner: false
+                    }
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should not have inner y axis', function () {
+            var paddingLeft = chart.internal.getCurrentPaddingLeft(),
+                tickTexts = chart.internal.main.selectAll('.c3-axis-y g.tick text');
+            expect(paddingLeft).toBe(50);
+            tickTexts.each(function () {
+                expect(+d3.select(this).attr('x')).toBeLessThan(0);
+            });
+        });
+
+        it('should update args to have inner y axis', function () {
+            args.axis.y.inner = true;
+            expect(true).toBeTruthy();
+        });
+
+        it('should have inner y axis', function () {
+            var paddingLeft = chart.internal.getCurrentPaddingLeft(),
+                tickTexts = chart.internal.main.selectAll('.c3-axis-y g.tick text');
+            expect(paddingLeft).toBe(1);
+            tickTexts.each(function () {
+                expect(+d3.select(this).attr('x')).toBeGreaterThan(0);
+            });
+        });
+
+    });
+
+    describe('axis.y2.inner', function () {
+
+        it('should update args', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                        ['data2', 50, 20, 10, 40, 15, 25]
+                    ]
+                },
+                axis: {
+                    y2: {
+                        show: true,
+                        inner: false
+                    }
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should not have inner y axis', function () {
+            var paddingRight = chart.internal.getCurrentPaddingRight(),
+                tickTexts = chart.internal.main.selectAll('.c3-axis-2y g.tick text');
+            expect(paddingRight).toBeGreaterThan(39);
+            tickTexts.each(function () {
+                expect(+d3.select(this).attr('x')).toBeGreaterThan(0);
+            });
+        });
+
+        it('should update args to have inner y axis', function () {
+            args.axis.y2.inner = true;
+            expect(true).toBeTruthy();
+        });
+
+        it('should have inner y axis', function () {
+            var paddingRight = chart.internal.getCurrentPaddingRight(),
+                tickTexts = chart.internal.main.selectAll('.c3-axis-2y g.tick text');
+            expect(paddingRight).toBe(2);
+            tickTexts.each(function () {
+                expect(+d3.select(this).attr('x')).toBeLessThan(0);
+            });
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/c3-helper.js

@@ -0,0 +1,43 @@
+function initDom() {
+    'use strict';
+
+    var div = document.createElement('div');
+    div.id = 'chart';
+    div.style.width = '640px';
+    div.style.height = '480px';
+    document.body.appendChild(div);
+    document.body.style.margin = '0px';
+}
+typeof initDom !== 'undefined';
+
+function setMouseEvent(chart, name, x, y, element) {
+    'use strict';
+
+    var paddingLeft = chart.internal.main.node().transform.baseVal.getItem(0).matrix.e,
+        event = document.createEvent("MouseEvents");
+    event.initMouseEvent(name, true, true, window,
+                       0, 0, 0, x + paddingLeft, y + 5,
+                       false, false, false, false, 0, null);
+    chart.internal.d3.event = event;
+    if (element) { element.dispatchEvent(event); }
+}
+typeof setMouseEvent !== 'undefined';
+
+function initChart(chart, args, done) {
+    'use strict';
+
+    if (typeof chart === 'undefined') {
+        window.initDom();
+    }
+    chart = window.c3.generate(args);
+    chart.internal.d3.select('.jasmine_html-reporter')
+        .style('position', 'absolute')
+        .style('right', 0);
+
+    window.setTimeout(function () {
+        done();
+    }, 10);
+
+    return chart;
+}
+typeof initChart !== 'undefined';

libraries/framework/vendor/plugins/c3charts/spec/c3-spec.js

@@ -0,0 +1,15 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it;
+
+describe('c3', function () {
+    'use strict';
+
+    var c3 = window.c3;
+
+    it('exists', function () {
+        expect(c3).not.toBeNull();
+        expect(typeof c3).toBe('object');
+    });
+});
+

libraries/framework/vendor/plugins/c3charts/spec/class-spec.js

@@ -0,0 +1,67 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart class', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2 prefix', 50, 20, 10, 40, 15, 25],
+                ['data3 мужчины', 150, 120, 110, 140, 115, 125]
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('internal.getTargetSelectorSuffix', function () {
+
+        it('should not replace any characters', function () {
+            var input = 'data1',
+                expected = '-' + input,
+                suffix = chart.internal.getTargetSelectorSuffix(input);
+            expect(suffix).toBe(expected);
+        });
+
+        it('should replace space to "-"', function () {
+            var input = 'data1 suffix',
+                expected = '-data1-suffix',
+                suffix = chart.internal.getTargetSelectorSuffix(input);
+            expect(suffix).toBe(expected);
+        });
+
+        it('should replace space to "-" with multibyte characters', function () {
+            var input = 'data1 suffix 日本語',
+                expected = '-data1-suffix-日本語',
+                suffix = chart.internal.getTargetSelectorSuffix(input);
+            expect(suffix).toBe(expected);
+        });
+
+        it('should replace special charactors to "-"', function () {
+            var input = 'data1 !@#$%^&*()_=+,.<>"\':;[]/|?~`{}\\',
+                expected = '-data1--------------------------------',
+                suffix = chart.internal.getTargetSelectorSuffix(input);
+            expect(suffix).toBe(expected);
+        });
+
+    });
+
+    describe('multibyte characters on chart', function () {
+
+        it('should replace space to "-" with multibyte characters', function () {
+            var selector = '.c3-target-data3-мужчины';
+            expect(chart.internal.main.select(selector).size()).toBe(1);
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/core-spec.js

@@ -0,0 +1,118 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', 150, 120, 110, 140, 115, 125]
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('init', function () {
+
+        it('should be created', function () {
+            var svg = d3.select('#chart svg');
+            expect(svg).not.toBeNull();
+        });
+
+        it('should set 3rd party property to Function', function () {
+            Function.prototype.$extIsFunction = true;
+            expect(true).toBeTruthy();
+        });
+
+        it('should be created even if 3rd party property has been set', function () {
+            var svg = d3.select('#chart svg');
+            expect(svg).not.toBeNull();
+        });
+
+    });
+
+    describe('size', function () {
+
+        it('should have same width', function () {
+            var svg = d3.select('#chart svg');
+            expect(+svg.attr('width')).toBe(640);
+        });
+
+        it('should have same height', function () {
+            var svg = d3.select('#chart svg');
+            expect(+svg.attr('height')).toBe(480);
+        });
+
+    });
+
+    describe('bindto', function () {
+
+        it('should accept d3.selection object', function () {
+            args.bindto = d3.select('#chart');
+            expect(true).toBeTruthy();
+        });
+
+        it('should be created', function () {
+            var svg = d3.select('#chart svg');
+            expect(svg).not.toBeNull();
+        });
+
+    });
+
+    describe('empty data', function () {
+
+        it('should upaate args for empty data', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1'],
+                        ['data2']
+                    ]
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should generate a chart', function () {
+            var ticks = chart.internal.main.select('.c3-axis-x').selectAll('g.tick');
+            expect(ticks.size()).toBe(0);
+        });
+
+        it('should upaate args for empty data', function () {
+            args = {
+                data: {
+                    x: 'x',
+                    columns: [
+                        ['x'],
+                        ['data1'],
+                        ['data2']
+                    ]
+                },
+                axis: {
+                    x: {
+                        type: 'timeseries'
+                    }
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should generate a chart', function () {
+            var ticks = chart.internal.main.select('.c3-axis-x').selectAll('g.tick');
+            expect(ticks.size()).toBe(0);
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/data-spec.js

@@ -0,0 +1,831 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart data', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', 150, 120, 110, 140, 115, 125]
+            ],
+            order: function () {
+                return 0;
+            }
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('function in data.order', function () {
+        it('should return false in isOrderAsc and isOrderDesc functions', function () {
+            expect(chart.internal.isOrderAsc() || chart.internal.isOrderDesc()).toBe(false);
+        });
+    });
+
+    describe('data.xs', function () {
+
+        describe('normal x', function () {
+ 
+            it('should have correct number of xs for each', function () {
+                expect(Object.keys(chart.internal.data.xs).length).toBe(3);
+                expect(chart.internal.data.xs.data1.length).toBe(6);
+                expect(chart.internal.data.xs.data2.length).toBe(6);
+                expect(chart.internal.data.xs.data3.length).toBe(6);
+            });
+
+            it('should have integer index as x', function () {
+                for (var i = 0; i < chart.internal.data.xs.data3.length; i++) {
+                    expect(chart.internal.data.xs.data1[i]).toBe(i);
+                    expect(chart.internal.data.xs.data2[i]).toBe(i);
+                    expect(chart.internal.data.xs.data3[i]).toBe(i);
+                }
+            });
+
+        });
+
+        describe('timeseries x', function () {
+            it('should load timeseries data successfully', function () {
+                args = {
+                    data: {
+                        x : 'date',
+                        columns: [
+                            ['date', '2013-01-01', '2013-01-02', '2013-01-03'],
+                            ['data1', 30, 200, 100],
+                            ['data2', 130, 300, 200]
+                        ]
+                    },
+                    axis : {
+                        x : {
+                            type : 'timeseries'
+                        }
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should have correct number of xs', function () {
+                expect(Object.keys(chart.internal.data.xs).length).toBe(2);
+                expect(chart.internal.data.xs.data1.length).toBe(3);
+                expect(chart.internal.data.xs.data2.length).toBe(3);
+            });
+
+            it('should have Date object as x', function () {
+                var xs = chart.internal.data.xs;
+                expect(+xs.data1[0]).toBe(+new Date(2013, 0, 1, 0, 0, 0));
+                expect(+xs.data1[1]).toBe(+new Date(2013, 0, 2, 0, 0, 0));
+                expect(+xs.data1[2]).toBe(+new Date(2013, 0, 3, 0, 0, 0));
+                expect(+xs.data2[0]).toBe(+new Date(2013, 0, 1, 0, 0, 0));
+                expect(+xs.data2[1]).toBe(+new Date(2013, 0, 2, 0, 0, 0));
+                expect(+xs.data2[2]).toBe(+new Date(2013, 0, 3, 0, 0, 0));
+            });
+        });
+
+        describe('milliseconds timeseries x', function () {
+
+            describe('as date string', function () {
+
+                it('should update args', function () {
+                    args = {
+                        data: {
+                            x : 'date',
+                            xFormat: '%Y-%m-%d %H:%M:%S.%L',
+                            columns: [
+                                ['date', "2014-05-20 17:25:00.123", "2014-05-20 17:30:00.345"],
+                                ['data1', 30, 200],
+                                ['data2', 130, 300]
+                            ]
+                        },
+                        axis: {
+                            x: {
+                                type: 'timeseries',
+                                tick: {
+                                    format: '%Y-%m-%d %H:%M:%S.%L',
+                                    multiline: false
+                                }
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have correct number of xs', function () {
+                    expect(Object.keys(chart.internal.data.xs).length).toBe(2);
+                    expect(chart.internal.data.xs.data1.length).toBe(2);
+                    expect(chart.internal.data.xs.data2.length).toBe(2);
+                });
+
+                it('should have Date object as x', function () {
+                    var xs = chart.internal.data.xs;
+                    expect(+xs.data1[0]).toBe(+new Date(2014, 4, 20, 17, 25, 0, 123));
+                    expect(+xs.data1[1]).toBe(+new Date(2014, 4, 20, 17, 30, 0, 345));
+                    expect(+xs.data2[0]).toBe(+new Date(2014, 4, 20, 17, 25, 0, 123));
+                    expect(+xs.data2[1]).toBe(+new Date(2014, 4, 20, 17, 30, 0, 345));
+                });
+
+                it('should have milliseconds tick format', function () {
+                    var expected = ["2014-05-20 17:25:00.123", "2014-05-20 17:30:00.345"];
+                    chart.internal.main.selectAll('.c3-axis-x g.tick text').each(function (d, i) {
+                        expect(d3.select(this).text()).toBe(expected[i]);
+                    });
+                });
+
+            });
+
+            describe('as unixtime number', function () {
+
+                it('should update args', function () {
+                    args = {
+                        data: {
+                            x : 'date',
+                            columns: [
+                                ['date', 1417622461123, 1417622522345],
+                                ['data1', 30, 200],
+                                ['data2', 130, 300]
+                            ]
+                        },
+                        axis: {
+                            x: {
+                                type: 'timeseries',
+                                tick: {
+                                    format: '%Y-%m-%d %H:%M:%S.%L'
+                                }
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have correct number of xs', function () {
+                    expect(Object.keys(chart.internal.data.xs).length).toBe(2);
+                    expect(chart.internal.data.xs.data1.length).toBe(2);
+                    expect(chart.internal.data.xs.data2.length).toBe(2);
+                });
+
+                it('should have Date object as x', function () {
+                    var xs = chart.internal.data.xs;
+                    expect(+xs.data1[0]).toBe(+new Date(2014, 11, 3, 16, 1, 1, 123));
+                    expect(+xs.data1[1]).toBe(+new Date(2014, 11, 3, 16, 2, 2, 345));
+                    expect(+xs.data2[0]).toBe(+new Date(2014, 11, 3, 16, 1, 1, 123));
+                    expect(+xs.data2[1]).toBe(+new Date(2014, 11, 3, 16, 2, 2, 345));
+                });
+            });
+
+            describe('as unixtime string', function () {
+
+                it('should upate args', function () {
+                    args = {
+                        data: {
+                            x : 'date',
+                            columns: [
+                                ['date', "1417622461123", "1417622522345"],
+                                ['data1', 30, 200],
+                                ['data2', 130, 300]
+                            ]
+                        },
+                        axis: {
+                            x: {
+                                type: 'timeseries',
+                                tick: {
+                                    format: '%Y-%m-%d %H:%M:%S.%L',
+                                    multiline: false
+                                }
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have correct number of xs', function () {
+                    expect(Object.keys(chart.internal.data.xs).length).toBe(2);
+                    expect(chart.internal.data.xs.data1.length).toBe(2);
+                    expect(chart.internal.data.xs.data2.length).toBe(2);
+                });
+
+                it('should have Date object as x', function () {
+                    var xs = chart.internal.data.xs;
+                    expect(+xs.data1[0]).toBe(+new Date(2014, 11, 3, 16, 1, 1, 123));
+                    expect(+xs.data1[1]).toBe(+new Date(2014, 11, 3, 16, 2, 2, 345));
+                    expect(+xs.data2[0]).toBe(+new Date(2014, 11, 3, 16, 1, 1, 123));
+                    expect(+xs.data2[1]).toBe(+new Date(2014, 11, 3, 16, 2, 2, 345));
+                });
+
+            });
+
+        });
+
+    });
+
+    describe('data.label', function () {
+
+        describe('with small values', function () {
+
+            it('should update args to show data label', function () {
+                args = {
+                    data: {
+                        columns: [
+                            ['data1', 0.03, 0.2, 0.1, 0.4, 0.15, 0.250]
+                        ],
+                        labels: true
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should have proper y domain', function () {
+                var domain = chart.internal.y.domain();
+                expect(domain[0]).toBeCloseTo(-0.02);
+                expect(domain[1]).toBeCloseTo(0.45);
+            });
+        });
+
+        describe('with positive values and null', function () {
+
+            describe('on not rotated axis', function () {
+
+                it('should update args', function () {
+                    args = {
+                        data: {
+                            columns: [
+                                ['data1', 190, 200, 190, null],
+                            ],
+                            type: 'bar',
+                            labels: {
+                                format: function (v) {
+                                    if (v === null) {
+                                        return 'Not Applicable';
+                                    }
+                                    return d3.format('$')(v);
+                                }
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(0, -1);
+                    expect(domain[1]).toBeCloseTo(227, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [67, 49, 67, 423],
+                        expectedXs = [74, 221, 368, 515];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(189, -1);
+                    expect(domain[1]).toBeCloseTo(201, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [375, 40, 375, 422],
+                        expectedXs = [6, 198, 391, 583];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+            });
+
+            describe('on rotated axis', function () {
+
+                it('should update args', function () {
+                    args.data.type = 'bar';
+                    args.axis = {
+                        rotated: true
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(0, -1);
+                    expect(domain[1]).toBeCloseTo(231, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [57, 163, 269, 375],
+                        expectedXs = [490, 516, 490, 4];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(188, -1);
+                    expect(domain[1]).toBeCloseTo(202, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [9, 147, 286, 424],
+                        expectedXs = [76, 526, 76, 4];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+            });
+
+        });
+
+        describe('with positive values and null', function () {
+
+            describe('on not rotated axis', function () {
+
+                it('should update args', function () {
+                    args = {
+                        data: {
+                            columns: [
+                                ['data1', -190, -200, -190, null],
+                            ],
+                            type: 'bar',
+                            labels: {
+                                format: function (v) {
+                                    if (v === null) {
+                                        return 'Not Applicable';
+                                    }
+                                    return d3.format('$')(v);
+                                }
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-227, -1);
+                    expect(domain[1]).toBeCloseTo(0, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [368, 387, 368, 12],
+                        expectedXs = [74, 221, 368, 515];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-201, -1);
+                    expect(domain[1]).toBeCloseTo(-189, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [58, 392, 58, 12],
+                        expectedXs = [6, 198, 391, 583];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+            });
+
+            describe('on rotated axis', function () {
+
+                it('should update args', function () {
+                    args.data.type = 'bar';
+                    args.axis = {
+                        rotated: true
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-232, -1);
+                    expect(domain[1]).toBeCloseTo(0, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [57, 163, 269, 375],
+                        expectedXs = [103, 78, 103, 526];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-202, -1);
+                    expect(domain[1]).toBeCloseTo(-188, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [9, 147, 286, 424],
+                        expectedXs = [511, 67, 511, 526];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+            });
+
+        });
+
+        describe('with positive and negative values and null', function () {
+
+            describe('on non rotated axis', function () {
+
+                it('should update args', function () {
+                    args = {
+                        data: {
+                            columns: [
+                                ['data1', -190, 200, 190, null],
+                            ],
+                            type: 'bar',
+                            labels: {
+                                format: function (v) {
+                                    if (v === null) {
+                                        return 'Not Applicable';
+                                    }
+                                    return d3.format('$')(v);
+                                }
+                            }
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-243, -1);
+                    expect(domain[1]).toBeCloseTo(253, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [392, 43, 52, 215],
+                        expectedXs = [74, 221, 368, 515];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-243, -1);
+                    expect(domain[1]).toBeCloseTo(253, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [392, 40, 49, 212],
+                        expectedXs = [6, 198, 391, 583];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+            });
+
+            describe('on rotated axis', function () {
+
+                it('should update args', function () {
+                    args.data.type = 'bar';
+                    args.axis = {
+                        rotated: true
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-254, -1);
+                    expect(domain[1]).toBeCloseTo(260, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [57, 163, 269, 375],
+                        expectedXs = [69, 525, 513, 295];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-254, -1);
+                    expect(domain[1]).toBeCloseTo(260, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [9, 147, 286, 424],
+                        expectedXs = [67, 527, 515, 297];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+            });
+
+        });
+
+        describe('with positive grouped values', function () {
+
+            describe('on non rotated axis', function () {
+
+                it('should update args', function () {
+                    args = {
+                        data: {
+                            columns: [
+                                ['data1', 30, 200, 100, 500],
+                                ['data2', 50, 20, 10, 40],
+                                ['data3', 250, 220, 210, 240],
+                            ],
+                            groups: [['data1', 'data2', 'data3']],
+                            labels: true,
+                            type: 'bar',
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(0, -1);
+                    expect(domain[1]).toBeCloseTo(885, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [385, 317, 370, 164],
+                        expectedXs = [74, 221, 368, 515];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-94, -1);
+                    expect(domain[1]).toBeCloseTo(884, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [344, 284, 331, 144],
+                        expectedXs = [6, 198, 391, 583];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+            });
+
+            describe('on rotated axis', function () {
+
+                it('should update args', function () {
+                    args.data.type = 'bar';
+                    args.axis = {
+                        rotated: true
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(0, -1);
+                    expect(domain[1]).toBeCloseTo(888, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [57, 163, 269, 375],
+                        expectedXs = [57, 150, 77, 363];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-87, -1);
+                    expect(domain[1]).toBeCloseTo(887, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [9, 147, 286, 424],
+                        expectedXs = [107, 192, 125, 386];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+            });
+
+        });
+
+        describe('with negative grouped values', function () {
+
+            describe('on non rotated axis', function () {
+
+                it('should update args', function () {
+                    args = {
+                        data: {
+                            columns: [
+                                ['data1', -30, -200, -100, -500],
+                                ['data2', -50, -20, -10, -40],
+                                ['data3', -250, -220, -210, -240]
+                            ],
+                            groups: [['data1', 'data2', 'data3']],
+                            labels: true,
+                            type: 'bar',
+                        }
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-885, -1);
+                    expect(domain[1]).toBeCloseTo(0, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [51, 118, 65, 272],
+                        expectedXs = [74, 221, 368, 515];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-884, -1);
+                    expect(domain[1]).toBeCloseTo(94, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [88, 149, 101, 288],
+                        expectedXs = [6, 198, 391, 583];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+            });
+
+            describe('on rotated axis', function () {
+
+                it('should update args', function () {
+                    args.data.type = 'bar';
+                    args.axis = {
+                        rotated: true
+                    };
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-894, -1);
+                    expect(domain[1]).toBeCloseTo(0, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [57, 163, 269, 375],
+                        expectedXs = [533, 440, 513, 230];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+
+                it('should update args', function () {
+                    args.data.type = 'line';
+                    expect(true).toBeTruthy();
+                });
+
+                it('should have y domain with proper padding', function () {
+                    var domain = chart.internal.y.domain();
+                    expect(domain[0]).toBeCloseTo(-894, -1);
+                    expect(domain[1]).toBeCloseTo(94, -1);
+                });
+
+                it('should locate labels above each data point', function () {
+                    var texts = chart.internal.main.selectAll('.c3-texts-data1 text'),
+                        expectedYs = [9, 147, 286, 424],
+                        expectedXs = [480, 397, 462, 205];
+                    texts.each(function (d, i) {
+                        var text = d3.select(this);
+                        expect(+text.attr('y')).toBeCloseTo(expectedYs[i], -2);
+                        expect(+text.attr('x')).toBeCloseTo(expectedXs[i], -2);
+                    });
+                });
+            });
+
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/domain-spec.js

@@ -0,0 +1,116 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart axis', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25]
+            ]
+        },
+        axis: {
+            y: {},
+            y2: {}
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('axis.y.min', function () {
+
+        it('should change axis.y.min to -100', function () {
+            args.axis.y.min = -100;
+            expect(true).toBeTruthy();
+        });
+
+        it('should be set properly when smaller than max of data', function () {
+            var domain = chart.internal.y.domain();
+            expect(domain[0]).toBe(-150);
+            expect(domain[1]).toBe(450);
+        });
+
+        it('should change axis.y.min to 500', function () {
+            args.axis.y.min = 500;
+            expect(true).toBeTruthy();
+        });
+
+        it('should be set properly when bigger than max of data', function () {
+            var domain = chart.internal.y.domain();
+            expect(domain[0]).toBe(499);
+            expect(domain[1]).toBe(511);
+        });
+
+        it('should change axis.y.min to undefined', function () {
+            args.axis.y.min = undefined;
+            expect(true).toBeTruthy();
+        });
+
+    });
+
+    describe('axis.y.max', function () {
+
+        it('should change axis.y.max to 1000', function () {
+            args.axis.y.max = 1000;
+            expect(true).toBeTruthy();
+        });
+
+        it('should be set properly when bigger than min of data', function () {
+            var domain = chart.internal.y.domain();
+            expect(domain[0]).toBe(-89);
+            expect(domain[1]).toBe(1099);
+        });
+
+        it('should change axis.y.max to 0', function () {
+            args.axis.y.max = 0;
+            expect(true).toBeTruthy();
+        });
+
+        it('should be set properly when smaller than min of data', function () {
+            var domain = chart.internal.y.domain();
+            expect(domain[0]).toBe(-11);
+            expect(domain[1]).toBe(1);
+        });
+
+    });
+
+    describe('axis.y.padding', function () {
+
+        it('should change axis.y.max to 1000', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 10, 20, 10, 40, 15, 25],
+                        ['data2', 50, 40, 30, 45, 25, 45]
+                    ]
+                },
+                axis: {
+                    y: {
+                        padding: {
+                            top: 200,
+                            bottom: 200
+                        }
+                    }
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should be set properly when bigger than min of data', function () {
+            var domain = chart.internal.y.domain();
+            expect(domain[0]).toBeCloseTo(-9, -1);
+            expect(domain[1]).toBeCloseTo(69, -1);
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/grid-spec.js

@@ -0,0 +1,131 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart grid', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250]
+            ]
+        },
+        axis: {
+            y: {
+                tick: {
+                }
+            }
+        },
+        grid: {
+            y: {
+                show: false
+            }
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('y grid', function () {
+
+        it('should not show y grids', function () {
+            expect(chart.internal.main.select('.c3-ygrids').size()).toBe(0);
+        });
+
+        it('should update args to show y grids', function () {
+            args.grid.y.show = true;
+            expect(true).toBeTruthy();
+        });
+
+        it('should show y grids', function () {
+            var ygrids = chart.internal.main.select('.c3-ygrids');
+            expect(ygrids.size()).toBe(1);
+            expect(ygrids.selectAll('.c3-ygrid').size()).toBe(9);
+        });
+
+        it('should update args to show only 3 y grids', function () {
+            args.grid.y.ticks = 3;
+            expect(true).toBeTruthy();
+        });
+
+        it('should show only 3 y grids', function () {
+            var ygrids = chart.internal.main.select('.c3-ygrids');
+            expect(ygrids.size()).toBe(1);
+            expect(ygrids.selectAll('.c3-ygrid').size()).toBe(3);
+        });
+
+        it('should update args to show y grids depending on y axis ticks', function () {
+            args.axis.y.tick.count = 5;
+            expect(true).toBeTruthy();
+        });
+
+        it('should show grids depending on y axis ticks', function () {
+            var ygrids = chart.internal.main.select('.c3-ygrids'),
+                expectedYs = [];
+            ygrids.selectAll('.c3-ygrid').each(function (d, i) {
+                expectedYs[i] = +d3.select(this).attr('y1');
+            });
+            expect(ygrids.size()).toBe(1);
+            expect(ygrids.selectAll('.c3-ygrid').size()).toBe(5);
+            chart.internal.main.select('.c3-axis-y').selectAll('.tick').each(function (d, i) {
+                var t = d3.transform(d3.select(this).attr('transform'));
+                expect(t.translate[1]).toBe(expectedYs[i]);
+            });
+        });
+
+    });
+
+    describe('x grid lines', function () {
+
+        describe('on category axis', function () {
+
+            it('should update args', function () {
+                args = {
+                    data: {
+                        x: 'x',
+                        columns: [
+                            ['x', 'a', 'b', 'c', 'd'],
+                            ['data1', 30, 200, 100, 400],
+                        ]
+                    },
+                    axis: {
+                        x: {
+                            type: 'category'
+                        }
+                    },
+                    grid: {
+                        x: {
+                            lines: [
+                                {value: 3, text: 'Label 3'},
+                                {value: 'a', text: 'Label a'}
+                            ]
+                        }
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should show x grid lines', function () {
+                var lines = chart.internal.main.selectAll('.c3-xgrid-lines .c3-xgrid-line'),
+                    expectedX1 = [515, 74],
+                    expectedText = ['Label 3', 'Label a'];
+                lines.each(function (id, i) {
+                    var line = d3.select(this),
+                        l = line.select('line'),
+                        t = line.select('text');
+                    expect(+l.attr('x1')).toBeCloseTo(expectedX1[i], -1);
+                    expect(t.text()).toBe(expectedText[i]);
+                });
+            });
+
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/interaction-spec.js

@@ -0,0 +1,132 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart interaction', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', 150, 120, 110, 140, 115, 125]
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('generate event rects', function () {
+
+        describe('custom x', function () {
+
+            it('should generate bar chart', function () {
+                args = {
+                    data: {
+                        x: 'x',
+                        columns: [
+                            ['x', 0, 1000, 3000, 10000],
+                            ['data', 10, 10, 10, 10]
+                        ],
+                        type: 'bar'
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should have 4 event rects properly', function () {
+                var lefts = [78, 138, 205.5, 407.5],
+                    widths = [60, 67.5, 202, 194];
+                d3.selectAll('.c3-event-rect').each(function (d, i) {
+                    var box = d3.select(this).node().getBoundingClientRect();
+                    expect(box.left).toBe(lefts[i]);
+                    expect(box.width).toBe(widths[i]);
+                });
+            });
+
+            it('should generate bar chart with only one data', function () {
+                args = {
+                    data: {
+                        x: 'x',
+                        columns: [
+                            ['x', 0],
+                            ['data', 10]
+                        ],
+                        type: 'bar'
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should have 1 event rects properly', function () {
+                var eventRects = d3.selectAll('.c3-event-rect');
+                expect(eventRects.size()).toBe(1);
+                eventRects.each(function () {
+                    var box = d3.select(this).node().getBoundingClientRect();
+                    expect(box.left).toBe(40.5);
+                    expect(box.width).toBe(598);
+                });
+            });
+        });
+
+        describe('timeseries', function () {
+
+            it('should generate line chart with timeseries', function () {
+                args = {
+                    data: {
+                        x: 'x',
+                        columns: [
+                            ['x', '20140101', '20140201', '20140210',  '20140301'],
+                            ['data', 10, 10, 10, 10]
+                        ]
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should have 4 event rects properly', function () {
+                var lefts = [43.5, 193, 353, 500],
+                    widths = [149.5, 160, 147, 136];
+                d3.selectAll('.c3-event-rect').each(function (d, i) {
+                    var box = d3.select(this).node().getBoundingClientRect();
+                    expect(box.left).toBe(lefts[i]);
+                    expect(box.width).toBe(widths[i]);
+                });
+
+            });
+
+            it('should generate line chart with only 1 data timeseries', function () {
+                args = {
+                    data: {
+                        x: 'x',
+                        columns: [
+                            ['x', '20140101'],
+                            ['data', 10]
+                        ]
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should have 1 event rects properly', function () {
+                var eventRects = d3.selectAll('.c3-event-rect');
+                expect(eventRects.size()).toBe(1);
+                eventRects.each(function () {
+                    var box = d3.select(this).node().getBoundingClientRect();
+                    expect(box.left).toBe(40.5);
+                    expect(box.width).toBe(598);
+                });
+            });
+
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/legend-spec.js

@@ -0,0 +1,186 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart legend', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25]
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        if (typeof chart === 'undefined') {
+            window.initDom();
+        }
+        chart = window.c3.generate(args);
+        d3 = chart.internal.d3;
+        chart.internal.d3.select('.jasmine_html-reporter')
+            .style('position', 'absolute')
+            .style('right', 0);
+
+        window.setTimeout(function () {
+            done();
+        }, 10);
+    });
+
+    describe('legend position', function () {
+
+        it('should be located on the center of chart', function () {
+            var box = chart.internal.legend.node().getBoundingClientRect();
+            expect(box.left + box.right).toBe(640);
+        });
+
+    });
+
+    describe('legend as inset', function () {
+
+        it('should change the legend to "inset" successfully', function () {
+            args.legend = {
+                position: 'inset',
+                inset: {
+                    step: null
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should be positioned properly', function () {
+            var box = d3.select('.c3-legend-background').node().getBoundingClientRect();
+            expect(box.top).toBe(5.5);
+            expect(box.left).toBe(60.5);
+        });
+
+        it('should have automatically calculated height', function () {
+            var box = d3.select('.c3-legend-background').node().getBoundingClientRect();
+            expect(box.height).toBe(48);
+        });
+
+        it('should change the legend step to 1 successfully', function () {
+            args.legend.inset.step = 1;
+            expect(true).toBeTruthy();
+        });
+
+        it('should have automatically calculated height', function () {
+            var box = d3.select('.c3-legend-background').node().getBoundingClientRect();
+            expect(box.height).toBe(28);
+        });
+
+        it('should change the legend step to 2 successfully', function () {
+            args.legend.inset.step = 2;
+            expect(true).toBeTruthy();
+        });
+
+        it('should have automatically calculated height', function () {
+            var box = d3.select('.c3-legend-background').node().getBoundingClientRect();
+            expect(box.height).toBe(48);
+        });
+
+        it('should update args to have only one series', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                    ]
+                },
+                legend: {
+                    position: 'inset'
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should locate legend properly', function () {
+            var box = d3.select('.c3-legend-background').node().getBoundingClientRect();
+            expect(box.height).toBe(28);
+            expect(box.width).toBeGreaterThan(64);
+        });
+
+    });
+
+    describe('legend.hide', function () {
+
+        it('should update args', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                        ['data2', 130, 100, 200, 100, 250, 150]
+                    ]
+                },
+                legend: {
+                    hide: true
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should not show legends', function () {
+            d3.selectAll('.c3-legend-item').each(function () {
+                expect(d3.select(this).style('visibility')).toBe('hidden');
+            });
+        });
+
+        it('should update args', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                        ['data2', 130, 100, 200, 100, 250, 150]
+                    ]
+                },
+                legend: {
+                    hide: 'data2'
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should not show legends', function () {
+            expect(d3.select('.c3-legend-item-data1').style('visibility')).toBe('visible');
+            expect(d3.select('.c3-legend-item-data2').style('visibility')).toBe('hidden');
+        });
+
+    });
+
+    describe('legend.show', function () {
+
+        it('should update args', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                        ['data2', 130, 100, 200, 100, 250, 150]
+                    ]
+                },
+                legend: {
+                    show: false
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should not initially have rendered any legend items', function () {
+            expect(d3.selectAll('.c3-legend-item').empty()).toBe(true);
+        });
+
+        it('allows us to show the legend on showLegend call', function () {
+            chart.legend.show();
+            d3.selectAll('.c3-legend-item').each(function () {
+                expect(d3.select(this).style('visibility')).toBe('visible');
+                // This selects all the children, but we expect it to be empty
+                expect(d3.select(this).selectAll("*").length).not.toEqual(0);
+            });
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/shape.bar-spec.js

@@ -0,0 +1,91 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+var setMouseEvent = window.setMouseEvent;
+
+describe('c3 chart shape bar', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, -150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', -150, 120, 110, 140, 115, 125]
+            ],
+            type: 'bar'
+        },
+        axis: {
+            rotated: false
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('internal.isWithinBar', function () {
+
+        describe('with normal axis', function () {
+
+            it('should not be within bar', function () {
+                var bar = d3.select('.c3-target-data1 .c3-bar-0').node();
+                setMouseEvent(chart, 'click', 0, 0);
+                expect(chart.internal.isWithinBar(bar)).toBeFalsy();
+            });
+
+            it('should be within bar', function () {
+                var bar = d3.select('.c3-target-data1 .c3-bar-0').node();
+                setMouseEvent(chart, 'click', 31, 280);
+                expect(chart.internal.isWithinBar(bar)).toBeTruthy();
+            });
+
+            it('should not be within bar of negative value', function () {
+                var bar = d3.select('.c3-target-data3 .c3-bar-0').node();
+                setMouseEvent(chart, 'click', 68, 280);
+                expect(chart.internal.isWithinBar(bar)).toBeFalsy();
+            });
+
+            it('should be within bar of negative value', function () {
+                var bar = d3.select('.c3-target-data3 .c3-bar-0').node();
+                setMouseEvent(chart, 'click', 68, 350);
+                expect(chart.internal.isWithinBar(bar)).toBeTruthy();
+            });
+
+        });
+
+        describe('with rotated axis', function () {
+
+            it('should change the chart as axis rotated', function () {
+                args.axis.rotated = true;
+                expect(true).toBeTruthy();
+            });
+
+            it('should not be within bar', function () {
+                var bar = d3.select('.c3-target-data1 .c3-bar-0').node();
+                setMouseEvent(chart, 'click', 0, 0);
+                expect(chart.internal.isWithinBar(bar)).toBeFalsy();
+            });
+
+            it('should be within bar', function () {
+                var bar = d3.select('.c3-target-data1 .c3-bar-0').node();
+                setMouseEvent(chart, 'click', 190, 20);
+                expect(chart.internal.isWithinBar(bar)).toBeTruthy();
+            });
+
+            it('should be within bar of negative value', function () {
+                var bar = d3.select('.c3-target-data3 .c3-bar-0').node();
+                setMouseEvent(chart, 'click', 68, 50);
+                expect(chart.internal.isWithinBar(bar)).toBeTruthy();
+            });
+
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/shape.line-spec.js

@@ -0,0 +1,102 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart shape line', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, -150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', -150, 120, 110, 140, 115, 125]
+            ],
+            type: 'line'
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('shape-rendering for line chart', function () {
+
+        it("should not have shape-rendering when it's line chart", function () {
+            d3.selectAll('.c3-line').each(function () {
+                var style = d3.select(this).style('shape-rendering');
+                expect(style).toBe('auto');
+            });
+        });
+
+        it('should chnage to step chart', function () {
+            args.data.type = 'step';
+            expect(true).toBeTruthy();
+        });
+
+        it("should have shape-rendering = crispedges when it's step chart", function () {
+            d3.selectAll('.c3-line').each(function () {
+                var style = d3.select(this).style('shape-rendering');
+                expect(style).toBe('crispedges');
+            });
+        });
+
+    });
+
+    describe('point.show option', function () {
+
+        it('should change args to include null data', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, null, 100, 400, -150, 250],
+                        ['data2', 50, 20, 10, 40, 15, 25],
+                        ['data3', -150, 120, 110, 140, 115, 125]
+                    ],
+                    type: 'line'
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should not show the circle for null', function (done) {
+            setTimeout(function () {
+                var target = chart.internal.main.select('.c3-chart-line.c3-target-data1');
+                expect(+target.select('.c3-circle-0').style('opacity')).toBe(1);
+                expect(+target.select('.c3-circle-1').style('opacity')).toBe(0);
+                expect(+target.select('.c3-circle-2').style('opacity')).toBe(1);
+                done();
+            }, 500);
+        });
+
+        it('should change args to include null data on scatter plot', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, null, 100, 400, -150, 250],
+                        ['data2', 50, 20, 10, 40, 15, 25],
+                        ['data3', -150, 120, 110, 140, 115, 125]
+                    ],
+                    type: 'scatter'
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should not show the circle for null', function (done) {
+            setTimeout(function () {
+                var target = chart.internal.main.select('.c3-chart-line.c3-target-data1');
+                expect(+target.select('.c3-circle-0').style('opacity')).toBe(0.5);
+                expect(+target.select('.c3-circle-1').style('opacity')).toBe(0);
+                expect(+target.select('.c3-circle-2').style('opacity')).toBe(0.5);
+                done();
+            }, 500);
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/tooltip-spec.js

@@ -0,0 +1,69 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart tooltip', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', 150, 120, 110, 140, 115, 125]
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('tooltip position', function () {
+
+        describe('without left margin', function () {
+
+            it('should show tooltip on proper position', function () {
+                var eventRect = d3.select('.c3-event-rect-2').node();
+                window.setMouseEvent(chart, 'mousemove', 100, 100, eventRect);
+
+                var tooltipContainer = d3.select('.c3-tooltip-container'),
+                    top = Math.floor(+tooltipContainer.style('top').replace(/px/, '')),
+                    left = Math.floor(+tooltipContainer.style('left').replace(/px/, '')),
+                    topExpected = 115,
+                    leftExpected = 307;
+                expect(top).toBe(topExpected);
+                expect(left).toBe(leftExpected);
+            });
+
+        });
+
+        describe('with left margin', function () {
+
+            it('should set left margin', function () {
+                d3.select('#chart').style('margin-left', '300px');
+                expect(true).toBeTruthy();
+            });
+
+            it('should show tooltip on proper position', function () {
+                var eventRect = d3.select('.c3-event-rect-2').node();
+                window.setMouseEvent(chart, 'mousemove', 100, 100, eventRect);
+
+                var tooltipContainer = d3.select('.c3-tooltip-container'),
+                    top = Math.floor(+tooltipContainer.style('top').replace(/px/, '')),
+                    left = Math.floor(+tooltipContainer.style('left').replace(/px/, '')),
+                    topExpected = 115,
+                    leftExpected = 307;
+                expect(top).toBe(topExpected);
+                expect(left).toBe(leftExpected);
+            });
+
+        });
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/type-spec.js

@@ -0,0 +1,140 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart types', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 150, 250],
+                ['data2', 50, 20, 10, 40, 15, 25],
+                ['data3', 150, 120, 110, 140, 115, 125]
+            ],
+            type: 'pie'
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('internal.hasArcType', function () {
+
+        describe('with data', function () {
+
+            it('should return true', function () {
+                expect(chart.internal.hasArcType()).toBeTruthy();
+            });
+
+            it('should change chart type to "bar"', function () {
+                args.data.type = 'bar';
+                expect(true).toBeTruthy();
+            });
+
+            it('should return false', function () {
+                expect(chart.internal.hasArcType()).toBeFalsy();
+            });
+
+        });
+
+        describe('with empty data', function () {
+
+            it('should update args to have empty data', function () {
+                args = {
+                    data: {
+                        columns: [],
+                        type: 'pie'
+                    }
+                };
+                expect(true).toBeTruthy();
+            });
+
+            it('should return true', function () {
+                expect(chart.internal.hasArcType()).toBeTruthy();
+            });
+
+            it('should change chart type to "bar"', function () {
+                args.data.type = 'bar';
+                expect(true).toBeTruthy();
+            });
+
+            it('should return false', function () {
+                expect(chart.internal.hasArcType()).toBeFalsy();
+            });
+
+        });
+
+    });
+
+    describe('internal.hasType', function () {
+
+        it('should update args', function () {
+            args = {
+                data: {
+                    columns: [
+                        ['data1', 30, 200, 100, 400, 150, 250],
+                        ['data2', 50, 20, 10, 40, 15, 25],
+                        ['data3', 150, 120, 110, 140, 115, 125]
+                    ],
+                    type: 'pie'
+                }
+            };
+            expect(true).toBeTruthy();
+        });
+
+        it('should return true for "pie" type', function () {
+            expect(chart.internal.hasType('pie')).toBeTruthy();
+        });
+
+        it('should return false for "line" type', function () {
+            expect(chart.internal.hasType('line')).toBeFalsy();
+        });
+
+        it('should return false for "bar" type', function () {
+            expect(chart.internal.hasType('bar')).toBeFalsy();
+        });
+
+        it('should unload successfully', function () {
+            chart.unload([]);
+            expect(true).toBeTruthy();
+        });
+
+        it('should return true for "pie" type even if no data', function () {
+            expect(chart.internal.hasType('pie')).toBeTruthy();
+        });
+
+        it('should return false for "line" type even if no data', function () {
+            expect(chart.internal.hasType('line')).toBeFalsy();
+        });
+
+        it('should return false for "bar" type even if no data', function () {
+            expect(chart.internal.hasType('bar')).toBeFalsy();
+        });
+
+        it('should change chart type to "bar" successfully', function () {
+            args.data.type = 'bar';
+            expect(true).toBeTruthy();
+        });
+
+        it('should return false for "pie" type even if no data', function () {
+            expect(chart.internal.hasType('pie')).toBeFalsy();
+        });
+
+        it('should return false for "line" type even if no data', function () {
+            expect(chart.internal.hasType('line')).toBeFalsy();
+        });
+
+        it('should return true for "bar" type even if no data', function () {
+            expect(chart.internal.hasType('bar')).toBeTruthy();
+        });
+
+
+    });
+
+});

libraries/framework/vendor/plugins/c3charts/spec/zoom-spec.js

@@ -0,0 +1,73 @@
+var describe = window.describe,
+    expect = window.expect,
+    it = window.it,
+    beforeEach = window.beforeEach;
+
+describe('c3 chart zoom', function () {
+    'use strict';
+
+    var chart, d3;
+
+    var args = {
+        data: {
+            columns: [
+                ['data1', 30, 200, 100, 400, 3150, 250],
+                ['data2', 50, 20, 10, 40, 15, 6025]
+            ]
+        },
+        axis: {
+            x: {
+                extent: [1, 2]
+            }
+        },
+        zoom: {
+            enable: true
+        },
+        subchart: {
+            show: true
+        }
+    };
+
+    beforeEach(function (done) {
+        chart = window.initChart(chart, args, done);
+        d3 = chart.internal.d3;
+    });
+
+    describe('default extent', function () {
+
+        describe('main chart domain', function () {
+
+            it('should have original y domain', function () {
+                var yDomain = chart.internal.y.domain(),
+                    expectedYDomain = [-591.5, 6626.5];
+                expect(yDomain[0]).toBe(expectedYDomain[0]);
+                expect(yDomain[1]).toBe(expectedYDomain[1]);
+            });
+
+        });
+
+        describe('main chart domain', function () {
+
+            it('should have original y domain in subchart', function () {
+                var yDomain = chart.internal.y.domain(),
+                    subYDomain = chart.internal.subY.domain();
+                expect(subYDomain[0]).toBe(yDomain[0]);
+                expect(subYDomain[1]).toBe(yDomain[1]);
+            });
+
+        });
+
+        describe('main chart domain', function () {
+
+            it('should have specified brush extent', function () {
+                var brushExtent = chart.internal.brush.extent(),
+                    expectedBrushExtent = [1, 2];
+                expect(brushExtent[0]).toBe(expectedBrushExtent[0]);
+                expect(brushExtent[1]).toBe(expectedBrushExtent[1]);
+            });
+
+        });
+
+    });
+
+});