diff --git a/cosmoz-omnitable-column-date-behavior.html b/cosmoz-omnitable-column-date-behavior.html
index fb7babd3..f7ffd955 100644
--- a/cosmoz-omnitable-column-date-behavior.html
+++ b/cosmoz-omnitable-column-date-behavior.html
@@ -7,16 +7,12 @@
 		properties: {
 			max: {
 				type: Date,
-				value() {
-					return new Date('2100-01-01');
-				}
+				value: null
 			},
 
 			min: {
 				type: Date,
-				value() {
-					return new Date('1970-01-01');
-				}
+				value: null
 			},
 
 			_filterText: {
diff --git a/cosmoz-omnitable-column-datetime.html b/cosmoz-omnitable-column-datetime.html
index f36ba992..ec1a12bf 100644
--- a/cosmoz-omnitable-column-datetime.html
+++ b/cosmoz-omnitable-column-datetime.html
@@ -47,20 +47,6 @@ <h3 style="margin: 0;">[[ title ]]</h3>
 					value: 1
 				},
 
-				max: {
-					type: Date,
-					value() {
-						return new Date(Date.UTC(2100, 11, 31, 20, 59, 999));
-					}
-				},
-
-				min: {
-					type: Date,
-					value() {
-						return new Date(Date.UTC(1970, 0, 1, 0, 0, 0));
-					}
-				},
-
 				width: {
 					type: String,
 					value: '210px'
diff --git a/package.json b/package.json
index 60fee1a0..e2e71735 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,7 @@
 		"start": "polymer serve -o",
 		"postinstall": "polymer install --variants",
 		"lint": "eslint --cache --ext .js,.html . && polymer lint cosmoz-*.html",
-		"test": "polymer test",
+		"test": "TZ=Europe/Bucharest polymer test",
 		"analyze": "polymer analyze --input cosmoz-*.html  > analysis.json"
 	},
 	"repository": {
diff --git a/test/index.html b/test/index.html
index da73fe1e..763703ef 100644
--- a/test/index.html
+++ b/test/index.html
@@ -11,7 +11,9 @@
 		var pages = [
 				'basic.html',
 				'hash-param.html',
-				'xlsx-export.html'
+				'xlsx-export.html',
+				'range.html',
+				'range-date.html'
 			],
 			suites = [],
 			i;
diff --git a/test/range-date.html b/test/range-date.html
new file mode 100644
index 00000000..f5a88375
--- /dev/null
+++ b/test/range-date.html
@@ -0,0 +1,374 @@
+<!doctype html>
+<html>
+<head>
+	<title>cosmoz-omnitable range tests for date, datetime, time</title>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
+
+	<script src="../../webcomponentsjs/webcomponents-lite.js"></script>
+	<script src="../../web-component-tester/browser.js"></script>
+	<script src="../../test-fixture/test-fixture-mocha.js"></script>
+
+	<link rel="import" href="../../test-fixture/test-fixture.html">
+	<link rel="import" href="../../iron-test-helpers/iron-test-helpers.html">
+
+	<link rel="import" href="../cosmoz-omnitable.html">
+	<link rel="import" href="../cosmoz-omnitable-columns.html">
+	<link rel="import" href="../demo/table-demo-behavior.html">
+</head>
+<body>
+	<test-fixture id="range">
+		<template>
+			<cosmoz-omnitable id="omnitable" class="flex">
+				<cosmoz-omnitable-column-number title="Age" name="age" value-path="age">
+				</cosmoz-omnitable-column-number>
+				<cosmoz-omnitable-column-amount title="Amount" name="amount" value-path="amount">
+				</cosmoz-omnitable-column-amount>
+				<cosmoz-omnitable-column-date title="Date" name="date" value-path="date" locale="en-US" editable>
+				</cosmoz-omnitable-column-date>
+				<cosmoz-omnitable-column-datetime title="Datetime" name="datetime" value-path="date" editable>
+				</cosmoz-omnitable-column-datetime>
+				<cosmoz-omnitable-column-time title="Time" name="time" value-path="time" editable>
+				</cosmoz-omnitable-column-time>
+			</cosmoz-omnitable>
+		</template>
+	</test-fixture>
+
+	<script>
+	/*global sinon chai flush */
+	(function () {
+		'use strict';
+		const data = [
+			{ age: 17,
+				amount: { amount: '12.4', currency: 'USD' },
+				date: '2023-03-21T00:00:00Z',
+				time: ''
+			},
+			{ amount: { amount: 2 },
+				date: new Date('2015-03-18T00:00:00Z')
+			},
+			{ age: -11,
+				amount: { amount: 678, currency: 'AUD' },
+				date: new Date(86400000), // Fri Jan 02 1970
+				time: 86400000
+			},
+			{ age: 9,
+				amount: { amount: -8, currency: 'EUR' },
+				date: new Date(99, 5, 24, 11, 33, 30, 0), // Thu Jun 24 1999 11:33:30 GMT+0300 (EEST)
+				time: '86400000'
+			},
+			{
+				age: 5,
+				amount: { amount: '3450', currency: 'DKK' },
+				date: new Date('2016-08-27'),
+				time: '2016-08-27T14:34:56Z'
+			},
+			{
+				date: '2017-12-22T23:00:00Z'
+			}
+		];
+
+		sinon.assert.expose(chai.assert, { prefix: '' });
+
+		suite('date', function () {
+			let omnitable,
+				column;
+
+			setup(function (done) {
+				omnitable = fixture('range');
+				omnitable.data = data;
+				Polymer.Base.async(function () {
+					column = omnitable.columns[2];
+					done();
+				}, 90);
+			});
+
+			test('instantiates a cosmoz-omnitable-column-date', function (done) {
+				assert.equal(column.is, 'cosmoz-omnitable-column-date');
+				done();
+			});
+
+			test('toDate converts an value to valid date', function (done) {
+				assert.equal(column.toDate('2023-03-21T00:00:00Z').getTime(), new Date('2023-03-21T00:00:00Z').getTime());
+				assert.equal(column.toDate(new Date('2015-03-18T00:00:00Z')).getTime(), new Date('2015-03-18T00:00:00Z').getTime());
+				assert.equal(column.toDate(new Date('2017-09-23T01:02:03Z')).getTime(), new Date('2017-09-23T01:02:03Z').getTime());
+				assert.equal(column.toDate(new Date(86400000)).getTime(), new Date(Date.UTC(1970, 0, 2)).getTime());
+				done();
+			});
+
+			test('toDate limits parameters', function (done) {
+				assert.equal(column.toDate('2023-03-21T00:00:00Z', '2023-03-21T00:00:00Z', Math.min).getTime(), (new Date('2023-03-21T00:00:00Z')).getTime()); // min
+				assert.equal(column.toDate(new Date('2015-03-18T00:00:00Z'), '2053-04-21T00:00:00Z', Math.min).getTime(), (new Date('2015-03-18T00:00:00Z')).getTime()); // min
+				assert.equal(column.toDate('2023-03-21T00:00:00Z', '2023-04-21T00:00:00Z', Math.max).getTime(), (new Date('2023-04-21T00:00:00Z')).getTime()); //max
+				assert.equal(column.toDate(new Date('2015-03-18T00:00:00Z'), '2017-03-18T00:00:00Z').getTime(), (new Date('2015-03-18T00:00:00Z')).getTime()); // missing limitFunc returns date
+				done();
+			});
+
+			test('date returns comparable values', function (done) {
+				assert.typeOf(column.getComparableValue('2023-03-21T00:00:00Z'), 'number');
+				assert.typeOf(column.getComparableValue(new Date('2015-03-18T00:00:00Z')), 'number');
+				assert.typeOf(column.getComparableValue(new Date(86400000)), 'number');
+				assert.equal(column.getComparableValue(new Date('2010-01-08T12:04:01Z')), 1262952241000);
+				done();
+			});
+
+			test('getString returns formated date with locale en-US', function (done) {
+				assert.equal(column.getString(), '');
+				assert.isString(column.getString(data[0], 'date'));
+				assert.isString(column.getString(data[1], 'date'));
+				assert.isString(column.getString(data[3], 'date'));
+				assert.isString(column.getString(data[4], 'date'));
+				assert.isString(column.getString(data[5], 'date'));
+				assert.equal(column.getString(data[0]), '3/21/2023');
+				assert.equal(column.getString(data[1]), '3/18/2015');
+				assert.equal(column.getString(data[3], 'date'), '6/24/1999');
+				assert.equal(column.getString(data[4]), '8/27/2016');
+				done();
+			});
+
+			test('_toLocalISOString returns formated date', function (done) {
+				assert.equal(column._toLocalISOString(new Date('2016-08-27')), '2016-08-27T03:00:00.000');
+				assert.equal(column._toLocalISOString(new Date('2015-01-03')), '2015-01-03T02:00:00.000');
+				assert.equal(column._toLocalISOString(new Date('2021-12-31')), '2021-12-31T02:00:00.000');
+				done();
+			});
+
+			test('changing filter updates _filterInput', function (done) {
+				assert.isNull(column.filter.min);
+				assert.isNull(column.filter.max);
+
+				column.filter = {
+					min: new Date('2015-03-18'),
+					max: new Date('2023-03-21')
+				};
+
+				assert.equal(column._filterInput.min, '2015-03-18', 'Expect _filterInput.min to be local ISO String');
+				assert.equal(column._filterInput.max, '2023-03-21', 'Expect _filterInput.max to be local ISO String');
+
+				assert.equal(new Date(column._filterInput.min).getTime(), column.filter.min.getTime(), 'Expect min input and filter to be equal as dates');
+				assert.equal(new Date(column._filterInput.max).getTime(), column.filter.max.getTime(), 'Expect max input and filter to be equal as dates');
+
+				done();
+			});
+
+			test('changing _filterInput updates filter', function (done) {
+				assert.isNull(column._filterInput.min);
+				assert.isNull(column._filterInput.max);
+				column._filterInput = {
+					min: '2015-03-18',
+					max: '2023-03-21'
+				};
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min.getTime(), new Date('2015-03-18T00:00:00').getTime());
+					assert.equal(column.filter.max.getTime(), new Date('2023-03-21T23:59:59').getTime(), 'Expecting max date included');
+					done();
+				}, 650);
+			});
+
+			test('changing only _filterInput min updates filter min', function (done) {
+				column._filterInput.min = '2015-08-27';
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min.getTime(), new Date('2015-08-27T00:00:00').getTime());
+					done();
+				}, 650);
+			});
+			test('filtering on specific date with datetime source', function (done) {
+				// date: '2017-12-22T23:00:00Z'
+
+				assert.equal(column.getComparableValue(data[5], column.valuePath), new Date('2017-12-22T23:00:00Z').getTime());
+
+				column._filterInput.min = '2017-12-22';
+				column._filterInput.max = '2017-12-23';
+				Polymer.Base.async(function () {
+					let fn = column.getFilterFn();
+					assert.isTrue(fn(data[5]));
+
+					done();
+				}, 650);
+			});
+
+			test('filtering on specific date with datetime source same day test', function (done) {
+				// date: '2017-12-22T23:00:00Z'
+
+				column._filterInput.min = '2017-12-23';
+				column._filterInput.max = '2017-12-23';
+				Polymer.Base.async(function () {
+					let fn = column.getFilterFn();
+					assert.isTrue(fn(data[5]));
+
+					done();
+				}, 650);
+			});
+		});
+
+		suite('datetime', function () {
+			let omnitable,
+				column;
+
+			setup(function (done) {
+				omnitable = fixture('range');
+				omnitable.data = data;
+				Polymer.Base.async(function () {
+					column = omnitable.columns[3];
+					done();
+				}, 90);
+			});
+
+			test('_toInputString converts datetime to local string', function (done) {
+				assert.equal(column._toInputString(new Date(86400000)), '1970-01-02T02:00:00');
+				assert.equal(column._toInputString(new Date('2006-07-14T07:05:39')), '2006-07-14T07:05:39');
+				assert.equal(column._toInputString(new Date('2021-12-03T09:26:04')), '2021-12-03T09:26:04');
+				assert.equal(column._toInputString(new Date('2114-04-22T04:09:00')), '2114-04-22T04:09:00');
+				done();
+			});
+
+			test('_toHashString converts datetime to UTC string replacing : with .', function (done) {
+				assert.equal(column._toHashString(new Date(86400000)), '1970-01-02T00.00.00');
+				assert.equal(column._toHashString(new Date('2021-12-03T11:26:04')), '2021-12-03T09.26.04');
+				assert.equal(column._toHashString(new Date('2016-04-22T07:09:00')), '2016-04-22T04.09.00');
+				assert.equal(column._toHashString(new Date('2017-01-16T09:19:38')), '2017-01-16T07.19.38');
+				done();
+			});
+
+			test('changing filter updates _filterInput', function (done) {
+				assert.isNull(column.filter.min);
+				assert.isNull(column.filter.max);
+				column.filter = {
+					min: new Date(86400000),
+					max: new Date(99, 5, 24, 11, 33, 30, 0)
+				};
+				assert.equal(column._filterInput.min, '1970-01-02T02:00:00');
+				assert.equal(column._filterInput.max, '1999-06-24T11:33:30');
+				done();
+			});
+
+			test('changing _filterInput updates filter', function (done) {
+				column._filterInput = {
+					min: '1970-01-02T02:00:00',
+					max: '1999-06-24T11:33:30'
+				};
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min.getTime(), 86400000);
+					assert.equal(column.filter.max.getTime(), new Date(99, 5, 24, 11, 33, 30, 0).getTime());
+					done();
+				}, 650);
+			});
+
+			test('changing only _filterInput min updates filter min', function (done) {
+				column._filterInput.min = '2014-06-24T11:33:30';
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min.getTime(), new Date('2014-06-24T11:33:30').getTime());
+					done();
+				}, 650);
+			});
+		});
+
+		suite('time', function () {
+			let omnitable,
+				column;
+
+			setup(function (done) {
+				omnitable = fixture('range');
+				omnitable.data = data;
+				Polymer.Base.async(function () {
+					column = omnitable.columns[4];
+					done();
+				}, 90);
+			});
+
+			test('instantiates a cosmoz-omnitable-column-time', function (done) {
+				assert.equal(column.is, 'cosmoz-omnitable-column-time');
+				done();
+			});
+
+			test('time toDate converts timestamp to valid date', function (done) {
+				assert.equal(column.toDate(''), null);
+				assert.equal(column.toDate(), null);
+				assert.equal(column.toDate(86400000).getTime(), new Date(Date.UTC(1970, 0, 2)).getTime());
+				assert.isNull(column.toDate('86400000'));
+				done();
+			});
+
+			test('time toDate accepts time as string and converts it to date', function (done) {
+				assert.equal(column.toDate('2016-08-27T14:34:56Z').getTime(), new Date(Date.UTC(2016, 7, 27, 14, 34, 56)).getTime());
+				done();
+			});
+
+			test('time toDate limits parameters', function (done) {
+				assert.equal(column.toDate(new Date(86400000), '2023-04-21T04:00:00Z', Math.min).getTime(), new Date(Date.UTC(1970, 0, 2)).getTime()); // min
+				assert.equal(column.toDate(new Date(86400000), '2053-04-21T11:23:32Z', Math.max).getTime(), new Date('2053-04-21T11:23:32Z').getTime()); // max
+				assert.equal(column.toDate('2016-08-27T14:34:56Z', '2023-04-21T04:00:00Z', Math.min).getTime(), new Date(Date.UTC(2023, 3, 21, 4)).getTime()); //min
+				assert.equal(column.toDate('2023-04-21T10:23:32Z', (new Date('2023-04-21T11:23:32Z')).getTime(), Math.max).getTime(), new Date('2023-04-21T11:23:32Z').getTime()); //max
+				assert.equal(column.toDate('2016-08-27T14:34:56Z', '2017-03-18T11:23:32Z').getTime(), new Date(Date.UTC(2016, 7, 27, 14, 34, 56)).getTime()); // missing limitFunc returns date
+				done();
+			});
+
+			test('time toDate accepts limit as timestamp', function (done) {
+				assert.equal(column.toDate(new Date(Date.UTC(2029, 0, 2, 17, 23, 12)).getTime(), 86400000, Math.min).getTime(), 86400000);
+				done();
+			});
+
+			test('time getComparableValue returns right value', function (done) {
+				assert.equal(column.getComparableValue(data[2], 'time'), 0, 'Expected to parse time from miliseconds timestamp as number');
+				assert.equal(column.getComparableValue(data[4], 'time'), 56096000);
+				done();
+			});
+
+			test('time _toInputString returns local ISO string', function (done) {
+				assert.equal(column._toInputString(), null);
+				assert.equal(column._toInputString(new Date(86400000)), '02:00:00');
+				assert.equal(column._toInputString('2016-08-27T14:34:56Z'), '17:34:56');
+				done();
+			});
+
+			test('time _toHashString converts time to UTC string replacing : with .', function (done) {
+				assert.equal(column._toHashString(new Date(86400000)), '00.00.00');
+				assert.equal(column._toHashString(new Date('2016-08-27T14:34:56Z')), '14.34.56');
+				assert.equal(column._toHashString(new Date('2004-11-14T06:13:06Z')), '06.13.06');
+				assert.equal(column._toHashString(new Date('2019-01-01T03:03:03Z')), '03.03.03');
+				assert.equal(column._toHashString(new Date('2014-12-07T07:25:13Z')), '07.25.13');
+				assert.equal(column._toHashString(new Date('1986-09-29T02:28:56Z')), '02.28.56');
+				done();
+			});
+
+			test('changing filter updates _filterInput', function (done) {
+				assert.isNull(column.filter.min);
+				assert.isNull(column.filter.max);
+				column.filter = {
+					min: new Date(86400000),
+					max: '2016-08-27T14:34:56Z'
+				};
+				assert.equal(column._filterInput.min, '02:00:00');
+				assert.equal(column._filterInput.max, '17:34:56');
+				done();
+			});
+
+			test('changing _filterInput updates filter', function (done) {
+				assert.isNull(column._filterInput.min);
+				assert.isNull(column._filterInput.max);
+				column._filterInput = {
+					min: '04:30:00',
+					max: '17:34:56'
+				};
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min.getTime(), new Date(Date.UTC(1970, 0, 1, 2, 30)).getTime());
+					assert.equal(column.filter.max.getTime(), new Date(Date.UTC(1970, 0, 1, 15, 34, 56)).getTime());
+					done();
+				}, 750);
+			});
+
+			test('changing only _filterInput min updates filter min', function (done) {
+				column._filterInput.min = '04:21:10';
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min.getTime(), new Date(Date.UTC(1970, 0, 1, 2, 21, 10)).getTime());
+					done();
+				}, 650);
+			});
+
+		});
+
+	}());
+
+	</script>
+</body>
+</html>
diff --git a/test/range.html b/test/range.html
new file mode 100644
index 00000000..0197ed10
--- /dev/null
+++ b/test/range.html
@@ -0,0 +1,304 @@
+<!doctype html>
+<html>
+<head>
+	<title>cosmoz-omnitable range tests for number and amount</title>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
+
+	<script src="../../webcomponentsjs/webcomponents-lite.js"></script>
+	<script src="../../web-component-tester/browser.js"></script>
+	<script src="../../test-fixture/test-fixture-mocha.js"></script>
+
+	<link rel="import" href="../../test-fixture/test-fixture.html">
+	<link rel="import" href="../../iron-test-helpers/iron-test-helpers.html">
+
+	<link rel="import" href="../cosmoz-omnitable.html">
+	<link rel="import" href="../cosmoz-omnitable-columns.html">
+	<link rel="import" href="../demo/table-demo-behavior.html">
+</head>
+<body>
+	<test-fixture id="range">
+		<template>
+			<cosmoz-omnitable id="omnitable" class="flex">
+				<cosmoz-omnitable-column-number title="Age" name="age" value-path="age">
+				</cosmoz-omnitable-column-number>
+				<cosmoz-omnitable-column-amount title="Amount" name="amount" value-path="amount">
+				</cosmoz-omnitable-column-amount>
+			</cosmoz-omnitable>
+		</template>
+	</test-fixture>
+
+	<script>
+	/*global sinon chai flush */
+	(function () {
+		'use strict';
+		const data = [
+			{
+				age: 17,
+				amount: { amount: '12.4', currency: 'USD' },
+			},
+			{
+				amount: { amount: 2 }
+			},
+			{
+				age: -11,
+				amount: { amount: 678, currency: 'AUD' }
+			},
+			{
+				age: 9,
+				amount: { amount: -8, currency: 'EUR' }
+			},
+			{
+				age: 5,
+				amount: { amount: '3450', currency: 'DKK' }
+			},
+		];
+
+		sinon.assert.expose(chai.assert, { prefix: '' });
+
+		suite('number', function () {
+			let omnitable,
+				column;
+
+			setup(function (done) {
+				omnitable = fixture('range');
+				omnitable.data = data;
+				Polymer.Base.async(function () {
+					column = omnitable.columns[0];
+					done();
+				}, 90);
+			});
+
+			test('instantiates a cosmoz-omnitable-column-number', function (done) {
+				assert.equal(column.is, 'cosmoz-omnitable-column-number');
+				done();
+			});
+
+			test('toNumber convers a value to Number', function (done) {
+				assert.isUndefined(column.toNumber());
+				assert.equal(column.toNumber(-7.5), -7.5);
+				assert.equal(column.toNumber('-7.5'), -7.5);
+				assert.equal(column.toNumber(123e-5), 0.00123);
+				assert.isNotNumber(column.toNumber('some string not number'));
+				done();
+			});
+
+			test('toNumber limits parameters', function (done) {
+				assert.equal(column.toNumber('-2.0014', 4), -2.0014);
+				assert.equal(column.toNumber(3, 2, Math.min), 2);
+				assert.equal(column.toNumber('23.3', '-10.5443', Math.min), -10.5443);
+				assert.equal(column.toNumber(3, '2.0014', Math.min), 2.0014);
+				assert.equal(column.toNumber(3, 2.0014, Math.max), 3);
+				done();
+			});
+
+			test('computes range from values', function (done) {
+				assert.isObject(column._range);
+				assert.equal(column._range.min, -11);
+				assert.equal(column._range.max, 17);
+				done();
+			});
+
+			test('returns the value of an item', function (done) {
+				assert.equal(column.getComparableValue({age: '13'}, 'age'), 13);
+				assert.equal(column.getComparableValue(13), 13);
+				assert.equal(column.getComparableValue(data[1], 'age'), null);
+				assert.equal(column.getComparableValue(data[2], 'age'), -11);
+				done();
+			});
+
+			test('changing filter updates _filterInput', function (done) {
+				assert.isNull(column.filter.min);
+				assert.isNull(column.filter.max);
+				column.filter = {
+					min: 3,
+					max: 200
+				};
+				assert.equal(column._filterInput.min, 3);
+				assert.equal(column._filterInput.max, 200);
+				done();
+			});
+
+			test('changing _filterInput updates filter', function (done) {
+				assert.isNull(column._filterInput.min);
+				assert.isNull(column._filterInput.max);
+				column._filterInput = {
+					min: -10,
+					max: 15
+				};
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min, -10);
+					assert.equal(column.filter.max, 15);
+					done();
+				}, 650);
+			});
+
+			test('changing only _filterInput min updates filter min', function (done) {
+				column._filterInput.min = -21;
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min, -21);
+					done();
+				}, 700);
+			});
+
+			test('changing out of range _filterInput limits _filterInput', function (done) {
+				assert.isNull(column._filterInput.min);
+				assert.isNull(column._filterInput.max);
+
+				column._filterInput =  {min: -11, max: 17 };
+
+				Polymer.Base.async(function () {
+					assert.equal(column._filterInput.min, -11);
+					assert.equal(column._filterInput.max, 17);
+					assert.equal(column.filter.min, -11);
+					assert.equal(column.filter.max, 17);
+
+					column._filterInput.min = 20;
+
+					Polymer.Base.async(function () {
+						assert.equal(column.filter.min, -11);
+						done();
+					});
+
+				}, 650);
+			});
+
+		});
+
+		suite('amount', function () {
+			let omnitable,
+				column;
+
+			setup(function (done) {
+				omnitable = fixture('range');
+				omnitable.data = data;
+				Polymer.Base.async(function () {
+					column = omnitable.columns[1];
+					done();
+				}, 120);
+			});
+
+			test('instantiates a cosmoz-omnitable-column-amount', function (done) {
+				assert.equal(column.is, 'cosmoz-omnitable-column-amount');
+				done();
+			});
+
+			test('toAmount returns a valid amount', function (done) {
+				assert.isUndefined(column.toAmount());
+				assert.isNull(column.toAmount('123'));
+				assert.isNull(column.toAmount({amount: 123}));
+				assert.isNull(column.toAmount({amount: '123'}));
+				assert.isNull(column.toAmount({currency: 'USD'}));
+
+				assert.isObject(column.toAmount({amount: 75, currency: 'SEK'}));
+				assert.deepEqual(column.toAmount({amount: 123, currency: 'AUD'}), {amount: 123, currency: 'AUD'});
+				assert.deepEqual(column.toAmount({amount: '2300', currency: 'USD'}), {amount: 2300, currency: 'USD'});
+				assert.deepEqual(column.toAmount({amount: 99, currency: 'SEK'}), {amount: 99, currency: 'SEK'});
+				done();
+			});
+
+			test('toAmount limits parameters value', function (done) {
+				assert.equal(column.toAmount({amount: '-2.0014', currency: 'SEK'}, 4).amount, -2.0014);
+				assert.equal(column.toAmount({amount: 3, currency: 'EUR'}, {amount: 2, currency: 'EUR'}, Math.min).amount, 2);
+				assert.equal(column.toAmount({amount: '23.3', currency: 'AUD'}, {amount: '-10.5443', currency: 'AUD'}, Math.min).amount, -10.5443);
+				assert.equal(column.toAmount({amount: 15.3, currency: 'DKK'}, {amount: '2.0014', currency: 'DKK'}, Math.min).amount, 2.0014);
+				assert.equal(column.toAmount({amount: 1592, currency: 'SEK'}, {amount: 2.0014, currency: 'SEK'}, Math.max).amount, 1592);
+				done();
+			});
+
+			test('returns comparable value', function (done) {
+				assert.equal(column.getComparableValue(data[3], 'amount'), -8);
+				assert.equal(column.getComparableValue(data[4], 'amount'), 3450);
+				assert.equal(column.getComparableValue({amount: '13', currency: 'EUR'}), 13);
+				assert.isUndefined(column.getComparableValue({}));
+				assert.isUndefined(column.getComparableValue([]));
+				done();
+			});
+
+			test('amount renders symbol and value', function (done) {
+				assert.equal(column.renderValue(null), '');
+				assert.equal(column.renderValue({}), '');
+				assert.equal(column.renderValue([]), '');
+				assert.equal(column.renderValue({amount: '12.4', currency: 'USD'}), '$12.40');
+				assert.equal(column.renderValue({amount: 534 }), '');
+				assert.equal(column.renderValue({amount: -897, currency: 'EUR'}), '-€897.00');
+				done();
+			});
+
+			test('getString returns valid amount or Invalid value', function (done) {
+				assert.equal(column.getString({amountPath: null}, 'amountPath'), '');
+				assert.equal(column.getString({amountPath: {}}, 'amountPath'), 'Invalid value');
+				assert.equal(column.getString({amountPath: []}, 'amountPath'), 'Invalid value');
+				assert.equal(column.getString(data[0]), '$12.40');
+				assert.equal(column.getString({amountPath: {amount: 2036 }}, 'amountPath'), 'Invalid value', 'Expected missing currency to be treated as invalid.');
+				assert.equal(column.getString({amountPath: {amount: 372, currency: 'EUR'}}, 'amountPath'), '€372.00');
+				done();
+			});
+
+			test('computes array of formaters', function (done) {
+				assert.deepEqual(Object.keys(column._formatters), ['SEK', 'USD', 'AUD', 'EUR', 'DKK']);
+				done();
+			});
+
+			test('changing filter updates _filterInput', function (done) {
+				assert.isNull(column.filter.min);
+				assert.isNull(column.filter.max);
+				column.filter = {
+					min: {amount: 225, currency: 'EUR'},
+					max: {amount: 457, currency: 'EUR'}
+				};
+				assert.equal(column._filterInput.min, 225);
+				assert.equal(column._filterInput.max, 457);
+				done();
+			});
+
+			test('changing _filterInput updates filter', function (done) {
+				assert.isNull(column._filterInput.min);
+				assert.isNull(column._filterInput.max);
+				column._filterInput = {
+					min: 1,
+					max: 15
+				};
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min.amount, 1);
+					assert.equal(column.filter.max.amount, 15);
+					done();
+				}, 650);
+			});
+
+			test('changing only _filterInput min updates filter min', function (done) {
+				column._filterInput.min = -2317;
+				Polymer.Base.async(function () {
+					assert.equal(column.filter.min.amount, -2317);
+					done();
+				}, 650);
+			});
+
+			test('changing out of range _filterInput limits _filterInput', function (done) {
+				assert.isNull(column._filterInput.min);
+				assert.isNull(column._filterInput.max);
+
+				column._filterInput =  {min: 7, max: 77};
+
+				Polymer.Base.async(function () {
+					assert.equal(column._filterInput.min, 7);
+					assert.equal(column._filterInput.max, 77);
+					assert.equal(column.filter.min.amount, 7);
+					assert.equal(column.filter.max.amount, 77);
+
+					column._filterInput.min = 9992;
+
+					Polymer.Base.async(function () {
+						assert.equal(column.filter.min.amount, 7);
+						done();
+					});
+
+				}, 650);
+			});
+
+		});
+	}());
+
+	</script>
+</body>
+</html>
