bump 3.2.0

fix: crash when rerender #57

README.md

@@ -106,6 +106,12 @@ ReactDOM.render(<Rcslider />, container);
           <td>false</td>
           <td>Determines the type of slider. If range is `true`, two handles will be rendered in order to select a range.</td>
         </tr>
+        <tr>
+          <td>allowCross</td>
+          <td>boolean</td>
+          <td>true</td>
+          <td>When `range` is `true`, `allowCross` could be set as `true` to allow those two handles cross.</td>
+        </tr>
         <tr>
           <td>defaultValue</td>
           <td>number or [number, number]</td>
@@ -148,6 +154,18 @@ ReactDOM.render(<Rcslider />, container);
           <td>false</td>
           <td>When the `step` value is greater than 1, you can set the `dots` to  `true` if you want to render the slider with dots.</td>
         </tr>
+        <tr>
+          <td>onChange</td>
+          <td>function</td>
+          <td>NOOP</td>
+          <td>`onChange` will be triggered while the value of Slider changing.</td>
+        </tr>
+        <tr>
+          <td>onAfterChange</td>
+          <td>function</td>
+          <td>NOOP</td>
+          <td>`onAfterChange` will be triggered when `ontouchend` or `onmouseup` is triggered.</td>
+        </tr>
     </tbody>
 </table>
 

examples/marks.js

@@ -1,23 +1,21 @@
-'use strict';
-
 require('rc-slider/assets/index.less');
 
-var React = require('react');
-var ReactDOM = require('react-dom');
-var Slider = require('rc-slider');
+const React = require('react');
+const ReactDOM = require('react-dom');
+const Slider = require('rc-slider');
 
