fix order of arguments validation in String.prototype.{ padStart, padEnd } polyfills

Author: zloirock

CHANGELOG.md

@@ -25,6 +25,7 @@
 - Fixed iterator closing in `Set.prototype.{ isDisjointFrom, isSupersetOf }` polyfill
 - Fixed (updated following the final spec) one more case `Set.prototype.difference` polyfill with updating `this`
 - Fixed `DataView.prototype.setFloat16` polyfill in (0, 1) range
+- Fixed order of arguments validation in `String.prototype.{ padStart, padEnd }` polyfills
 - Fixed order of arguments validation in `String.prototype.{ startsWith, endsWith }` polyfills
 - Fixed some cases of `Infinity` handling in `String.prototype.substr` polyfill
 - Fixed `String.prototype.repeat` polyfill with a counter exceeding 2 ** 32

packages/core-js/internals/string-pad.js

@@ -15,9 +15,10 @@ var createMethod = function (IS_END) {
     var S = toString(requireObjectCoercible($this));
     var intMaxLength = toLength(maxLength);
     var stringLength = S.length;
+    if (intMaxLength <= stringLength) return S;
     var fillStr = fillString === undefined ? ' ' : toString(fillString);
     var fillLen, stringFiller;
-    if (intMaxLength <= stringLength || fillStr === '') return S;
+    if (fillStr === '') return S;
     fillLen = intMaxLength - stringLength;
     stringFiller = repeat(fillStr, ceil(fillLen / fillStr.length));
     if (stringFiller.length > fillLen) stringFiller = stringSlice(stringFiller, 0, fillLen);

tests/unit-global/es.string.pad-end.js

@@ -15,9 +15,14 @@ QUnit.test('String#padEnd', assert => {
   assert.same('foo'.padEnd(1), 'foo');
   assert.same('foo'.padEnd(5, ''), 'foo');
 
+  const thrower = { toString() { throw new Error('oops'); } };
+  assert.throws(() => 'a'.padEnd(10, thrower), 'throws on thrower argument conversion');
+  assert.same('abc'.padEnd(2, thrower), 'abc', 'does not throw on thrower argument when no padding needed');
+
   const symbol = Symbol('padEnd test');
   assert.throws(() => padEnd.call(symbol, 10, 'a'), 'throws on symbol context');
   assert.throws(() => padEnd.call('a', 10, symbol), 'throws on symbol argument');
+  assert.same('abc'.padEnd(2, symbol), 'abc', 'does not throw on symbol fillString when no padding needed');
 
   if (STRICT) {
     assert.throws(() => padEnd.call(null, 0), TypeError);

tests/unit-global/es.string.pad-start.js

@@ -15,9 +15,14 @@ QUnit.test('String#padStart', assert => {
   assert.same('foo'.padStart(1), 'foo');
   assert.same('foo'.padStart(5, ''), 'foo');
 
+  const thrower = { toString() { throw new Error('oops'); } };
+  assert.throws(() => 'a'.padStart(10, thrower), 'throws on thrower argument conversion');
+  assert.same('abc'.padStart(2, thrower), 'abc', 'does not throw on thrower argument when no padding needed');
+
   const symbol = Symbol('padStart test');
   assert.throws(() => padStart.call(symbol, 10, 'a'), 'throws on symbol context');
   assert.throws(() => padStart.call('a', 10, symbol), 'throws on symbol argument');
+  assert.same('abc'.padStart(2, symbol), 'abc', 'does not throw on symbol fillString when no padding needed');
 
   if (STRICT) {
     assert.throws(() => padStart.call(null, 0), TypeError);

tests/unit-pure/es.string.pad-end.js

@@ -13,9 +13,14 @@ QUnit.test('String#padEnd', assert => {
   assert.same(padEnd('foo', 1), 'foo');
   assert.same(padEnd('foo', 5, ''), 'foo');
 
+  const thrower = { toString() { throw new Error('oops'); } };
+  assert.throws(() => padEnd('a', 10, thrower), 'throws on thrower argument conversion');
+  assert.same(padEnd('abc', 2, thrower), 'abc', 'does not throw on thrower argument when no padding needed');
+
   const symbol = Symbol('padEnd test');
   assert.throws(() => padEnd(symbol, 10, 'a'), 'throws on symbol context');
   assert.throws(() => padEnd('a', 10, symbol), 'throws on symbol argument');
+  assert.same(padEnd('abc', 2, symbol), 'abc', 'does not throw on symbol fillString when no padding needed');
 
   if (STRICT) {
     assert.throws(() => padEnd(null, 0), TypeError);

tests/unit-pure/es.string.pad-start.js

@@ -13,9 +13,14 @@ QUnit.test('String#padStart', assert => {
   assert.same(padStart('foo', 1), 'foo');
   assert.same(padStart('foo', 5, ''), 'foo');
 
+  const thrower = { toString() { throw new Error('oops'); } };
+  assert.throws(() => padStart('a', 10, thrower), 'throws on thrower argument conversion');
+  assert.same(padStart('abc', 2, thrower), 'abc', 'does not throw on thrower argument when no padding needed');
+
   const symbol = Symbol('padStart test');
   assert.throws(() => padStart(symbol, 10, 'a'), 'throws on symbol context');
   assert.throws(() => padStart('a', 10, symbol), 'throws on symbol argument');
+  assert.same(padStart('abc', 2, symbol), 'abc', 'does not throw on symbol fillString when no padding needed');
 
   if (STRICT) {
     assert.throws(() => padStart(null, 0), TypeError);