From 2dae17fb87f26cf8ac8751db316b0bed87b96948 Mon Sep 17 00:00:00 2001 From: dslomov Date: Wed, 19 Nov 2014 16:31:59 -0800 Subject: [PATCH] Rename String.prototype.contains to 'includes'. Per TC39 Nov 2014 decison. R=arv@chromium.org,yangguo@chromium.org LOG=Y Review URL: https://codereview.chromium.org/742963002 Cr-Commit-Position: refs/heads/master@{#25430} --- src/harmony-string.js | 8 +- test/js-perf-test/Strings/harmony-string.js | 10 +- test/mjsunit/harmony/string-contains.js | 166 -------------------- test/mjsunit/harmony/string-includes.js | 166 ++++++++++++++++++++ 4 files changed, 175 insertions(+), 175 deletions(-) delete mode 100644 test/mjsunit/harmony/string-contains.js create mode 100644 test/mjsunit/harmony/string-includes.js diff --git a/src/harmony-string.js b/src/harmony-string.js index 1c477e2fa5..c4717df5db 100644 --- a/src/harmony-string.js +++ b/src/harmony-string.js @@ -95,14 +95,14 @@ function StringEndsWith(searchString /* position */) { // length == 1 // ES6 draft 04-05-14, section 21.1.3.6 -function StringContains(searchString /* position */) { // length == 1 - CHECK_OBJECT_COERCIBLE(this, "String.prototype.contains"); +function StringIncludes(searchString /* position */) { // length == 1 + CHECK_OBJECT_COERCIBLE(this, "String.prototype.includes"); var s = TO_STRING_INLINE(this); if (IS_REGEXP(searchString)) { throw MakeTypeError("first_argument_not_regexp", - ["String.prototype.contains"]); + ["String.prototype.includes"]); } var ss = TO_STRING_INLINE(searchString); @@ -184,7 +184,7 @@ function ExtendStringPrototype() { // Set up the non-enumerable functions on the String prototype object. InstallFunctions($String.prototype, DONT_ENUM, $Array( "codePointAt", StringCodePointAt, - "contains", StringContains, + "includes", StringIncludes, "endsWith", StringEndsWith, "repeat", StringRepeat, "startsWith", StringStartsWith diff --git a/test/js-perf-test/Strings/harmony-string.js b/test/js-perf-test/Strings/harmony-string.js index f430ab4578..c2eac4ee33 100644 --- a/test/js-perf-test/Strings/harmony-string.js +++ b/test/js-perf-test/Strings/harmony-string.js @@ -9,8 +9,8 @@ new BenchmarkSuite('StringFunctions', [1000], [ StartsWith, WithSetup, WithTearDown), new Benchmark('StringEndsWith', false, false, 0, EndsWith, WithSetup, WithTearDown), - new Benchmark('StringContains', false, false, 0, - Contains, ContainsSetup, WithTearDown), + new Benchmark('StringIncludes', false, false, 0, + Includes, IncludesSetup, WithTearDown), new Benchmark('StringFromCodePoint', false, false, 0, FromCodePoint, FromCodePointSetup, FromCodePointTearDown), new Benchmark('StringCodePointAt', false, false, 0, @@ -60,13 +60,13 @@ function EndsWith() { result = str.endsWith(substr); } -function ContainsSetup() { +function IncludesSetup() { str = "def".repeat(100) + "abc".repeat(100) + "qqq".repeat(100); substr = "abc".repeat(100); } -function Contains() { - result = str.contains(substr); +function Includes() { + result = str.includes(substr); } var MAX_CODE_POINT = 0xFFFFF; diff --git a/test/mjsunit/harmony/string-contains.js b/test/mjsunit/harmony/string-contains.js deleted file mode 100644 index b853ed99f7..0000000000 --- a/test/mjsunit/harmony/string-contains.js +++ /dev/null @@ -1,166 +0,0 @@ -// Copyright 2013 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Flags: --harmony-strings - -assertEquals(1, String.prototype.contains.length); - -var reString = "asdf[a-z]+(asdf)?"; -assertTrue(reString.contains("[a-z]+")); -assertTrue(reString.contains("(asdf)?")); - -// Random greek letters -var twoByteString = "\u039a\u0391\u03a3\u03a3\u0395"; - -// Test single char pattern -assertTrue(twoByteString.contains("\u039a"), "Lamda"); -assertTrue(twoByteString.contains("\u0391"), "Alpha"); -assertTrue(twoByteString.contains("\u03a3"), "First Sigma"); -assertTrue(twoByteString.contains("\u03a3",3), "Second Sigma"); -assertTrue(twoByteString.contains("\u0395"), "Epsilon"); -assertFalse(twoByteString.contains("\u0392"), "Not beta"); - -// Test multi-char pattern -assertTrue(twoByteString.contains("\u039a\u0391"), "lambda Alpha"); -assertTrue(twoByteString.contains("\u0391\u03a3"), "Alpha Sigma"); -assertTrue(twoByteString.contains("\u03a3\u03a3"), "Sigma Sigma"); -assertTrue(twoByteString.contains("\u03a3\u0395"), "Sigma Epsilon"); - -assertFalse(twoByteString.contains("\u0391\u03a3\u0395"), - "Not Alpha Sigma Epsilon"); - -//single char pattern -assertTrue(twoByteString.contains("\u0395")); - -assertThrows("String.prototype.contains.call(null, 'test')", TypeError); -assertThrows("String.prototype.contains.call(null, null)", TypeError); -assertThrows("String.prototype.contains.call(undefined, undefined)", TypeError); - -assertThrows("String.prototype.contains.apply(null, ['test'])", TypeError); -assertThrows("String.prototype.contains.apply(null, [null])", TypeError); -assertThrows("String.prototype.contains.apply(undefined, [undefined])", TypeError); - -var TEST_INPUT = [{ - msg: "Empty string", val: "" -}, { - msg: "Number 1234.34", val: 1234.34 -}, { - msg: "Integer number 0", val: 0 -}, { - msg: "Negative number -1", val: -1 -}, { - msg: "Boolean true", val: true -}, { - msg: "Boolean false", val: false -}, { - msg: "Empty array []", val: [] -}, { - msg: "Empty object {}", val: {} -}, { - msg: "Array of size 3", val: new Array(3) -}]; - -var i = 0; -var l = TEST_INPUT.length; - -for (; i < l; i++) { - var e = TEST_INPUT[i]; - var v = e.val; - var s = String(v); - assertTrue(s.contains(v), e.msg); - assertTrue(String.prototype.contains.call(v, v), e.msg); - assertTrue(String.prototype.contains.apply(v, [v]), e.msg); -} - -// Test cases found in FF -assertTrue("abc".contains("a")); -assertTrue("abc".contains("b")); -assertTrue("abc".contains("abc")); -assertTrue("abc".contains("bc")); -assertFalse("abc".contains("d")); -assertFalse("abc".contains("abcd")); -assertFalse("abc".contains("ac")); -assertTrue("abc".contains("abc", 0)); -assertTrue("abc".contains("bc", 0)); -assertFalse("abc".contains("de", 0)); -assertTrue("abc".contains("bc", 1)); -assertTrue("abc".contains("c", 1)); -assertFalse("abc".contains("a", 1)); -assertFalse("abc".contains("abc", 1)); -assertTrue("abc".contains("c", 2)); -assertFalse("abc".contains("d", 2)); -assertFalse("abc".contains("dcd", 2)); -assertFalse("abc".contains("a", 42)); -assertFalse("abc".contains("a", Infinity)); -assertTrue("abc".contains("ab", -43)); -assertFalse("abc".contains("cd", -42)); -assertTrue("abc".contains("ab", -Infinity)); -assertFalse("abc".contains("cd", -Infinity)); -assertTrue("abc".contains("ab", NaN)); -assertFalse("abc".contains("cd", NaN)); -assertFalse("xyzzy".contains("zy\0", 2)); - -var dots = Array(10000).join("."); -assertFalse(dots.contains("\x01", 10000)); -assertFalse(dots.contains("\0", 10000)); - -var myobj = { - toString: function () { - return "abc"; - }, - contains: String.prototype.contains -}; -assertTrue(myobj.contains("abc")); -assertFalse(myobj.contains("cd")); - -var gotStr = false; -var gotPos = false; -myobj = { - toString: function () { - assertFalse(gotPos); - gotStr = true; - return "xyz"; - }, - contains: String.prototype.contains -}; - -assertEquals("foo[a-z]+(bar)?".contains("[a-z]+"), true); -assertThrows("'foo[a-z]+(bar)?'.contains(/[a-z]+/)", TypeError); -assertThrows("'foo/[a-z]+/(bar)?'.contains(/[a-z]+/)", TypeError); -assertEquals("foo[a-z]+(bar)?".contains("(bar)?"), true); -assertThrows("'foo[a-z]+(bar)?'.contains(/(bar)?/)", TypeError); -assertThrows("'foo[a-z]+/(bar)?/'.contains(/(bar)?/)", TypeError); - -assertThrows("String.prototype.contains.call({ 'toString': function() { " + - "throw RangeError(); } }, /./)", RangeError); -assertThrows("String.prototype.contains.call({ 'toString': function() { " + - "return 'abc'; } }, /./)", TypeError); - -assertThrows("String.prototype.contains.apply({ 'toString': function() { " + - "throw RangeError(); } }, [/./])", RangeError); -assertThrows("String.prototype.contains.apply({ 'toString': function() { " + - "return 'abc'; } }, [/./])", TypeError); diff --git a/test/mjsunit/harmony/string-includes.js b/test/mjsunit/harmony/string-includes.js new file mode 100644 index 0000000000..33ed8ea44c --- /dev/null +++ b/test/mjsunit/harmony/string-includes.js @@ -0,0 +1,166 @@ +// Copyright 2013 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony-strings + +assertEquals(1, String.prototype.includes.length); + +var reString = "asdf[a-z]+(asdf)?"; +assertTrue(reString.includes("[a-z]+")); +assertTrue(reString.includes("(asdf)?")); + +// Random greek letters +var twoByteString = "\u039a\u0391\u03a3\u03a3\u0395"; + +// Test single char pattern +assertTrue(twoByteString.includes("\u039a"), "Lamda"); +assertTrue(twoByteString.includes("\u0391"), "Alpha"); +assertTrue(twoByteString.includes("\u03a3"), "First Sigma"); +assertTrue(twoByteString.includes("\u03a3",3), "Second Sigma"); +assertTrue(twoByteString.includes("\u0395"), "Epsilon"); +assertFalse(twoByteString.includes("\u0392"), "Not beta"); + +// Test multi-char pattern +assertTrue(twoByteString.includes("\u039a\u0391"), "lambda Alpha"); +assertTrue(twoByteString.includes("\u0391\u03a3"), "Alpha Sigma"); +assertTrue(twoByteString.includes("\u03a3\u03a3"), "Sigma Sigma"); +assertTrue(twoByteString.includes("\u03a3\u0395"), "Sigma Epsilon"); + +assertFalse(twoByteString.includes("\u0391\u03a3\u0395"), + "Not Alpha Sigma Epsilon"); + +//single char pattern +assertTrue(twoByteString.includes("\u0395")); + +assertThrows("String.prototype.includes.call(null, 'test')", TypeError); +assertThrows("String.prototype.includes.call(null, null)", TypeError); +assertThrows("String.prototype.includes.call(undefined, undefined)", TypeError); + +assertThrows("String.prototype.includes.apply(null, ['test'])", TypeError); +assertThrows("String.prototype.includes.apply(null, [null])", TypeError); +assertThrows("String.prototype.includes.apply(undefined, [undefined])", TypeError); + +var TEST_INPUT = [{ + msg: "Empty string", val: "" +}, { + msg: "Number 1234.34", val: 1234.34 +}, { + msg: "Integer number 0", val: 0 +}, { + msg: "Negative number -1", val: -1 +}, { + msg: "Boolean true", val: true +}, { + msg: "Boolean false", val: false +}, { + msg: "Empty array []", val: [] +}, { + msg: "Empty object {}", val: {} +}, { + msg: "Array of size 3", val: new Array(3) +}]; + +var i = 0; +var l = TEST_INPUT.length; + +for (; i < l; i++) { + var e = TEST_INPUT[i]; + var v = e.val; + var s = String(v); + assertTrue(s.includes(v), e.msg); + assertTrue(String.prototype.includes.call(v, v), e.msg); + assertTrue(String.prototype.includes.apply(v, [v]), e.msg); +} + +// Test cases found in FF +assertTrue("abc".includes("a")); +assertTrue("abc".includes("b")); +assertTrue("abc".includes("abc")); +assertTrue("abc".includes("bc")); +assertFalse("abc".includes("d")); +assertFalse("abc".includes("abcd")); +assertFalse("abc".includes("ac")); +assertTrue("abc".includes("abc", 0)); +assertTrue("abc".includes("bc", 0)); +assertFalse("abc".includes("de", 0)); +assertTrue("abc".includes("bc", 1)); +assertTrue("abc".includes("c", 1)); +assertFalse("abc".includes("a", 1)); +assertFalse("abc".includes("abc", 1)); +assertTrue("abc".includes("c", 2)); +assertFalse("abc".includes("d", 2)); +assertFalse("abc".includes("dcd", 2)); +assertFalse("abc".includes("a", 42)); +assertFalse("abc".includes("a", Infinity)); +assertTrue("abc".includes("ab", -43)); +assertFalse("abc".includes("cd", -42)); +assertTrue("abc".includes("ab", -Infinity)); +assertFalse("abc".includes("cd", -Infinity)); +assertTrue("abc".includes("ab", NaN)); +assertFalse("abc".includes("cd", NaN)); +assertFalse("xyzzy".includes("zy\0", 2)); + +var dots = Array(10000).join("."); +assertFalse(dots.includes("\x01", 10000)); +assertFalse(dots.includes("\0", 10000)); + +var myobj = { + toString: function () { + return "abc"; + }, + includes: String.prototype.includes +}; +assertTrue(myobj.includes("abc")); +assertFalse(myobj.includes("cd")); + +var gotStr = false; +var gotPos = false; +myobj = { + toString: function () { + assertFalse(gotPos); + gotStr = true; + return "xyz"; + }, + includes: String.prototype.includes +}; + +assertEquals("foo[a-z]+(bar)?".includes("[a-z]+"), true); +assertThrows("'foo[a-z]+(bar)?'.includes(/[a-z]+/)", TypeError); +assertThrows("'foo/[a-z]+/(bar)?'.includes(/[a-z]+/)", TypeError); +assertEquals("foo[a-z]+(bar)?".includes("(bar)?"), true); +assertThrows("'foo[a-z]+(bar)?'.includes(/(bar)?/)", TypeError); +assertThrows("'foo[a-z]+/(bar)?/'.includes(/(bar)?/)", TypeError); + +assertThrows("String.prototype.includes.call({ 'toString': function() { " + + "throw RangeError(); } }, /./)", RangeError); +assertThrows("String.prototype.includes.call({ 'toString': function() { " + + "return 'abc'; } }, /./)", TypeError); + +assertThrows("String.prototype.includes.apply({ 'toString': function() { " + + "throw RangeError(); } }, [/./])", RangeError); +assertThrows("String.prototype.includes.apply({ 'toString': function() { " + + "return 'abc'; } }, [/./])", TypeError);