-var style = {width: 400, margin: 50};
-var marks = {
+const style = {width: 400, margin: 50};
+const marks = {
   '-10': '-10°C',
   0: '0°C',
   26: '26°C',
   37: '37°C',
-  100: '100°C'
+  100: '100°C',
 };
 
-var log = function(value) {
+function log(value) {
   console.log(value);
-};
+}
 
 ReactDOM.render(
   <div>

examples/range.js

@@ -1,38 +1,73 @@
-'use strict';
-
+/* eslint react/no-multi-comp: 0 */
 require('rc-slider/assets/index.less');
 
-var React = require('react');
-var ReactDOM = require('react-dom');
-var Slider = require('rc-slider');
+const React = require('react');
+const ReactDOM = require('react-dom');
+const Slider = require('rc-slider');
 
-var style = {width: 400, margin: 50};
-var log = function(value) {
+const style = {width: 400, margin: 50};
+
+function log(value) {
   console.log(value);
-};
+}
 
-var CustomizedRange = React.createClass({
+const CustomizedRange = React.createClass({
   getInitialState: function() {
     return {
-      value: [20, 40]
-    }
+      value: [20, 40],
+    };
   },
-  onChange: function(value) {
+  onSliderChange: function(value) {
     log(value);
     this.setState({
-      value: value
+      value: value,
     });
   },
   render: function() {
-    return <Slider range value={this.state.value} onChange={this.onChange} />;
-  }
+    return <Slider range value={this.state.value} onChange={this.onSliderChange} />;
+  },
+});
+
+const DynamicBounds = React.createClass({
+  getInitialState() {
+    return {
+      min: 0,
+      max: 100,
+    };
+  },
+  onSliderChange: function(value) {
+    log(value);
+  },
+  onMinChange: function(e) {
+    this.setState({
+      min: +e.target.value || 0,
+    });
+  },
+  onMaxChange: function(e) {
+    this.setState({
+      max: +e.target.value || 100,
+    });
+  },
+  render: function() {
+    return (
+      <div>
+        <label>Min: </label>
+        <input type="number" value={this.state.min} onChange={this.onMinChange} />
+        <br />
+        <label>Max: </label>
+        <input type="number" value={this.state.max} onChange={this.onMaxChange} />
+        <br /><br />
+        <Slider range defaultValue={[20, 50]} min={this.state.min} max={this.state.max} onChange={this.onSliderChange} />
+      </div>
+    );
+  },
 });
 
 ReactDOM.render(
   <div>
     <div style={style}>
-      <p>Basic Range</p>
-      <Slider range defaultValue={[0, 20]} onChange={log} />
+      <p>Basic Range，`allowCross=false`</p>
+      <Slider range allowCross={false} defaultValue={[0, 20]} onChange={log} />
     </div>
     <div style={style}>
       <p>Basic Range，`step=20` </p>
@@ -50,5 +85,9 @@ ReactDOM.render(
       <p>Customized Range</p>
       <CustomizedRange />
     </div>
+    <div style={style}>
+      <p>Range with dynamic `max` `min`</p>
+      <DynamicBounds />
+    </div>
   </div>
   , document.getElementById('__react-content'));

examples/slider.js

@@ -1,43 +1,78 @@
-'use strict';
-
+/* eslint react/no-multi-comp: 0 */
 require('rc-slider/assets/index.less');
 
-var React = require('react');
-var ReactDOM = require('react-dom');
-var Slider = require('rc-slider');
+const React = require('react');
+const ReactDOM = require('react-dom');
+const Slider = require('rc-slider');
 
-var style = {width: 400, margin: 50};
-var log = function(value) {
+const style = {width: 400, margin: 50};
+
+function log(value) {
   console.log(value);
-};
+}
 
 
 function percentFormatter(v) {
   return v + ' %';
 }
 
-var CustomizedSlider = React.createClass({
+const CustomizedSlider = React.createClass({
   getInitialState: function() {
     return {
-      value: 50
-    }
+      value: 50,
+    };
   },
-  onChange: function(value) {
+  onSliderChange: function(value) {
     log(value);
     this.setState({
-      value: value
+      value: value,
     });
   },
   render: function() {
-    return <Slider value={this.state.value} onChange={this.onChange} />;
-  }
+    return <Slider value={this.state.value} onChange={this.onSliderChange} />;
+  },
+});
+
+const DynamicBounds = React.createClass({
+  getInitialState: function() {
+    return {
+      min: 0,
+      max: 100,
+    };
+  },
+  onSliderChange: function(value) {
+    log(value);
+  },
+  onMinChange: function(e) {
+    this.setState({
+      min: +e.target.value || 0,
+    });
+  },
+  onMaxChange: function(e) {
+    this.setState({
+      max: +e.target.value || 100,
+    });
+  },
+  render: function() {
+    return (
+      <div>
+        <label>Min: </label>
+        <input type="number" value={this.state.min} onChange={this.onMinChange} />
+        <br />
+        <label>Max: </label>
+        <input type="number" value={this.state.max} onChange={this.onMaxChange} />
+        <br /><br />
+        <Slider defaultValue={50} min={this.state.min} max={this.state.max} onChange={this.onSliderChange} />
+      </div>
+    );
+  },
 });
 
 ReactDOM.render(
   <div>
     <div style={style}>
       <p>Basic Slider</p>
-      <Slider tipTransitionName='rc-slider-tooltip-zoom-down' onChange={log} />
+      <Slider tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log} />
     </div>
     <div style={style}>
       <p>Basic Slider，`step=20`</p>
@@ -49,7 +84,7 @@ ReactDOM.render(
     </div>
     <div style={style}>
       <p>Basic Slider with `tipFormatter`</p>
-      <Slider tipFormatter={percentFormatter} tipTransitionName='rc-slider-tooltip-zoom-down' onChange={log} />
+      <Slider tipFormatter={percentFormatter} tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log} />
     </div>
     <div style={style}>
       <p>Controlled Slider</p>
@@ -59,5 +94,9 @@ ReactDOM.render(
       <p>Customized Slider</p>
       <CustomizedSlider />
     </div>
+    <div style={style}>
+      <p>Slider with dynamic `min` `max`</p>
+      <DynamicBounds />
+    </div>
   </div>
   , document.getElementById('__react-content'));

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rc-slider",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "slider ui component for react",
   "keywords": [
     "react",
@@ -39,7 +39,6 @@
   },
   "devDependencies": {
     "expect.js": "0.3.x",
-    "jquery": "^1.11.2",
     "pre-commit": "1.x",
     "rc-server": "3.x",
     "rc-tools": "4.x",
@@ -51,6 +50,8 @@
     "lint"
   ],
   "dependencies": {
+    "classnames": "^2.2.1",
+    "object-assign": "^4.0.1",
     "rc-tooltip": "3.x",
     "rc-util": "3.x"
   }

src/Dots.jsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { classSet } from 'rc-util';
+import classNames from 'classnames';
 
 function calcPoints(marks, dots, step, min, max) {
   const points = Object.keys(marks).map(parseFloat);
@@ -19,7 +19,7 @@ const Dots = ({prefixCls, marks, dots, step, included, lowerBound, upperBound, m
 
     const isActived = (!included && point === upperBound) ||
             (included && point <= upperBound && point >= lowerBound);
-    const pointClassName = classSet({
+    const pointClassName = classNames({
       [prefixCls + '-dot']: true,
       [prefixCls + '-dot-active']: isActived,
     });

src/Marks.jsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import rcUtil from 'rc-util';
+import classNames from 'classnames';
 
 const Marks = ({className, marks, included, upperBound, lowerBound, max, min}) => {
   const marksKeys = Object.keys(marks);
@@ -11,7 +11,7 @@ const Marks = ({className, marks, included, upperBound, lowerBound, max, min}) =
   const elements = marksKeys.map(parseFloat).map((point) => {
     const isActived = (!included && point === upperBound) ||
             (included && point <= upperBound && point >= lowerBound);
-    const markClassName = rcUtil.classSet({
+    const markClassName = classNames({
       [className + '-text']: true,
       [className + '-text-active']: isActived,
     });

src/Slider.jsx

@@ -1,5 +1,7 @@
 import React from 'react';
-import {Dom as DomUtils, classSet} from 'rc-util';
+import {Dom as DomUtils} from 'rc-util';
+import classNames from 'classnames';
+import objectAssign from 'object-assign';
 import Track from './Track';
 import Handle from './Handle';
 import Dots from './Dots';
@@ -65,34 +67,48 @@ class Slider extends React.Component {
   }
 
   componentWillReceiveProps(nextProps) {
+    if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;
+
+    const {lowerBound, upperBound} = this.state;
     if (nextProps.range) {
-      const value = nextProps.value;
-      if (value) {
-        this.setState({
-          upperBound: value[1],
-          lowerBound: value[0],
-        });
-      }
-    } else if ('value' in nextProps) {
+      const value = nextProps.value || [lowerBound, upperBound];
+      const nextUpperBound = this.trimAlignValue(value[1], nextProps);
+      const nextLowerBound = this.trimAlignValue(value[0], nextProps);
+      if (nextLowerBound === lowerBound && nextUpperBound === upperBound) return;
+
       this.setState({
-        upperBound: nextProps.value,
+        upperBound: nextUpperBound,
+        lowerBound: nextLowerBound,
       });
+      if (this.isValueOutOfBounds(upperBound, nextProps) ||
+          this.isValueOutOfBounds(lowerBound, nextProps)) {
+        this.props.onChange([nextLowerBound, nextUpperBound]);
+      }
+    } else {
+      const value = 'value' in nextProps ? nextProps.value : upperBound;
+      const nextValue = this.trimAlignValue(value, nextProps);
+      if (nextValue === upperBound && lowerBound === nextProps.min) return;
+
+      this.setState({
+        upperBound: nextValue,
+        lowerBound: nextProps.min,
+      });
+      if (this.isValueOutOfBounds(upperBound, nextProps)) {
+        this.props.onChange(nextValue);
+      }
     }
   }
 
-  onChange(handle, value) {
+  onChange(state) {
     const props = this.props;
     const isNotControlled = !('value' in props);
     if (isNotControlled) {
-      this.setState({[handle]: value});
+      this.setState(state);
+    } else if (state.handle) {
+      this.setState({handle: state.handle});
     }
 
-    const state = this.state;
-    const data = {
-      upperBound: state.upperBound,
-      lowerBound: state.lowerBound,
-    };
-    data[handle] = value;
+    const data = objectAssign({}, this.state, state);
     const changedValue = props.range ? [data.lowerBound, data.upperBound] : data.upperBound;
     props.onChange(changedValue);
   }
@@ -124,7 +140,26 @@ class Slider extends React.Component {
     const oldValue = state[state.handle];
     if (value === oldValue) return;
 
-    this.onChange(state.handle, value);
+    if (props.allowCross && value < state.lowerBound && state.handle === 'upperBound') {
+      this.onChange({
+        handle: 'lowerBound',
+        lowerBound: value,
+        upperBound: this.state.lowerBound,
+      });
+      return;
+    }
+    if (props.allowCross && value > state.upperBound && state.handle === 'lowerBound') {
+      this.onChange({
+        handle: 'upperBound',
+        upperBound: value,
+        lowerBound: this.state.upperBound,
+      });
+      return;
+    }
+
+    this.onChange({
+      [state.handle]: value,
+    });
   }
 
   onTouchStart(e) {
@@ -179,7 +214,9 @@ class Slider extends React.Component {
     const oldValue = state[valueNeedChanging];
     if (value === oldValue) return;
 
-    this.onChange(valueNeedChanging, value);
+    this.onChange({
+      [valueNeedChanging]: value,
+    });
   }
 
   getValue() {
@@ -203,10 +240,24 @@ class Slider extends React.Component {
     return rect.left;
   }
 
-  trimAlignValue(v) {
+  getPrecision() {
+    const props = this.props;
+    const stepString = props.step.toString();
+    let precision = 0;
+    if (stepString.indexOf('.') >= 0) {
+      precision = stepString.length - stepString.indexOf('.') - 1;
+    }
+    return precision;
+  }
+
+  isValueOutOfBounds(value, props) {
+    return value < props.min || value > props.max;
+  }
+
+  trimAlignValue(v, nextProps) {
     const state = this.state || {};
     const {handle, lowerBound, upperBound} = state;
-    const {marks, step, min, max} = this.props;
+    const {marks, step, min, max, allowCross} = objectAssign({}, this.props, nextProps || {});
 
     let val = v;
     if (val <= min) {
@@ -215,10 +266,10 @@ class Slider extends React.Component {
     if (val >= max) {
       val = max;
     }
-    if (handle === 'upperBound' && val <= lowerBound) {
+    if (!allowCross && handle === 'upperBound' && val <= lowerBound) {
       val = lowerBound;
     }
-    if (handle === 'lowerBound' && val >= upperBound) {
+    if (!allowCross && handle === 'lowerBound' && val >= upperBound) {
       val = upperBound;
     }
 
@@ -231,7 +282,7 @@ class Slider extends React.Component {
     const diffs = points.map((point) => Math.abs(val - point));
     const closestPoint = points[diffs.indexOf(Math.min.apply(Math, diffs))];
 
-    return closestPoint;
+    return step !== null ? parseFloat(closestPoint.toFixed(this.getPrecision())) : closestPoint;
   }
 
   calcOffset(value) {
@@ -301,7 +352,7 @@ class Slider extends React.Component {
                        offset={lowerOffset} value={lowerBound} dragging={handle === 'lowerBound'} />);
     }
 
-    const sliderClassName = classSet({
+    const sliderClassName = classNames({
       [prefixCls]: true,
       [prefixCls + '-disabled']: disabled,
       [className]: !!className,
@@ -352,6 +403,7 @@ Slider.propTypes = {
   tipFormatter: React.PropTypes.func,
   dots: React.PropTypes.bool,
   range: React.PropTypes.bool,
+  allowCross: React.PropTypes.bool,
 };
 
 Slider.defaultProps = {
@@ -369,6 +421,7 @@ Slider.defaultProps = {
   disabled: false,
   dots: false,
   range: false,
+  allowCross: true,
 };
 
 export default Slider;

tests/index.spec.js

@@ -1,83 +1,127 @@
+const expect = require('expect.js');
+const React = require('react');
+const ReactDOM = require('react-dom');
+const ReactTestUtils = require('react-addons-test-utils');
+const Slider = require('..');
 
-var expect = require('expect.js');
-var Slider = require('../index.js');
-var React = require('react');
-var ReactDOM = require('react-dom');
-var TestUtils = require('react-addons-test-utils');
-var Simulate = TestUtils.Simulate;
-var $ = require('jquery');
 require('../assets/index.less');
 
-describe('rc-slider', function () {
+describe('rc-slider', function() {
   this.timeout(5000);
-  var div = document.createElement('div');
+  const div = document.createElement('div');
   document.body.appendChild(div);
 
-  afterEach(function () {
+  afterEach(() => {
     ReactDOM.unmountComponentAtNode(div);
   });
 
-  it('should render a simple slider with value correctly!', function () {
-    var slider = ReactDOM.render(
-      <Slider className='rc-slider' defaultValue={40}/>,
-      div
-    );
-    var node = $(div);
-    expect(node.find('.rc-slider').length).to.be(1);
-    expect(node.find('.rc-slider-handle').length).to.be(1);
-    expect(node.find('.rc-slider-track').length).to.be(1);
-    expect(slider.state.upperBound).to.be(40);
-    var trackWidth = node.find('.rc-slider-track')[0].style.width;
-    expect(trackWidth).to.eql(node.find('.rc-slider-handle')[0].style.left);
+  it('should render a Slider with correct DOM structure', () => {
+    const slider = ReactDOM.render(<Slider />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-handle').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-track').length).to.be(1);
   });
 
-  it('should render a slider with correct numbers of step!', function () {
-    var slider = ReactDOM.render(
-      <Slider className='rc-slider' step={20}/>,
-      div
-    );
-    var node = $(div);
-    expect(node.find('.rc-slider').length).to.be(1);
-    expect(node.find('.rc-slider-handle').length).to.be(1);
-    expect(node.find('.rc-slider-track').length).to.be(1);
-    expect(slider.state.upperBound).to.be(0);
+  it('should render a Slider with correct value and CSS style', () => {
+    const sliderWithDefaultValue = ReactDOM.render(<Slider defaultValue={50} />, div);
+    expect(sliderWithDefaultValue.state.upperBound).to.be(50);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.be('left: 50%; ');
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-track')[0]
+           .style.cssText)
+      .to.be('left: 0%; width: 50%; visibility: visible; ');
 
-    var sliderWithDots = ReactDOM.render(
-      <Slider className='rc-slider' step={20} dots/>,
-      div
-    );
-    var node1 = $(div);
-    expect(node1.find('.rc-slider-dot').length).to.be(6);
+    const sliderWithValue = ReactDOM.render(<Slider value={50} />, div);
+    expect(sliderWithValue.state.upperBound).to.be(50);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.be('left: 50%; ');
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-track')[0]
+           .style.cssText)
+      .to.be('left: 0%; width: 50%; visibility: visible; ');
   });
 
-  it('should render a slider with marks correctly!', function () {
-    var slider = ReactDOM.render(
-      <Slider marks={{0: "一", 20: "二", 40: "三", 60: "四", 100: "五"}} defaultValue={40} />,
-      div
-    );
-    var node = $(div);
-    expect(node.find('.rc-slider').length).to.be(1);
-    expect(node.find('.rc-slider-handle').length).to.be(1);
-    expect(node.find('.rc-slider-track').length).to.be(1);
-    expect(node.find('.rc-slider-dot').length).to.be(Object.keys(slider.props.marks).length);
-    expect(node.find('.rc-slider-mark').length).to.be(1);
-    expect(node.find('.rc-slider-mark-text').length).to.be(Object.keys(slider.props.marks).length);
-    expect(slider.state.upperBound).to.be(40);
+  it('should render a Range with correct DOM structure', () => {
+    const range = ReactDOM.render(<Slider range />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-handle').length).to.be(2);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-track').length).to.be(1);
   });
 
-  // it('should mouseDown works!', function (done) {
-  //   var slider = ReactDOM.render(
-  //     <Slider marks={["一","二","三","四","五"]} />,
-  //     div
-  //   );
-  //   var selectedStep = slider.refs.step3.getDOMNode();
+  it('should render a Range with correct value and CSS style', () => {
+    const sliderWithDefaultValue = ReactDOM.render(<Slider range defaultValue={[0, 50]} />, div);
+    expect(sliderWithDefaultValue.state.lowerBound).to.be(0);
+    expect(sliderWithDefaultValue.state.upperBound).to.be(50);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.be('left: 50%; ');
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[1]
+           .style.cssText)
+      .to.be('left: 0%; ');
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-track')[0]
+           .style.cssText)
+      .to.be('left: 0%; width: 50%; visibility: visible; ');
 
-  //   Simulate.mouseDown(selectedStep);
+    const sliderWithValue = ReactDOM.render(<Slider range value={[50, 100]} />, div);
+    expect(sliderWithValue.state.lowerBound).to.be(50);
+    expect(sliderWithValue.state.upperBound).to.be(100);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.be('left: 100%; ');
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[1]
+           .style.cssText)
+      .to.be('left: 50%; ');
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-track')[0]
+           .style.cssText)
+      .to.be('width: 50%; visibility: visible; left: 50%; ');
+  });
 
-  //   setTimeout( function() {
-  //     expect(slider.state.active).to.be('active');
-  //     done();
-  //   }, 200);
-  // });
+  it('should render dots correctly when `dots=true`', () => {
+    const slider = ReactDOM.render(<Slider value={50} step={10} dots />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-dot').length).to.be(11);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-dot-active').length).to.be(6);
 
+    const range = ReactDOM.render(<Slider range value={[20, 50]} step={10} dots />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-dot').length).to.be(11);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-dot-active').length).to.be(4);
+  });
+
+  it('should render marks correctly when `marks` is not an empty object', () => {
+    const marks = {0: '0', 30: '30', 100: '100'};
+
+    const slider = ReactDOM.render(<Slider value={30} marks={marks} />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-mark-text').length).to.be(3);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-mark-text')[0].innerHTML).to.be('0');
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-mark-text')[1].innerHTML).to.be('30');
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-mark-text')[2].innerHTML).to.be('100');
+
+    const range = ReactDOM.render(<Slider range value={[0, 30]} marks={marks} />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-mark-text').length).to.be(3);
+  });
+
+  it('should not set value greater than `max` or smaller `min`', () => {
+    const sliderWithMin = ReactDOM.render(<Slider value={0} min={10} />, div);
+    expect(sliderWithMin.state.upperBound).to.be(10);
+    ReactDOM.unmountComponentAtNode(div);
+
+    const sliderWithMax = ReactDOM.render(<Slider value={100} max={90} />, div);
+    expect(sliderWithMax.state.upperBound).to.be(90);
+    ReactDOM.unmountComponentAtNode(div);
+
+    const range = ReactDOM.render(<Slider range value={[0, 100]} min={10} max={90} />, div);
+    expect(range.state.lowerBound).to.be(10);
+    expect(range.state.upperBound).to.be(90);
+    ReactDOM.unmountComponentAtNode(div);
+  });
 });