This is an automated email from the ASF dual-hosted git repository.

sushuang pushed a commit to branch dataset-trans2
in repository https://gitbox.apache.org/repos/asf/incubator-echarts.git

commit 81d1306b5fc7dc528b01a360fe042b2b2ed72736
Author: 100pah <sushuang0...@gmail.com>
AuthorDate: Fri Aug 14 05:09:54 2020 +0800

    fix: [data-transform] (1) clarity the detail of value comparison. (2) 
rename "parse" to "parser".
---
 src/component/transform/sortTransform.ts  |  59 ++--
 src/data/helper/dataValueHelper.ts        | 206 ++++++------
 src/util/conditionalExpression.ts         |  32 +-
 src/util/number.ts                        |  15 +-
 test/data-transform.html                  | 173 ++++++++--
 test/ut/spec/data/dataValueHelper.test.js | 531 ++++++++++++++++++++----------
 6 files changed, 662 insertions(+), 354 deletions(-)

diff --git a/src/component/transform/sortTransform.ts 
b/src/component/transform/sortTransform.ts
index cd47616..8f6f184 100644
--- a/src/component/transform/sortTransform.ts
+++ b/src/component/transform/sortTransform.ts
@@ -22,10 +22,10 @@ import {
     DimensionLoose, SOURCE_FORMAT_KEYED_COLUMNS, DimensionIndex, 
OptionDataValue
 } from '../../util/types';
 import { makePrintable, throwError } from '../../util/log';
-import { isArray, each, hasOwn } from 'zrender/src/core/util';
+import { isArray, each } from 'zrender/src/core/util';
 import { normalizeToArray } from '../../util/model';
 import {
-    RawValueParserType, getRawValueParser, createRelationalComparator
+    RawValueParserType, getRawValueParser, SortOrderComparator
 } from '../../data/helper/dataValueHelper';
 
 /**
@@ -54,12 +54,13 @@ export interface SortTransformOption extends 
DataTransformOption {
 // PENDING: whether support { dimension: 'score', order: 'asc' } ?
 type OrderExpression = {
     dimension: DimensionLoose;
-    order: SortOrder;
-    parse?: RawValueParserType;
+    order: 'asc' | 'desc';
+    parser?: RawValueParserType;
+    // Value that is not comparable (like null/undefined) will be
+    // put to head or tail.
+    incomparable?: 'min' | 'max';
 };
 
-type SortOrder = 'asc' | 'desc';
-const SortOrderValidMap = { asc: true, desc: true } as const;
 
 let sampleLog = '';
 if (__DEV__) {
@@ -95,13 +96,14 @@ export const sortTransform: 
ExternalDataTransform<SortTransformOption> = {
 
         const orderDefList: {
             dimIdx: DimensionIndex;
-            orderReturn: -1 | 1;
             parser: ReturnType<typeof getRawValueParser>;
+            comparator: SortOrderComparator
         }[] = [];
         each(orderExprList, function (orderExpr) {
             const dimLoose = orderExpr.dimension;
             const order = orderExpr.order;
-            const parserName = orderExpr.parse;
+            const parserName = orderExpr.parser;
+            const incomparable = orderExpr.incomparable;
 
             if (dimLoose == null) {
                 if (__DEV__) {
@@ -110,13 +112,28 @@ export const sortTransform: 
ExternalDataTransform<SortTransformOption> = {
                 throwError(errMsg);
             }
 
-            if (!hasOwn(SortOrderValidMap, order)) {
+            if (order !== 'asc' && order !== 'desc') {
                 if (__DEV__) {
                     errMsg = 'Sort transform config must has "order" 
specified.' + sampleLog;
                 }
                 throwError(errMsg);
             }
 
+            if (incomparable && (incomparable !== 'min' && incomparable !== 
'max')) {
+                let errMsg = '';
+                if (__DEV__) {
+                    errMsg = 'incomparable must be "min" or "max" rather than 
"' + incomparable + '".';
+                }
+                throwError(errMsg);
+            }
+            if (order !== 'asc' && order !== 'desc') {
+                let errMsg = '';
+                if (__DEV__) {
+                    errMsg = 'order must be "asc" or "desc" rather than "' + 
order + '".';
+                }
+                throwError(errMsg);
+            }
+
             const dimInfo = source.getDimensionInfo(dimLoose);
             if (!dimInfo) {
                 if (__DEV__) {
@@ -142,8 +159,8 @@ export const sortTransform: 
ExternalDataTransform<SortTransformOption> = {
 
             orderDefList.push({
                 dimIdx: dimInfo.index,
-                orderReturn: order === 'asc' ? -1 : 1,
-                parser: parser
+                parser: parser,
+                comparator: new SortOrderComparator(order, incomparable)
             });
         });
 
@@ -170,9 +187,6 @@ export const sortTransform: 
ExternalDataTransform<SortTransformOption> = {
             resultData.push(source.getRawDataItem(i));
         }
 
-        const lt = createRelationalComparator('lt');
-        const gt = createRelationalComparator('gt');
-
         resultData.sort(function (item0, item1) {
             if (item0 === headerPlaceholder) {
                 return -1;
@@ -180,15 +194,6 @@ export const sortTransform: 
ExternalDataTransform<SortTransformOption> = {
             if (item1 === headerPlaceholder) {
                 return 1;
             }
-            // FIXME: check other empty?
-            // Always put empty item last?
-            if (item0 == null) {
-                return 1;
-            }
-            if (item1 == null) {
-                return -1;
-            }
-            // TODO Optimize a little: manually loop unrolling?
             for (let i = 0; i < orderDefList.length; i++) {
                 const orderDef = orderDefList[i];
                 let val0 = source.retrieveItemValue(item0, orderDef.dimIdx);
@@ -197,11 +202,9 @@ export const sortTransform: 
ExternalDataTransform<SortTransformOption> = {
                     val0 = orderDef.parser(val0) as OptionDataValue;
                     val1 = orderDef.parser(val1) as OptionDataValue;
                 }
-                if (lt.evaluate(val0, val1)) {
-                    return orderDef.orderReturn;
-                }
-                else if (gt.evaluate(val0, val1)) {
-                    return -orderDef.orderReturn;
+                const result = orderDef.comparator.evaluate(val0, val1);
+                if (result !== 0) {
+                    return result;
                 }
             }
             return 0;
diff --git a/src/data/helper/dataValueHelper.ts 
b/src/data/helper/dataValueHelper.ts
index 9214bb3..07c98e0 100644
--- a/src/data/helper/dataValueHelper.ts
+++ b/src/data/helper/dataValueHelper.ts
@@ -21,6 +21,7 @@ import { ParsedValue, DimensionType } from '../../util/types';
 import OrdinalMeta from '../OrdinalMeta';
 import { parseDate, numericToNumber } from '../../util/number';
 import { createHashMap, trim, hasOwn } from 'zrender/src/core/util';
+import { throwError } from '../../util/log';
 
 
 /**
@@ -99,51 +100,99 @@ export function getRawValueParser(type: 
RawValueParserType): RawValueParser {
 
 
 
-export interface UnaryExpression {
-    evaluate(val: unknown): unknown;
-}
-export interface BinaryExpression {
-    evaluate(lval: unknown, rval: unknown): unknown;
+export interface FilterComparator {
+    evaluate(val: unknown): boolean;
 }
 
-class OrderComparatorUnary implements UnaryExpression {
-    _rval: unknown;
-    _rvalTypeof: string; // typeof rval
-    _rvalFloat: number;
-    _rvalIsNumeric: boolean;
-    _opFn: (lval: unknown, rval: unknown) => boolean;
+const ORDER_COMPARISON_OP_MAP: {
+    [key in OrderRelationOperator]: ((lval: unknown, rval: unknown) => boolean)
+} = {
+    lt: (lval, rval) => lval < rval,
+    lte: (lval, rval) => lval <= rval,
+    gt: (lval, rval) => lval > rval,
+    gte: (lval, rval) => lval >= rval
+};
+
+class FilterOrderComparator implements FilterComparator {
+    private _rvalFloat: number;
+    private _opFn: (lval: unknown, rval: unknown) => boolean;
+    constructor(op: OrderRelationOperator, rval: unknown) {
+        if (typeof rval !== 'number') {
+            let errMsg = '';
+            if (__DEV__) {
+                errMsg = 'rvalue of "<", ">", "<=", ">=" can only be number in 
filter.';
+            }
+            throwError(errMsg);
+        }
+        this._opFn = ORDER_COMPARISON_OP_MAP[op];
+        this._rvalFloat = numericToNumber(rval);
+    }
     // Performance sensitive.
     evaluate(lval: unknown): boolean {
         // Most cases is 'number', and typeof maybe 10 times faseter than 
parseFloat.
-        const lvalIsNumber = typeof lval === 'number';
-        return (lvalIsNumber && this._rvalIsNumeric)
+        return typeof lval === 'number'
             ? this._opFn(lval, this._rvalFloat)
-            : (lvalIsNumber || this._rvalTypeof === 'number')
-            ? this._opFn(numericToNumber(lval), this._rvalFloat)
-            : false;
+            : this._opFn(numericToNumber(lval), this._rvalFloat);
     }
 }
-class OrderComparatorBinary implements BinaryExpression {
-    _opFn: (lval: unknown, rval: unknown) => boolean;
+
+export class SortOrderComparator {
+    private _incomparable: number;
+    private _resultLT: -1 | 1;
+    /**
+     * @param order by defualt: 'asc'
+     * @param incomparable by defualt: Always on the tail.
+     *        That is, if 'asc' => 'max', if 'desc' => 'min'
+     */
+    constructor(order: 'asc' | 'desc', incomparable: 'min' | 'max') {
+        const isDesc = order === 'desc';
+        this._resultLT = isDesc ? 1 : -1;
+        if (incomparable == null) {
+            incomparable = isDesc ? 'min' : 'max';
+        }
+        this._incomparable = incomparable === 'min' ? -Infinity : Infinity;
+    }
     // Performance sensitive.
