import 8.3.0 source

[pve-eslint.git] / eslint / tests / lib / rules / use-isnan.js

diff --git a/eslint/tests/lib/rules/use-isnan.js b/eslint/tests/lib/rules/use-isnan.js
index c5a4b6bd6863e368f6c6bf8e23a68703bcb4de38..a9bfe3a67d7a4bfacc1725f4d93dde7f03b152e2 100644 (file)
--- a/eslint/tests/lib/rules/use-isnan.js
+++ b/eslint/tests/lib/rules/use-isnan.js
@@ -36,6 +36,19 @@ ruleTester.run("use-isnan", rule, {
         "foo(NaN / 2)",
         "foo(2 / NaN)",
         "var x; if (x = NaN) { }",
+        "var x = Number.NaN;",
+        "isNaN(Number.NaN) === true;",
+        "Number.isNaN(Number.NaN) === true;",
+        "foo(Number.NaN + 1);",
+        "foo(1 + Number.NaN);",
+        "foo(Number.NaN - 1)",
+        "foo(1 - Number.NaN)",
+        "foo(Number.NaN * 2)",
+        "foo(2 * Number.NaN)",
+        "foo(Number.NaN / 2)",
+        "foo(2 / Number.NaN)",
+        "var x; if (x = Number.NaN) { }",
+        "x === Number[NaN];",
 
         //------------------------------------------------------------------------------
         // enforceForSwitchCase
@@ -105,6 +118,62 @@ ruleTester.run("use-isnan", rule, {
             code: "switch(foo) { case bar: break; case 1: break; default: break; }",
             options: [{ enforceForSwitchCase: true }]
         },
+        {
+            code: "switch(Number.NaN) { case foo: break; }",
+            options: [{ enforceForSwitchCase: false }]
+        },
+        {
+            code: "switch(foo) { case Number.NaN: break; }",
+            options: [{ enforceForSwitchCase: false }]
+        },
+        {
+            code: "switch(NaN) { case Number.NaN: break; }",
+            options: [{ enforceForSwitchCase: false }]
+        },
+        {
+            code: "switch(foo) { case bar: break; case Number.NaN: break; default: break; }",
+            options: [{ enforceForSwitchCase: false }]
+        },
+        {
+            code: "switch(foo) { case bar: Number.NaN; }",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch(foo) { default: Number.NaN; }",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch(Number.Nan) {}",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch('Number.NaN') { default: break; }",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch(foo(Number.NaN)) {}",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch(foo.Number.NaN) {}",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch(foo) { case Number.Nan: break }",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch(foo) { case 'Number.NaN': break }",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch(foo) { case foo(Number.NaN): break }",
+            options: [{ enforceForSwitchCase: true }]
+        },
+        {
+            code: "switch(foo) { case foo.Number.NaN: break }",
+            options: [{ enforceForSwitchCase: true }]
+        },
 
         //------------------------------------------------------------------------------
         // enforceForIndexOf
@@ -112,6 +181,8 @@ ruleTester.run("use-isnan", rule, {
 
         "foo.indexOf(NaN)",
         "foo.lastIndexOf(NaN)",
+        "foo.indexOf(Number.NaN)",
+        "foo.lastIndexOf(Number.NaN)",
         {
             code: "foo.indexOf(NaN)",
             options: [{}]
@@ -200,6 +271,79 @@ ruleTester.run("use-isnan", rule, {
         {
             code: "foo.lastIndexOf(NaN())",
             options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo.indexOf(Number.NaN)",
+            options: [{}]
+        },
+        {
+            code: "foo.lastIndexOf(Number.NaN)",
+            options: [{}]
+        },
+        {
+            code: "foo.indexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: false }]
+        },
+        {
+            code: "foo.lastIndexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: false }]
+        },
+        {
+            code: "indexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "lastIndexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "new foo.indexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo.bar(Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo.IndexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo[indexOf](Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo[lastIndexOf](Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "indexOf.foo(Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo.lastIndexOf(Number.Nan)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo.indexOf(a, Number.NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo.lastIndexOf(Number.NaN, b)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo.lastIndexOf(Number.NaN, NaN)",
+            options: [{ enforceForIndexOf: true }]
+        },
+        {
+            code: "foo.indexOf(...Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            parserOptions: { ecmaVersion: 6 }
+        },
+        {
+            code: "foo.lastIndexOf(Number.NaN())",
+            options: [{ enforceForIndexOf: true }]
         }
     ],
     invalid: [
@@ -267,6 +411,79 @@ ruleTester.run("use-isnan", rule, {
             code: "\"abc\" >= NaN;",
             errors: [comparisonError]
         },
+        {
+            code: "123 == Number.NaN;",
+            errors: [comparisonError]
+        },
+        {
+            code: "123 === Number.NaN;",
+            errors: [comparisonError]
+        },
+        {
+            code: "Number.NaN === \"abc\";",
+            errors: [comparisonError]
+        },
+        {
+            code: "Number.NaN == \"abc\";",
+            errors: [comparisonError]
+        },
+        {
+            code: "123 != Number.NaN;",
+            errors: [comparisonError]
+        },
+        {
+            code: "123 !== Number.NaN;",
+            errors: [comparisonError]
+        },
+        {
+            code: "Number.NaN !== \"abc\";",
+            errors: [comparisonError]
+        },
+        {
+            code: "Number.NaN != \"abc\";",
+            errors: [comparisonError]
+        },
+        {
+            code: "Number.NaN < \"abc\";",
+            errors: [comparisonError]
+        },
+        {
+            code: "\"abc\" < Number.NaN;",
+            errors: [comparisonError]
+        },
+        {
+            code: "Number.NaN > \"abc\";",
+            errors: [comparisonError]
+        },
+        {
+            code: "\"abc\" > Number.NaN;",
+            errors: [comparisonError]
+        },
+        {
+            code: "Number.NaN <= \"abc\";",
+            errors: [comparisonError]
+        },
+        {
+            code: "\"abc\" <= Number.NaN;",
+            errors: [comparisonError]
+        },
+        {
+            code: "Number.NaN >= \"abc\";",
+            errors: [comparisonError]
+        },
+        {
+            code: "\"abc\" >= Number.NaN;",
+            errors: [comparisonError]
+        },
+        {
+            code: "x === Number?.NaN;",
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [comparisonError]
+        },
+        {
+            code: "x === Number['NaN'];",
+            errors: [comparisonError]
+        },
 
         //------------------------------------------------------------------------------
         // enforceForSwitchCase
@@ -351,6 +568,85 @@ ruleTester.run("use-isnan", rule, {
                 { messageId: "caseNaN", type: "SwitchCase", column: 15 }
             ]
         },
+        {
+            code: "switch(Number.NaN) { case foo: break; }",
+            errors: [{ messageId: "switchNaN", type: "SwitchStatement", column: 1 }]
+        },
+        {
+            code: "switch(foo) { case Number.NaN: break; }",
+            errors: [{ messageId: "caseNaN", type: "SwitchCase", column: 15 }]
+        },
+        {
+            code: "switch(Number.NaN) { case foo: break; }",
+            options: [{}],
+            errors: [{ messageId: "switchNaN", type: "SwitchStatement", column: 1 }]
+        },
+        {
+            code: "switch(foo) { case Number.NaN: break; }",
+            options: [{}],
+            errors: [{ messageId: "caseNaN", type: "SwitchCase", column: 15 }]
+        },
+        {
+            code: "switch(Number.NaN) {}",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "switchNaN", type: "SwitchStatement", column: 1 }]
+        },
+        {
+            code: "switch(Number.NaN) { case foo: break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "switchNaN", type: "SwitchStatement", column: 1 }]
+        },
+        {
+            code: "switch(Number.NaN) { default: break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "switchNaN", type: "SwitchStatement", column: 1 }]
+        },
+        {
+            code: "switch(Number.NaN) { case foo: break; default: break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "switchNaN", type: "SwitchStatement", column: 1 }]
+        },
+        {
+            code: "switch(foo) { case Number.NaN: }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "caseNaN", type: "SwitchCase", column: 15 }]
+        },
+        {
+            code: "switch(foo) { case Number.NaN: break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "caseNaN", type: "SwitchCase", column: 15 }]
+        },
+        {
+            code: "switch(foo) { case (Number.NaN): break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "caseNaN", type: "SwitchCase", column: 15 }]
+        },
+        {
+            code: "switch(foo) { case bar: break; case Number.NaN: break; default: break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "caseNaN", type: "SwitchCase", column: 32 }]
+        },
+        {
+            code: "switch(foo) { case bar: case Number.NaN: default: break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [{ messageId: "caseNaN", type: "SwitchCase", column: 25 }]
+        },
+        {
+            code: "switch(foo) { case bar: break; case NaN: break; case baz: break; case Number.NaN: break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [
+                { messageId: "caseNaN", type: "SwitchCase", column: 32 },
+                { messageId: "caseNaN", type: "SwitchCase", column: 66 }
+            ]
+        },
+        {
+            code: "switch(Number.NaN) { case Number.NaN: break; }",
+            options: [{ enforceForSwitchCase: true }],
+            errors: [
+                { messageId: "switchNaN", type: "SwitchStatement", column: 1 },
+                { messageId: "caseNaN", type: "SwitchCase", column: 22 }
+            ]
+        },
 
         //------------------------------------------------------------------------------
         // enforceForIndexOf
@@ -403,6 +699,54 @@ ruleTester.run("use-isnan", rule, {
             options: [{ enforceForIndexOf: true }],
             parserOptions: { ecmaVersion: 2020 },
             errors: [{ messageId: "indexOfNaN", data: { methodName: "indexOf" } }]
+        },
+        {
+            code: "foo.indexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            errors: [{ messageId: "indexOfNaN", type: "CallExpression", data: { methodName: "indexOf" } }]
+        },
+        {
+            code: "foo.lastIndexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            errors: [{ messageId: "indexOfNaN", type: "CallExpression", data: { methodName: "lastIndexOf" } }]
+        },
+        {
+            code: "foo['indexOf'](Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            errors: [{ messageId: "indexOfNaN", type: "CallExpression", data: { methodName: "indexOf" } }]
+        },
+        {
+            code: "foo['lastIndexOf'](Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            errors: [{ messageId: "indexOfNaN", type: "CallExpression", data: { methodName: "lastIndexOf" } }]
+        },
+        {
+            code: "foo().indexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            errors: [{ messageId: "indexOfNaN", type: "CallExpression", data: { methodName: "indexOf" } }]
+        },
+        {
+            code: "foo.bar.lastIndexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            errors: [{ messageId: "indexOfNaN", type: "CallExpression", data: { methodName: "lastIndexOf" } }]
+        },
+        {
+            code: "foo.indexOf?.(Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [{ messageId: "indexOfNaN", data: { methodName: "indexOf" } }]
+        },
+        {
+            code: "foo?.indexOf(Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [{ messageId: "indexOfNaN", data: { methodName: "indexOf" } }]
+        },
+        {
+            code: "(foo?.indexOf)(Number.NaN)",
+            options: [{ enforceForIndexOf: true }],
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [{ messageId: "indexOfNaN", data: { methodName: "indexOf" } }]
         }
     ]
 });