-    evaluate(lval: unknown, rval: unknown): boolean {
+    evaluate(lval: unknown, rval: unknown): -1 | 0 | 1 {
         // Most cases is 'number', and typeof maybe 10 times faseter than 
parseFloat.
-        const lvalIsNumber = typeof lval === 'number';
-        const rvalIsNumber = typeof rval === 'number';
-        return (lvalIsNumber && rvalIsNumber)
-            ? this._opFn(lval, rval)
-            : (lvalIsNumber || rvalIsNumber)
-            ? this._opFn(numericToNumber(lval), numericToNumber(rval))
-            : false;
+        const lvalTypeof = typeof lval;
+        const rvalTypeof = typeof rval;
+        let lvalFloat = lvalTypeof === 'number' ? lval : numericToNumber(lval);
+        let rvalFloat = rvalTypeof === 'number' ? rval : numericToNumber(rval);
+        const lvalIncmpr = isNaN(lvalFloat as number);
+        const rvalIncmpr = isNaN(rvalFloat as number);
+        if (lvalIncmpr) {
+            lvalFloat = this._incomparable;
+        }
+        if (rvalIncmpr) {
+            rvalFloat = this._incomparable;
+        }
+        // In most cases, pure string sort has no meanings. But it can exists 
when need to
+        // group two categories (and order by anthor dimension meanwhile).
+        // But if we support string sort, we still need to avoid the 
misleading of `'2' > '12'`,
+        // and support '-' means empty, and trade `'abc' > 2` as incomparable.
+        // So we support string comparison only if both lval and rval are 
string and not numeric.
+        if (lvalIncmpr && rvalIncmpr && lvalTypeof === 'string' && rvalTypeof 
=== 'string') {
+            lvalFloat = lval;
+            rvalFloat = rval;
+        }
+        return lvalFloat < rvalFloat ? this._resultLT
+            : lvalFloat > rvalFloat ? (-this._resultLT as -1 | 1)
+            : 0;
     }
 }
 
-class EqualityComparatorUnary implements UnaryExpression {
-    _rval: unknown;
-    _rvalTypeof: string; // typeof rval
-    _rvalFloat: number;
-    _rvalIsNumeric: boolean;
-    _isEq: boolean;
+class FilterEqualityComparator implements FilterComparator {
+    private _isEQ: boolean;
+    private _rval: unknown;
+    private _rvalTypeof: string;
+    private _rvalFloat: number;
+    constructor(isEq: boolean, rval: unknown) {
+        this._rval = rval;
+        this._isEQ = isEq;
+        this._rvalTypeof = typeof rval;
+        this._rvalFloat = numericToNumber(rval);
+    }
     // Performance sensitive.
     evaluate(lval: unknown): boolean {
         let eqResult = lval === this._rval;
@@ -153,80 +202,47 @@ class EqualityComparatorUnary implements UnaryExpression {
                 eqResult = numericToNumber(lval) === this._rvalFloat;
             }
         }
-        return this._isEq ? eqResult : !eqResult;
+        return this._isEQ ? eqResult : !eqResult;
     }
 }
 
-class EqualityComparatorBinary implements BinaryExpression {
-    _isEq: boolean;
-    // Performance sensitive.
-    evaluate(lval: unknown, rval: unknown): boolean {
-        let eqResult = lval === rval;
-        if (!eqResult) {
-            const lvalTypeof = typeof lval;
-            const rvalTypeof = typeof rval;
-            if (lvalTypeof !== rvalTypeof && (lvalTypeof === 'number' || 
rvalTypeof === 'number')) {
-                eqResult = numericToNumber(lval) === numericToNumber(rval);
-            }
-        }
-        return this._isEq ? eqResult : !eqResult;
-    }
-}
-
-const ORDER_COMPARISON_OP_MAP = {
-    lt: (tarVal: unknown, condVal: unknown) => tarVal < condVal,
-    lte: (tarVal: unknown, condVal: unknown) => tarVal <= condVal,
-    gt: (tarVal: unknown, condVal: unknown) => tarVal > condVal,
-    gte: (tarVal: unknown, condVal: unknown) => tarVal >= condVal
-} as const;
-
-export type RelationalOperator = 'lt' | 'lte' | 'gt' | 'gte' | 'eq' | 'ne';
+type OrderRelationOperator = 'lt' | 'lte' | 'gt' | 'gte';
+export type RelationalOperator = OrderRelationOperator | 'eq' | 'ne';
 
 /**
- * [COMPARISON_RULE]
- * `lt`, `lte`, `gt`, `gte`:
- * + If two "number" or a "number" and a "numeric": convert to number and 
compare.
- * + Else return `false`.
+ * [FILTER_COMPARISON_RULE]
+ * `lt`|`lte`|`gt`|`gte`:
+ * + rval must be a number. And lval will be converted to number 
(`numericToNumber`) to compare.
  * `eq`:
- * + If same type, compare with ===.
- * + If two "number" or a "number" and a "numeric": convert to number and 
compare.
+ * + If same type, compare with `===`.
+ * + If there is one number, convert to number (`numericToNumber`) to compare.
  * + Else return `false`.
  * `ne`:
  * + Not `eq`.
  *
- * Definition of "numeric": see `util/number.ts#numericToNumber`.
+ * [SORT_COMPARISON_RULE]
+ * Only `lt`|`gt`.
+ * Always convert to number (`numericToNumer`) to compare.
+ * (e.g., consider case: [12, " 13 ", " 14 ", null, 15])
+ *
+ * [CHECK_LIST_OF_THE_RULE_DESIGN]
+ * + Do not support string comparison until required. And also need to
+ *   void the misleading of "2" > "12".
+ * + Should avoid the misleading case:
+ *   `" 22 " gte "22"` is `true` but `" 22 " eq "22"` is `false`.
+ * + JS bad case should be avoided: null <= 0, [] <= 0, ' ' <= 0, ...
+ * + Only "numeric" can be converted to comparable number, otherwise converted 
to NaN.
+ *   See `util/number.ts#numericToNumber`.
  *
- * [MEMO]
- * + Do not support string comparison until required. And also need to 
consider the
- *   misleading of "2" > "12".
- * + JS bad case considered: null <= 0, [] <= 0, ' ' <= 0, ...
+ * @return If `op` is not `RelationalOperator`, return null;
  */
-export function createRelationalComparator(op: RelationalOperator): 
BinaryExpression;
-export function createRelationalComparator(op: RelationalOperator, isUnary: 
true, rval: unknown): UnaryExpression;
-export function createRelationalComparator(
-    op: RelationalOperator,
-    isUnary?: true,
+export function createFilterComparator(
+    op: string,
     rval?: unknown
-): UnaryExpression | BinaryExpression {
-    let comparator;
-    if (op === 'eq' || op === 'ne') {
-        comparator = isUnary ? new EqualityComparatorUnary() : new 
EqualityComparatorBinary();
-        comparator._isEq = op === 'eq';
-    }
-    else {
-        comparator = isUnary ? new OrderComparatorUnary() : new 
OrderComparatorBinary();
-        comparator._opFn = ORDER_COMPARISON_OP_MAP[op];
-    }
-    if (isUnary) {
-        const unaryComp = comparator as OrderComparatorUnary | 
EqualityComparatorUnary;
-        unaryComp._rval = rval;
-        unaryComp._rvalTypeof = typeof rval;
-        const rvalFloat = unaryComp._rvalFloat = numericToNumber(rval);
-        unaryComp._rvalIsNumeric = !isNaN(rvalFloat); // eslint-disable-line 
eqeqeq
-    }
-    return comparator;
-}
-
-export function isRelationalOperator(op: string): op is RelationalOperator {
-    return hasOwn(ORDER_COMPARISON_OP_MAP, op) || op === 'eq' || op === 'ne';
+): FilterComparator {
+    return (op === 'eq' || op === 'ne')
+        ? new FilterEqualityComparator(op === 'eq', rval)
+        : hasOwn(ORDER_COMPARISON_OP_MAP, op)
+        ? new FilterOrderComparator(op as OrderRelationOperator, rval)
+        : null;
 }
diff --git a/src/util/conditionalExpression.ts 
b/src/util/conditionalExpression.ts
index b871b09..2d9b752 100644
--- a/src/util/conditionalExpression.ts
+++ b/src/util/conditionalExpression.ts
@@ -23,13 +23,13 @@ import {
 } from 'zrender/src/core/util';
 import { throwError, makePrintable } from './log';
 import {
-    RawValueParserType, getRawValueParser, isRelationalOperator,
-    createRelationalComparator, RelationalOperator, UnaryExpression
+    RawValueParserType, getRawValueParser,
+    RelationalOperator, FilterComparator, createFilterComparator
 } from '../data/helper/dataValueHelper';
 
 
 // PENDING:
-// (1) Support more parser like: `parse: 'trim'`, `parse: 'lowerCase'`, 
`parse: 'year'`, `parse: 'dayOfWeek'`?
+// (1) Support more parser like: `parser: 'trim'`, `parser: 'lowerCase'`, 
`parser: 'year'`, `parser: 'dayOfWeek'`?
 // (2) Support piped parser ?
 // (3) Support callback parser or callback condition?
 // (4) At present do not support string expression yet but only stuctured 
expression.
@@ -77,24 +77,24 @@ import {
  * ```js
  * // Trim if string
  * {
- *     parse: 'trim',
+ *     parser: 'trim',
  *     eq: 'Flowers'
  * }
  * // Parse as time and enable arithmetic relation comparison.
  * {
- *     parse: 'time',
+ *     parser: 'time',
  *     lt: '2012-12-12'
  * }
  * // Normalize number-like string and make '-' to Null.
  * {
- *     parse: 'time',
+ *     parser: 'time',
  *     lt: '2012-12-12'
  * }
  * // Normalize to number:
  * // + number-like string (like '  123  ') can be converted to a number.
  * // + where null/undefined or other string will be converted to NaN.
  * {
- *     parse: 'number',
+ *     parser: 'number',
  *     eq: 2011
  * }
  * // RegExp, include the feature in SQL: `like '%xxx%'`.
@@ -164,13 +164,13 @@ type RelationalExpressionOptionByOpAlias = Record<keyof 
typeof RELATIONAL_EXPRES
 interface RelationalExpressionOption extends
         RelationalExpressionOptionByOp, RelationalExpressionOptionByOpAlias {
     dimension?: DimensionLoose;
-    parse?: RawValueParserType;
+    parser?: RawValueParserType;
 }
 
 type RelationalExpressionOpEvaluate = (tarVal: unknown, condVal: unknown) => 
boolean;
 
 
-class RegExpEvaluator implements UnaryExpression {
+class RegExpEvaluator implements FilterComparator {
     private _condVal: RegExp;
 
     constructor(rVal: unknown) {
@@ -279,7 +279,7 @@ class RelationalConditionInternal implements 
ParsedConditionInternal {
     valueParser: ReturnType<typeof getRawValueParser>;
     // If no parser, be null/undefined.
     getValue: ConditionalExpressionValueGetter;
-    subCondList: UnaryExpression[];
+    subCondList: FilterComparator[];
 
     evaluate() {
         const needParse = !!this.valueParser;
@@ -392,12 +392,12 @@ function parseRelationalOption(
     const subCondList = [] as RelationalConditionInternal['subCondList'];
     const exprKeys = keys(exprOption);
 
-    const parserName = exprOption.parse;
+    const parserName = exprOption.parser;
     const valueParser = parserName ? getRawValueParser(parserName) : null;
 
     for (let i = 0; i < exprKeys.length; i++) {
         const keyRaw = exprKeys[i];
-        if (keyRaw === 'parse' || getters.valueGetterAttrMap.get(keyRaw)) {
+        if (keyRaw === 'parser' || getters.valueGetterAttrMap.get(keyRaw)) {
             continue;
         }
 
@@ -406,12 +406,8 @@ function parseRelationalOption(
             : (keyRaw as keyof RelationalExpressionOptionByOp);
         const condValueRaw = exprOption[keyRaw];
         const condValueParsed = valueParser ? valueParser(condValueRaw) : 
condValueRaw;
-        const evaluator =
-            isRelationalOperator(op)
-            ? createRelationalComparator(op, true, condValueParsed)
-            : op === 'reg'
-            ? new RegExpEvaluator(condValueParsed)
-            : null;
+        const evaluator = createFilterComparator(op, condValueParsed)
+            || (op === 'reg' && new RegExpEvaluator(condValueParsed));
 
         if (!evaluator) {
             if (__DEV__) {
diff --git a/src/util/number.ts b/src/util/number.ts
index b2ae043..775d51a 100644
--- a/src/util/number.ts
+++ b/src/util/number.ts
@@ -549,22 +549,19 @@ export function reformIntervals(list: IntervalItem[]): 
IntervalItem[] {
  *     non-string, ...
  *
  * @test See full test cases in `test/ut/spec/util/number.js`.
+ * @return Must be a typeof number. If not numeric, return NaN.
  */
 export function numericToNumber(val: unknown): number {
     const valFloat = parseFloat(val as string);
-    return isNumericHavingParseFloat(val, valFloat) ? valFloat : NaN;
+    return (
+        valFloat == val // eslint-disable-line eqeqeq
+        && (valFloat !== 0 || typeof val !== 'string' || val.indexOf('x') <= 
0) // For case ' 0x0 '.
+    ) ? valFloat : NaN;
 }
 
 /**
  * Definition of "numeric": see `numericToNumber`.
  */
 export function isNumeric(val: unknown): val is number {
-    return isNumericHavingParseFloat(val, parseFloat(val as string));
-}
-
-function isNumericHavingParseFloat(val: unknown, valFloat: number): val is 
number {
-    return (
-        valFloat == val // eslint-disable-line eqeqeq
-        && (valFloat !== 0 || typeof val !== 'string' || val.indexOf('x') <= 
0) // For case ' 0x0 '.
-    );
+    return !isNaN(numericToNumber(val));
 }
diff --git a/test/data-transform.html b/test/data-transform.html
index 9a11dc7..0f23efe 100644
--- a/test/data-transform.html
+++ b/test/data-transform.html
@@ -80,21 +80,24 @@ under the License.
                 Age: 1,
                 Sex: 2,
                 Score: 3,
-                Date: 4
+                Date: 4,
+                DirtyNumber: 5,
+                Numeric: 6,
+                HasEmpty: 7
             };
             var NAME_SCORE_DIRTY_DATA_HEADER =
-                ['Name', 'Age', 'Sex', 'Score', 'Date'];
+                ['Name', 'Age', 'Sex', 'Score', 'Date', 'DirtyNumber', 
'Numeric', 'HasEmpty'];
             var NAME_SCORE_DIRTY_DATA_NO_HEADER = [
                 // This is for trim testing.
-                [' Jobs Mat ', 41, 'male', 314, '2011-02-12'],
+                [' Jobs Mat ', 41, 'male', 314, '2011-02-12', '13', ' 91000 ', 
45 ],
                 // This is for edge testing (03-01, 20)
-                ['Hottlyuipe Xu ', 20, 'female', 351, '2011-03-01'],
-                [' Jone Mat ', 52, 'male', 287, '2011-02-14'],
-                ['Uty Xu', 19, 'male', 219, '2011-02-18'],
-                ['Tatum von Godden', 25, 'female', 301, '2011-04-02'],
-                ['Must Godden', 31, 'female', 235, '2011-03-19'],
-                ['Caoas Xu', 71, 'male', 318, '2011-02-24'],
-                ['Malise Mat', 67, 'female', 366, '2011-03-12'],
+                ['Hottlyuipe Xu ', 20, 'female', 351, '2011-03-01', 44, ' 
83000 ', 13 ],
+                [' Jone Mat ', 52, 'male', 287, '2011-02-14', null, ' 43000 ', 
null ],
+                ['Uty Xu', 19, 'male', 219, '2011-02-18', undefined, ' 63000 
', 81 ],
+                ['Tatum von Godden', 25, 'female', 301, '2011-04-02', '-', ' 
13000 ', undefined ],
+                ['Must Godden', 31, 'female', 235, '2011-03-19', ' 454', '-', 
32 ],
+                ['Caoas Xu', 71, 'male', 318, '2011-02-24', NaN, ' 73000 ', 
'-' ],
+                ['Malise Mat', 67, 'female', 366, '2011-03-12', '232a', ' 
23000 ', 19 ]
             ];
             var NAME_SCORE_DIRTY_DATA_WITH_HEADER =
                 [NAME_SCORE_DIRTY_DATA_HEADER]
@@ -287,7 +290,8 @@ under the License.
                         NAME_SCORE_DIM.Date,
                         NAME_SCORE_DIM.Score,
                         NAME_SCORE_DIM.Sex,
-                        NAME_SCORE_DIM.Age
+                        NAME_SCORE_DIM.Age,
+                        NAME_SCORE_DIM.DirtyNumber
                     ]
                 };
                 option.series.push(series);
@@ -299,7 +303,7 @@ under the License.
                 transform: {
                     type: 'filter',
                     // print: true,
-                    config: { dimension: NAME_SCORE_DIM.Name, eq: 'Jobs Mat', 
parse: 'trim' }
+                    config: { dimension: NAME_SCORE_DIM.Name, eq: 'Jobs Mat', 
parser: 'trim' }
                 }
             });
             addCartesian({
@@ -314,7 +318,7 @@ under the License.
                 transform: {
                     type: 'filter',
                     // print: true,
-                    config: { dimension: NAME_SCORE_DIM.Date, lt: '2011-03', 
gte: '2011-02', parse: 'time' }
+                    config: { dimension: NAME_SCORE_DIM.Date, lt: '2011-03', 
gte: '2011-02', parser: 'time' }
                 }
             });
             addCartesian({
@@ -329,7 +333,7 @@ under the License.
                 transform: {
                     type: 'filter',
                     // print: true,
-                    config: { dimension: NAME_SCORE_DIM.Date, lte: '2011-03', 
gte: '2011-02-29', parse: 'time' }
+                    config: { dimension: NAME_SCORE_DIM.Date, lte: '2011-03', 
gte: '2011-02-29', parser: 'time' }
                 }
             });
             addCartesian({
@@ -344,7 +348,7 @@ under the License.
                 transform: {
                     type: 'filter',
                     // print: true,
-                    config: { dimension: NAME_SCORE_DIM.Name, reg: /\sXu$/, 
parse: 'trim' }
+                    config: { dimension: NAME_SCORE_DIM.Name, reg: /\sXu$/, 
parser: 'trim' }
                 }
             });
             addCartesian({
@@ -359,7 +363,7 @@ under the License.
                 transform: {
                     type: 'filter',
                     // print: true,
-                    config: { dimension: NAME_SCORE_DIM.Sex, ne: 'male', 
parse: 'trim' }
+                    config: { dimension: NAME_SCORE_DIM.Sex, ne: 'male', 
parser: 'trim' }
                 }
             });
             addCartesian({
@@ -377,7 +381,7 @@ under the License.
                     // print: true,
                     config: {
                         and: [
-                            { dimension: NAME_SCORE_DIM.Sex, eq: 'male', 
parse: 'trim' },
+                            { dimension: NAME_SCORE_DIM.Sex, eq: 'male', 
parser: 'trim' },
                             { dimension: NAME_SCORE_DIM.Score, '>': 300 }
                         ]
                     }
@@ -464,6 +468,30 @@ under the License.
             });
 
 
+            option.dataset.push({
+                id: 'j',
+                transform: {
+                    type: 'filter',
+                    // print: true,
+                    config: {
+                        or: [{
+                            dimension: NAME_SCORE_DIM.DirtyNumber,
+                            eq: 454
+                        }, {
+                            dimension: NAME_SCORE_DIM.DirtyNumber,
+                            eq: 232
+                        }]
+                    }
+                }
+            });
+            addCartesian({
+                series: {
+                    datasetId: 'j',
+                    encode: { label: [NAME_SCORE_DIM.DirtyNumber] }
+                },
+                xAxis: { name: 'Show only "Must Godden"' }
+            });
+
 
 
             var chart = testHelper.create(echarts, 
'main_cartesian_parse_trim_time_reg', {
@@ -501,7 +529,7 @@ under the License.
             var leftStart = 50;
             var leftBase = leftStart;
             var topBase = 30;
-            var gridWidth = 100;
+            var gridWidth = 200;
             var gridHeight = 100;
             var gapWidth = 70;
             var gapHeight = 80;
@@ -537,7 +565,13 @@ under the License.
                 series.type = 'bar';
                 series.xAxisIndex = option.xAxis.length - 1;
                 series.yAxisIndex = option.yAxis.length - 1;
-                series.label = { show: true, position: 'top' };
+                series.label = {
+                    show: true,
+                    position: 'insideBottom',
+                    rotate: 90,
+                    align: 'left',
+                    verticalAlign: 'middle'
+                };
                 series.encode = {
                     x: NAME_SCORE_DIM.Date,
                     y: NAME_SCORE_DIM.Score,
@@ -547,7 +581,10 @@ under the License.
                         NAME_SCORE_DIM.Date,
                         NAME_SCORE_DIM.Score,
                         NAME_SCORE_DIM.Sex,
-                        NAME_SCORE_DIM.Age
+                        NAME_SCORE_DIM.Age,
+                        NAME_SCORE_DIM.DirtyNumber,
+                        NAME_SCORE_DIM.Numeric,
+                        NAME_SCORE_DIM.HasEmpty
                     ]
                 };
                 option.series.push(series);
@@ -564,9 +601,10 @@ under the License.
             });
             addCartesian({
                 series: {
+                    encode: { label: NAME_SCORE_DIM.Score },
                     datasetId: 'a'
                 },
-                xAxis: { name: 'Show all eight\norder by Score asc' }
+                xAxis: { name: 'Show all eight bars\norder by Score asc' }
             });
 
             option.dataset.push({
@@ -582,7 +620,7 @@ under the License.
                     datasetId: 'b',
                     encode: { label: NAME_SCORE_DIM.Age }
                 },
-                xAxis: { name: 'Show all eight\norder by Age desc' }
+                xAxis: { name: 'Show all eight bars\norder by Age desc' }
             });
 
             option.dataset.push({
@@ -599,9 +637,9 @@ under the License.
             addCartesian({
                 series: {
                     datasetId: 'c',
-                    encode: { label: NAME_SCORE_DIM.Sex }
+                    encode: { label: [NAME_SCORE_DIM.Sex, 
NAME_SCORE_DIM.Score] }
                 },
-                xAxis: { name: 'Show all eight\nSex asc, Score desc' }
+                xAxis: { name: 'Show all eight bars\nSex asc (all female 
left)\nScore desc in each Sex' }
             });
 
             option.dataset.push({
@@ -610,15 +648,16 @@ under the License.
                     type: 'sort',
                     // print: true,
                     config: [
-                        { dimension: NAME_SCORE_DIM.Date, order: 'asc', parse: 
'time' }
+                        { dimension: NAME_SCORE_DIM.Date, order: 'asc', 
parser: 'time' }
                     ]
                 }
             });
             addCartesian({
                 series: {
+                    encode: { label: NAME_SCORE_DIM.Date },
                     datasetId: 'd'
                 },
-                xAxis: { name: 'Show all eight\nDate asc' }
+                xAxis: { name: 'Show all eight bars\nDate asc' }
             });
 
 
@@ -626,26 +665,98 @@ under the License.
                 id: 'e',
                 transform: [{
                     type: 'filter',
-                    // print: true,
                     config: { dimension: NAME_SCORE_DIM.Age, lte: 40, gte: 20 }
                 }, {
                     type: 'sort',
-                    // print: true,
                     config: { dimension: NAME_SCORE_DIM.Score, order: 'asc' }
                 }]
             });
             addCartesian({
                 series: {
+                    encode: { label: [NAME_SCORE_DIM.Age, 
NAME_SCORE_DIM.Score] },
                     datasetId: 'e'
                 },
-                xAxis: { name: 'Show three ponits\nFilter by Age 20-40\nOrder 
by Score' }
+                xAxis: { name: 'Show three bars\nFilter by Age 20-40\nOrder by 
Score asc' }
+            });
+
+
+            option.dataset.push({
+                id: 'f',
+                transform: {
+                    type: 'sort',
+                    config: [
+                        { dimension: NAME_SCORE_DIM.DirtyNumber, order: 
'desc', parser: 'number' }
+                    ]
+                }
+            });
+            addCartesian({
+                series: {
+                    encode: { label: NAME_SCORE_DIM.DirtyNumber },
+                    datasetId: 'f'
+                },
+                xAxis: { name: 'Show all eight bars\nOrder by DirtyNumber 
desc' }
+            });
+
+
+            option.dataset.push({
+                id: 'g',
+                transform: {
+                    type: 'sort',
+                    config: [
+                        { dimension: NAME_SCORE_DIM.Numeric, order: 'asc' }
+                    ]
+                }
+            });
+            addCartesian({
+                series: {
+                    encode: { label: NAME_SCORE_DIM.Numeric },
+                    datasetId: 'g'
+                },
+                xAxis: { name: 'Show all eight bars\nOrder by Numeric 
asc\nOnly one empty at right' }
+            });
+
+
+            option.dataset.push({
+                id: 'h',
+                transform: {
+                    type: 'sort',
+                    config: [
+                        { dimension: NAME_SCORE_DIM.HasEmpty, order: 'desc' }
+                    ]
+                }
+            });
+            addCartesian({
+                series: {
+                    encode: { label: NAME_SCORE_DIM.HasEmpty },
+                    datasetId: 'h'
+                },
+                xAxis: { name: 'Show all eight bars\nOrder by HasEmpty 
desc\nempty at right' }
+            });
+
+
+            option.dataset.push({
+                id: 'i',
+                transform: {
+                    type: 'sort',
+                    config: [
+                        { dimension: NAME_SCORE_DIM.HasEmpty, order: 'desc', 
incomparable: 'max' }
+                    ]
+                }
+            });
+            addCartesian({
+                series: {
+                    encode: { label: NAME_SCORE_DIM.HasEmpty },
+                    datasetId: 'i'
+                },
+                xAxis: { name: 'Show all eight bars\nOrder by HasEmpty 
desc\nempty at left' }
             });
 
 
             var chart = testHelper.create(echarts, 'main_cartesian_sort', {
                 title: [
-                    'Check each cartesians.',
-                    'The expectationa are below each cartesian.'
+                    'Test sort transform. Check each cartesians.',
+                    'The expectationa are below each cartesian.',
+                    'Ordered dimension is on **bar label **'
                 ],
                 width: chartWidth,
                 height: 600,
diff --git a/test/ut/spec/data/dataValueHelper.test.js 
b/test/ut/spec/data/dataValueHelper.test.js
index 8eb7309..cf0c627 100644
--- a/test/ut/spec/data/dataValueHelper.test.js
+++ b/test/ut/spec/data/dataValueHelper.test.js
@@ -20,189 +20,374 @@
 
 const dataValueHelper = require('../../../../lib/data/helper/dataValueHelper');
 
-describe('data/helper/dataValueHelper', function () {
+const NO_SUCH_CASE = 'NO_SUCH_CASE';
+
+// Tags for relational comparison cases.
+// LT: less than, GT: greater than, INCMPR: incomparable
+const TAG = {
+    ONE_OR_TWO_NUMBER_L_LT_R: 'ONE_OR_TWO_NUMBER_L_LT_R',
+    ONE_OR_TWO_NUMBER_L_GT_R: 'ONE_OR_TWO_NUMBER_L_GT_R',
+    TWO_STRING_L_LT_R: 'TWO_STRING_L_LT_R',
+    TWO_STRING_L_GT_R: 'TWO_STRING_L_GT_R',
+    TWO_STRING_ONLY_NUMERIC_EQ: 'TWO_STRING_ONLY_NUMERIC_EQ',
+    STRICT_EQ: 'STRICT_EQ',
+    ONE_NUMBER_NUMERIC_EQ: 'ONE_NUMBER_NUMERIC_EQ',
+    BOTH_INCMPR_NOT_EQ: 'BOTH_INCMPR_NOT_EQ',
+    ONLY_L_INCMPR: 'ONLY_L_INCMPR',
+    ONLY_R_INCMPR: 'ONLY_R_INCMPR'
+};
+const tagRevertPairs = [
+    ['ONE_OR_TWO_NUMBER_L_LT_R', 'ONE_OR_TWO_NUMBER_L_GT_R'],
+    ['TWO_STRING_L_LT_R', 'TWO_STRING_L_GT_R'],
+    ['TWO_STRING_ONLY_NUMERIC_EQ', 'TWO_STRING_ONLY_NUMERIC_EQ'],
+    ['STRICT_EQ', 'STRICT_EQ'],
+    ['ONE_NUMBER_NUMERIC_EQ', 'ONE_NUMBER_NUMERIC_EQ'],
+    ['BOTH_INCMPR_NOT_EQ', 'BOTH_INCMPR_NOT_EQ'],
+    ['ONLY_L_INCMPR', 'ONLY_R_INCMPR']
+];
+
+const filterResultMap = {
+    ONE_OR_TWO_NUMBER_L_LT_R: {
+        lt: true,
+        lte: true,
+        gt: false,
+        gte: false,
+        eq: false,
+        ne: true
+    },
+    ONE_OR_TWO_NUMBER_L_GT_R: {
+        lt: false,
+        lte: false,
+        gt: true,
+        gte: true,
+        eq: false,
+        ne: true
+    },
+    TWO_STRING_L_LT_R: {
+        lt: NO_SUCH_CASE,
+        lte: NO_SUCH_CASE,
+        gt: NO_SUCH_CASE,
+        gte: NO_SUCH_CASE,
+        eq: false,
+        ne: true
+    },
+    TWO_STRING_L_GT_R: {
+        lt: NO_SUCH_CASE,
+        lte: NO_SUCH_CASE,
+        gt: NO_SUCH_CASE,
+        gte: NO_SUCH_CASE,
+        eq: false,
+        ne: true
+    },
+    TWO_STRING_ONLY_NUMERIC_EQ: {
+        lt: NO_SUCH_CASE,
+        lte: NO_SUCH_CASE,
+        gt: NO_SUCH_CASE,
+        gte: NO_SUCH_CASE,
+        eq: false,
+        ne: true
+    },
+    STRICT_EQ: {
+        lt: false,
+        lte: true,
+        gt: false,
+        gte: true,
+        eq: true,
+        ne: false
+    },
+    ONE_NUMBER_NUMERIC_EQ: {
+        lt: false,
+        lte: true,
+        gt: false,
+        gte: true,
+        eq: true,
+        ne: false
+    },
+    BOTH_INCMPR_NOT_EQ: {
+        lt: false,
+        lte: false,
+        gt: false,
+        gte: false,
+        eq: false,
+        ne: true
+    },
+    ONLY_L_INCMPR: {
+        lt: false,
+        lte: false,
+        gt: false,
+        gte: false,
+        eq: false,
+        ne: true
+    },
+    ONLY_R_INCMPR: {
+        lt: false,
+        lte: false,
+        gt: false,
+        gte: false,
+        eq: false,
+        ne: true
+    }
+};
+
+const sortResultMap = {
+    ONE_OR_TWO_NUMBER_L_LT_R: {
+        asc_incmprmin: -1,
+        asc_incmprmax: -1,
+        desc_incmprmin: 1,
+        desc_incmprmax: 1
+    },
+    ONE_OR_TWO_NUMBER_L_GT_R: {
+        asc_incmprmin: 1,
+        asc_incmprmax: 1,
+        desc_incmprmin: -1,
+        desc_incmprmax: -1
+    },
+    TWO_STRING_L_LT_R: {
+        asc_incmprmin: -1,
+        asc_incmprmax: -1,
+        desc_incmprmin: 1,
+        desc_incmprmax: 1
+    },
+    TWO_STRING_L_GT_R: {
+        asc_incmprmin: 1,
+        asc_incmprmax: 1,
+        desc_incmprmin: -1,
+        desc_incmprmax: -1
+    },
+    TWO_STRING_ONLY_NUMERIC_EQ: {
+        asc_incmprmin: 0,
+        asc_incmprmax: 0,
+        desc_incmprmin: 0,
+        desc_incmprmax: 0
+    },
+    STRICT_EQ: {
+        asc_incmprmin: 0,
+        asc_incmprmax: 0,
+        desc_incmprmin: 0,
+        desc_incmprmax: 0
+    },
+    ONE_NUMBER_NUMERIC_EQ: {
+        asc_incmprmin: 0,
+        asc_incmprmax: 0,
+        desc_incmprmin: 0,
+        desc_incmprmax: 0
+    },
+    BOTH_INCMPR_NOT_EQ: {
+        asc_incmprmin: 0,
+        asc_incmprmax: 0,
+        desc_incmprmin: 0,
+        desc_incmprmax: 0
+    },
+    ONLY_L_INCMPR: {
+        asc_incmprmin: -1,
+        asc_incmprmax: 1,
+        desc_incmprmin: 1,
+        desc_incmprmax: -1
+    },
+    ONLY_R_INCMPR: {
+        asc_incmprmin: 1,
+        asc_incmprmax: -1,
+        desc_incmprmin: -1,
+        desc_incmprmax: 1
+    }
+};
+
+/**
+ * @param {(lval: unknown, rval: unknown, caseTag: TAG) => void} evalFn
+ */
+function eachRelationalComparisonCase(evalFn) {
+
+    const FULL_WIDTH_SPACE = String.fromCharCode(12288);
+
+    const testerMap = {
+        notEqualAndHasOrder: function () {
+            expectDual(123, 555, TAG.ONE_OR_TWO_NUMBER_L_LT_R);
+            expectDual(-123, -555, TAG.ONE_OR_TWO_NUMBER_L_GT_R);
+            expectDual(-123, 123, TAG.ONE_OR_TWO_NUMBER_L_LT_R);
 
-    describe('relational_comparison', function () {
+            expectDual(Infinity, 123, TAG.ONE_OR_TWO_NUMBER_L_GT_R);
+            expectDual(-Infinity, -123, TAG.ONE_OR_TWO_NUMBER_L_LT_R);
+            expectDual('Infinity', 123, TAG.ONE_OR_TWO_NUMBER_L_GT_R);
+            expectDual('-Infinity', 123, TAG.ONE_OR_TWO_NUMBER_L_LT_R);
+            expectDual(123, '555', TAG.ONE_OR_TWO_NUMBER_L_LT_R);
+            expectDual(555, '555.6', TAG.ONE_OR_TWO_NUMBER_L_LT_R);
+            expectDual('-555', -555.6, TAG.ONE_OR_TWO_NUMBER_L_GT_R);
+            expectDual(123, ' 555 ', TAG.ONE_OR_TWO_NUMBER_L_LT_R);
+            expectDual(' -555 ', 123, TAG.ONE_OR_TWO_NUMBER_L_LT_R);
+            expectDual(123, ' \r \n 555 \t ' + FULL_WIDTH_SPACE, 
TAG.ONE_OR_TWO_NUMBER_L_LT_R);
+        },
 
-        function expectDual(evalFn, lval, rval, resultLR, resultRL) {
-            expect(evalFn(lval, rval)).toEqual(resultLR);
-            expect(evalFn(rval, lval)).toEqual(resultRL);
+        notEqualAndNoOrder: function () {
+            const makeDate = () => new Date(2012, 5, 12);
+            const makeFn = () => function () {};
+
+            expectDual(NaN, NaN, TAG.BOTH_INCMPR_NOT_EQ);
+            expectDual(NaN, -NaN, TAG.BOTH_INCMPR_NOT_EQ);
+            expectDual(NaN, 0, TAG.ONLY_L_INCMPR);
+            expectDual(NaN, 2, TAG.ONLY_L_INCMPR);
+            expectDual('NaN', NaN, TAG.BOTH_INCMPR_NOT_EQ);
+            expectDual('NaN', 0, TAG.ONLY_L_INCMPR);
+            expectDual('NaN', 2, TAG.ONLY_L_INCMPR);
+            expectDual('-NaN', -NaN, TAG.BOTH_INCMPR_NOT_EQ);
+            expectDual('-NaN', 0, TAG.ONLY_L_INCMPR);
+            expectDual('-NaN', 2, TAG.ONLY_L_INCMPR);
+            expectDual(true, 0, TAG.ONLY_L_INCMPR);
+            expectDual(false, 1, TAG.ONLY_L_INCMPR);
+            expectDual('true', 0, TAG.ONLY_L_INCMPR);
+            expectDual('false', 1, TAG.ONLY_L_INCMPR);
+            expectDual(undefined, 2, TAG.ONLY_L_INCMPR);
+            expectDual(undefined, 0, TAG.ONLY_L_INCMPR);
+            expectDual(null, 2, TAG.ONLY_L_INCMPR);
+            expectDual(null, 0, TAG.ONLY_L_INCMPR);
+            expectDual(makeDate(), 0, TAG.ONLY_L_INCMPR);
+            expectDual(makeDate(), makeDate(), TAG.BOTH_INCMPR_NOT_EQ);
+            expectDual(makeDate(), +makeDate(), TAG.ONLY_L_INCMPR);
+            expectDual([], 1, TAG.ONLY_L_INCMPR);
+            expectDual([], 0, TAG.ONLY_L_INCMPR);
+            expectDual({}, 1, TAG.ONLY_L_INCMPR);
+            expectDual([], '0', TAG.ONLY_L_INCMPR);
+            expectDual({}, '1', TAG.ONLY_L_INCMPR);
+            expectDual({}, 0, TAG.ONLY_L_INCMPR);
+            expectDual({}, '1', TAG.ONLY_L_INCMPR);
+            expectDual({}, '0', TAG.ONLY_L_INCMPR);
+            expectDual(/1/, 0, TAG.ONLY_L_INCMPR);
+            expectDual(/0/, 0, TAG.ONLY_L_INCMPR);
+            expectDual('555a', 123, TAG.ONLY_L_INCMPR);
+            expectDual('abc', 123, TAG.ONLY_L_INCMPR);
+            expectDual('abc', '123', TAG.ONLY_L_INCMPR);
+            expectDual('abc', 'abcde', TAG.TWO_STRING_L_LT_R);
+            expectDual('abc', 'abc', TAG.STRICT_EQ);
+            expectDual('2', '12', TAG.TWO_STRING_L_LT_R); // '2' > '12' in JS 
but should not happen here.
+            expectDual(' ', '', TAG.TWO_STRING_L_GT_R);
+            expectDual(0.5, '0. 5', TAG.ONLY_R_INCMPR);
+            expectDual('0.5', '0. 5', TAG.ONLY_R_INCMPR);
+            expectDual('- 5', -5, TAG.ONLY_L_INCMPR);
+            expectDual('-123.5', ' -123.5 ', TAG.TWO_STRING_ONLY_NUMERIC_EQ);
+            expectDual('0x11', 17, TAG.ONLY_L_INCMPR); // not 17 in int16.
+            expectDual('0x11', 0, TAG.ONLY_L_INCMPR);
+            expectDual('0x0', 0, TAG.ONLY_L_INCMPR);
+            expectDual('0. 5', 0.5, TAG.ONLY_L_INCMPR);
+            expectDual('0 .5', 0.5, TAG.ONLY_L_INCMPR);
+            expectDual('', 2, TAG.ONLY_L_INCMPR);
+            expectDual('', 0, TAG.ONLY_L_INCMPR);
+            expectDual(' ', 2, TAG.ONLY_L_INCMPR);
+            expectDual(' ', 0, TAG.ONLY_L_INCMPR);
+            expectDual(' \n', '\n', TAG.TWO_STRING_L_GT_R);
+            expectDual('\n', 0, TAG.ONLY_L_INCMPR);
+            expectDual('\n', 2, TAG.ONLY_L_INCMPR);
+            expectDual({}, {}, TAG.BOTH_INCMPR_NOT_EQ);
+            expectDual({}, [], TAG.BOTH_INCMPR_NOT_EQ);
+            expectDual(makeFn(), makeFn(), TAG.BOTH_INCMPR_NOT_EQ);
+            expectDual(makeFn(), 0, TAG.ONLY_L_INCMPR);
+            expectDual(makeFn(), 1, TAG.ONLY_L_INCMPR);
+            expectDual(makeFn(), makeFn().toString(), TAG.BOTH_INCMPR_NOT_EQ);
+        },
+
+        equalNumeric: function () {
+            expectDual(123, 123, TAG.STRICT_EQ);
+            expectDual(1e3, 1000, TAG.STRICT_EQ);
+            expectDual(-1e3, -1000, TAG.STRICT_EQ);
+            expectDual('1e3', 1000, TAG.ONE_NUMBER_NUMERIC_EQ);
+            expectDual('-1e3', -1000, TAG.ONE_NUMBER_NUMERIC_EQ);
+            expectDual(123, '123', TAG.ONE_NUMBER_NUMERIC_EQ);
+            expectDual(123, ' 123 ', TAG.ONE_NUMBER_NUMERIC_EQ);
+            expectDual(123.5, ' \n \r 123.5 \t ', TAG.ONE_NUMBER_NUMERIC_EQ);
+            expectDual(123.5, 123.5 + FULL_WIDTH_SPACE, 
TAG.ONE_NUMBER_NUMERIC_EQ);
+            expectDual(' -123.5 ', -123.5, TAG.ONE_NUMBER_NUMERIC_EQ);
+            expectDual('011', 11, TAG.ONE_NUMBER_NUMERIC_EQ); // not 9 in int8.
+        },
+
+        equalOtherTypes: function () {
+            const emptyObj = {};
+            const emptyArr = [];
+            const date = new Date(2012, 5, 12);
+            const fn = function () {};
+            expectDual(emptyObj, emptyObj, TAG.STRICT_EQ);
+            expectDual(emptyArr, emptyArr, TAG.STRICT_EQ);
+            expectDual(date, date, TAG.STRICT_EQ);
+            expectDual(fn, fn, TAG.STRICT_EQ);
         }
+    };
+
+    function expectDual(lval, rval, caseTag) {
+        validateCaseTag(caseTag);
+        evalFn(lval, rval, caseTag);
+
+        const revertedCaseTag = findRevertTag(caseTag);
+        validateCaseTag(revertedCaseTag);
+        evalFn(rval, lval, revertedCaseTag);
+    }
+
+    function validateCaseTag(caseTag) {
+        expect(TAG.hasOwnProperty(caseTag)).toEqual(true);
+    }
 
-        const testerMap = {
-
-            notEqualAndHasOrder: function (evalFn, op) {
-                let asc;
-                let desc;
-                if (op === 'lt' || op === 'lte') {
-                    asc = true;
-                    desc = false;
-                }
-                else if (op === 'gt' || op === 'gte') {
-                    asc = false;
-                    desc = true;
-                }
-                else if (op === 'eq') {
-                    asc = desc = false;
-                }
-                else if (op === 'ne') {
-                    asc = desc = true;
-                }
-
-                expectDual(evalFn, 123, 555, asc, desc);
-                expectDual(evalFn, -123, -555, desc, asc);
-                expectDual(evalFn, -123, 123, asc, desc);
-
-                expectDual(evalFn, Infinity, 123, desc, asc);
-                expectDual(evalFn, -Infinity, -123, asc, desc);
-                expectDual(evalFn, 'Infinity', 123, desc, asc);
-                expectDual(evalFn, '-Infinity', 123, asc, desc);
-                expectDual(evalFn, 123, '555', asc, desc);
-                expectDual(evalFn, 555, '555.6', asc, desc);
-                expectDual(evalFn, '-555', -555.6, desc, asc);
-                expectDual(evalFn, 123, ' 555 ', asc, desc);
-                expectDual(evalFn, ' -555 ', 123, asc, desc);
-                expectDual(evalFn, 123, ' \r \n 555 \t ' + 
String.fromCharCode(12288), asc, desc);
-            },
-
-            notEqualAndNoOrder: function (evalFn, op) {
-                const result = op === 'ne';
-                const makeDate = () => new Date(2012, 5, 12);
-                const makeFn = () => function () {};
-
-                expectDual(evalFn, NaN, NaN, result, result);
-                expectDual(evalFn, NaN, -NaN, result, result);
-                expectDual(evalFn, NaN, 0, result, result);
-                expectDual(evalFn, NaN, 2, result, result);
-                expectDual(evalFn, 'NaN', NaN, result, result);
-                expectDual(evalFn, 'NaN', 0, result, result);
-                expectDual(evalFn, 'NaN', 2, result, result);
-                expectDual(evalFn, '-NaN', -NaN, result, result);
-                expectDual(evalFn, '-NaN', 0, result, result);
-                expectDual(evalFn, '-NaN', 2, result, result);
-                expectDual(evalFn, true, 0, result, result);
-                expectDual(evalFn, false, 1, result, result);
-                expectDual(evalFn, 'true', 0, result, result);
-                expectDual(evalFn, 'false', 1, result, result);
-                expectDual(evalFn, undefined, 2, result, result);
-                expectDual(evalFn, undefined, 0, result, result);
-                expectDual(evalFn, null, 2, result, result);
-                expectDual(evalFn, null, 0, result, result);
-                expectDual(evalFn, makeDate(), 0, result, result);
-                expectDual(evalFn, makeDate(), makeDate(), result, result);
-                expectDual(evalFn, makeDate(), +makeDate(), result, result);
-                expectDual(evalFn, [], 1, result, result);
-                expectDual(evalFn, [], 0, result, result);
-                expectDual(evalFn, {}, 1, result, result);
-                expectDual(evalFn, [], '0', result, result);
-                expectDual(evalFn, {}, '1', result, result);
-                expectDual(evalFn, {}, 0, result, result);
-                expectDual(evalFn, {}, '1', result, result);
-                expectDual(evalFn, {}, '0', result, result);
-                expectDual(evalFn, /1/, 0, result, result);
-                expectDual(evalFn, /0/, 0, result, result);
-                expectDual(evalFn, '555a', 123, result, result);
-                expectDual(evalFn, '2', '12', result, result); // '2' > '12' 
in JS but should not happen here.
-                expectDual(evalFn, ' ', '', result, result);
-                expectDual(evalFn, 0.5, '0. 5', result, result);
-                expectDual(evalFn, '0.5', '0. 5', result, result);
-                expectDual(evalFn, '- 5', -5, result, result);
-                expectDual(evalFn, '-123.5', ' -123.5 ', result, result);
-                expectDual(evalFn, '0x11', 17, result, result); // not 17 in 
int16.
-                expectDual(evalFn, '0x11', 0, result, result);
-                expectDual(evalFn, '0x0', 0, result, result);
-                expectDual(evalFn, '0. 5', 0.5, result, result);
-                expectDual(evalFn, '0 .5', 0.5, result, result);
-                expectDual(evalFn, '', 2, result, result);
-                expectDual(evalFn, '', 0, result, result);
-                expectDual(evalFn, ' ', 2, result, result);
-                expectDual(evalFn, ' ', 0, result, result);
-                expectDual(evalFn, ' \n', '\n', result, result);
-                expectDual(evalFn, '\n', 0, result, result);
-                expectDual(evalFn, '\n', 2, result, result);
-                expectDual(evalFn, {}, {}, result, result);
-                expectDual(evalFn, {}, [], result, result);
-                expectDual(evalFn, makeFn(), makeFn(), result, result);
-                expectDual(evalFn, makeFn(), 0, result, result);
-                expectDual(evalFn, makeFn(), 1, result, result);
-                expectDual(evalFn, makeFn(), makeFn().toString(), result, 
result);
-            },
-
-            numericEqual: function (evalFn, op) {
-                const result = op === 'eq' || op === 'lte' || op === 'gte';
-
-                expectDual(evalFn, 123, 123, result, result);
-                expectDual(evalFn, 1e3, 1000, result, result);
-                expectDual(evalFn, -1e3, -1000, result, result);
-                expectDual(evalFn, '1e3', 1000, result, result);
-                expectDual(evalFn, '-1e3', -1000, result, result);
-                expectDual(evalFn, 123, '123', result, result);
-                expectDual(evalFn, 123, ' 123 ', result, result);
-                expectDual(evalFn, 123.5, ' \n \r 123.5 \t ', result, result);
-                expectDual(evalFn, 123.5, 123.5 + String.fromCharCode(12288), 
result, result);
-                expectDual(evalFn, ' -123.5 ', -123.5, result, result);
-                expectDual(evalFn, '011', 11, result, result); // not 9 in 
int8.
-            },
-
-            otherTypesEqual: function (evalFn, op) {
-                const result = op === 'eq';
-
-                const emptyObj = {};
-                const emptyArr = [];
-                const date = new Date(2012, 5, 12);
-                const fn = function () {};
-                expectDual(evalFn, emptyObj, emptyObj, result, result);
-                expectDual(evalFn, emptyArr, emptyArr, result, result);
-                expectDual(evalFn, date, date, result, result);
-                expectDual(evalFn, fn, fn, result, result);
+    function findRevertTag(caseTag) {
+        for (let i = 0; i < tagRevertPairs.length; i++) {
+            const item = tagRevertPairs[i];
+            if (item[0] === caseTag) {
+                return item[1];
             }
-        };
-
-        function doTest(op) {
-            expect(['lt', 'lte', 'gt', 'gte', 'eq', 'ne'].indexOf(op) >= 
0).toEqual(true);
-            it(op, () => {
-                const comparator0 = 
dataValueHelper.createRelationalComparator(op);
-                Object.keys(testerMap).forEach(name => {
-                    const evalFn = (lVal, rVal) => {
-                        return comparator0.evaluate(lVal, rVal);
-                    };
-                    testerMap[name](evalFn, op);
-                });
+            else if (item[1] === caseTag) {
+                return item[0];
+            }
+        }
+    }
+
+    Object.keys(testerMap).forEach(name => testerMap[name]());
+}
+
+
+describe('data/helper/dataValueHelper', function () {
 
-                Object.keys(testerMap).forEach(name => {
-                    const evalFn = (lVal, rVal) => {
-                        const comparator1 = 
dataValueHelper.createRelationalComparator(op, true, rVal);
-                        return comparator1.evaluate(lVal);
-                    };
-                    testerMap[name](evalFn, op);
+    describe('filter_relational_comparison', function () {
+        function testFilterComparator(op) {
+            it(op + '_filter_comparator', () => {
+                eachRelationalComparisonCase((lval, rval, caseTag) => {
+                    expect(filterResultMap.hasOwnProperty[caseTag]);
+                    expect(filterResultMap[caseTag].hasOwnProperty[op]);
+                    const expectedResult = filterResultMap[caseTag][op];
+
+                    if ((op === 'lt' || op === 'lte' || op === 'gt' || op === 
'gte')
+                        && typeof rval !== 'number'
+                    ) {
+                        expect(() => {
+                            dataValueHelper.createFilterComparator(op, rval);
+                        }).toThrow();
+                    }
+                    else {
+                        const comparator = 
dataValueHelper.createFilterComparator(op, rval);
+                        expect(comparator.evaluate(lval, 
rval)).toEqual(expectedResult);
+                    }
                 });
             });
         }
+        testFilterComparator('lt');
+        testFilterComparator('lte');
+        testFilterComparator('gt');
+        testFilterComparator('gte');
+        testFilterComparator('eq');
+        testFilterComparator('ne');
+    });
 
-        doTest('lt');
-        doTest('lte');
-        doTest('gt');
-        doTest('gte');
-        doTest('eq');
-        doTest('ne');
-
-        it('isRelationalOperator', function () {
-            expect(dataValueHelper.isRelationalOperator('lt')).toEqual(true);
-            expect(dataValueHelper.isRelationalOperator('lte')).toEqual(true);
-            expect(dataValueHelper.isRelationalOperator('gt')).toEqual(true);
-            expect(dataValueHelper.isRelationalOperator('gte')).toEqual(true);
-            expect(dataValueHelper.isRelationalOperator('eq')).toEqual(true);
-            expect(dataValueHelper.isRelationalOperator('ne')).toEqual(true);
-            expect(dataValueHelper.isRelationalOperator('')).toEqual(false);
-
-            expect(dataValueHelper.isRelationalOperator(null)).toEqual(false);
-            
expect(dataValueHelper.isRelationalOperator(undefined)).toEqual(false);
-            expect(dataValueHelper.isRelationalOperator(NaN)).toEqual(false);
-            expect(dataValueHelper.isRelationalOperator('neq')).toEqual(false);
-            expect(dataValueHelper.isRelationalOperator('ge')).toEqual(false);
-            expect(dataValueHelper.isRelationalOperator('le')).toEqual(false);
-        });
-
+    describe('sort_relational_comparison', function () {
+        function testSortComparator(order, incomparable) {
+            const key = order + '_incmpr' + incomparable;
+            const SortOrderComparator = dataValueHelper.SortOrderComparator;
+            const sortOrderComparator = new SortOrderComparator(order, 
incomparable);
+            it(key + '_sort_comparator', () => {
+                eachRelationalComparisonCase((lval, rval, caseTag) => {
+                    expect(sortResultMap.hasOwnProperty[caseTag]);
+                    expect(sortResultMap[caseTag].hasOwnProperty[key]);
+                    const expectedResult = sortResultMap[caseTag][key];
+                    expect(sortOrderComparator.evaluate(lval, 
rval)).toEqual(expectedResult);
+                });
+            });
+        }
+        testSortComparator('asc', 'min');
+        testSortComparator('asc', 'max');
+        testSortComparator('desc', 'min');
+        testSortComparator('desc', 'max');
     });
 
 });


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@echarts.apache.org
For additional commands, e-mail: commits-h...@echarts.apache.org

Reply via email to