add some conversion tests

tests/helpers/helpers.js

@@ -69,6 +69,23 @@ export function createAsyncIterable(elements, methods) {
   return iterable;
 }
 
+export function createConversionChecker(value, string) {
+  const checker = {
+    $valueOf: 0,
+    $toString: 0,
+    valueOf() {
+      checker.$valueOf++;
+      return value;
+    },
+    toString() {
+      checker.$toString++;
+      return arguments.length > 1 ? string : String(value);
+    },
+  };
+
+  return checker;
+}
+
 export function arrayFromArrayLike(source) {
   const { length } = source;
   const result = Array(length);

tests/pure/es.math.acosh.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import acosh from 'core-js-pure/es/math/acosh';
 import EPSILON from 'core-js-pure/es/number/epsilon';
 
@@ -14,4 +16,9 @@ QUnit.test('Math.acosh', assert => {
   assert.epsilon(acosh(1e+160), 369.10676205960726);
   assert.epsilon(acosh(Number.MAX_VALUE), 710.475860073944);
   assert.epsilon(acosh(1 + EPSILON), 2.1073424255447017e-8);
+
+  const checker = createConversionChecker(1234);
+  assert.epsilon(acosh(checker), 7.811163220849231);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.asinh.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import asinh from 'core-js-pure/es/math/asinh';
 
 QUnit.test('Math.asinh', assert => {
@@ -12,4 +14,9 @@ QUnit.test('Math.asinh', assert => {
   assert.epsilon(asinh(1e150), 346.0809111296668);
   assert.epsilon(asinh(1e7), 16.811242831518268);
   assert.epsilon(asinh(-1e7), -16.811242831518268);
+
+  const checker = createConversionChecker(1234);
+  assert.epsilon(asinh(checker), 7.811163549201245);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.atanh.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import atanh from 'core-js-pure/es/math/atanh';
 
 QUnit.test('Math.atanh', assert => {
@@ -16,4 +18,9 @@ QUnit.test('Math.atanh', assert => {
   assert.epsilon(atanh(0.5), 0.5493061443340549);
   assert.epsilon(atanh(-0.5), -0.5493061443340549);
   assert.epsilon(atanh(0.444), 0.47720201260109457);
+
+  const checker = createConversionChecker(0.5);
+  assert.epsilon(atanh(checker), 0.5493061443340549);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.cbrt.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import cbrt from 'core-js-pure/es/math/cbrt';
 
 QUnit.test('Math.cbrt', assert => {
@@ -11,4 +13,9 @@ QUnit.test('Math.cbrt', assert => {
   assert.same(cbrt(8), 2);
   assert.epsilon(cbrt(-1000), -10);
   assert.epsilon(cbrt(1000), 10);
+
+  const checker = createConversionChecker(1000);
+  assert.epsilon(cbrt(checker), 10);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.clz32.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import clz32 from 'core-js-pure/es/math/clz32';
 
 QUnit.test('Math.clz32', assert => {
@@ -8,4 +10,9 @@ QUnit.test('Math.clz32', assert => {
   assert.same(clz32(0.6), 32);
   assert.same(clz32(2 ** 32 - 1), 0);
   assert.same(clz32(2 ** 32), 32);
+
+  const checker = createConversionChecker(1);
+  assert.same(clz32(checker), 31, 'object wrapper');
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.cosh.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import cosh from 'core-js-pure/es/math/cosh';
 
 QUnit.test('Math.cosh', assert => {
@@ -12,4 +14,9 @@ QUnit.test('Math.cosh', assert => {
   assert.epsilon(cosh(-10), 11013.23292010332313972137);
   assert.epsilon(cosh(-23), 4872401723.1244513000, 1e-5);
   assert.epsilon(cosh(710), 1.1169973830808557e+308, 1e+295);
+
+  const checker = createConversionChecker(12);
+  assert.epsilon(cosh(checker), 81377.395712574, 1e-9, 'object wrapper');
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.expm1.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import expm1 from 'core-js-pure/es/math/expm1';
 
 QUnit.test('Math.expm1', assert => {
@@ -9,4 +11,9 @@ QUnit.test('Math.expm1', assert => {
   assert.same(expm1(-Infinity), -1);
   assert.epsilon(expm1(10), 22025.465794806718);
   assert.epsilon(expm1(-10), -0.9999546000702375);
+
+  const checker = createConversionChecker(10);
+  assert.epsilon(expm1(checker), 22025.465794806718);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.fround.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import fround from 'core-js-pure/es/math/fround';
 
 QUnit.test('Math.fround', assert => {
@@ -35,4 +37,9 @@ QUnit.test('Math.fround', assert => {
   assert.same(fround(-1.1754942807573642e-38), -maxSubnormal32, 'fround(-1.1754942807573642e-38)');
   assert.same(fround(-1.1754942807573643e-38), -minNormal32, 'fround(-1.1754942807573643e-38)');
   assert.same(fround(-1.1754942807573644e-38), -minNormal32, 'fround(-1.1754942807573644e-38)');
+
+  const checker = createConversionChecker(1.1754942807573642e-38);
+  assert.same(fround(checker), maxSubnormal32, 'object wrapper');
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.hypot.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import hypot from 'core-js-pure/es/math/hypot';
 
 QUnit.test('Math.hypot', assert => {
@@ -38,4 +40,18 @@ QUnit.test('Math.hypot', assert => {
   assert.same(hypot(1e+300, 1e+300, 2, 3), 1.4142135623730952e+300);
   assert.same(hypot(-3, 4), 5);
   assert.same(hypot(3, -4), 5);
+
+  const checker1 = createConversionChecker(2);
+  const checker2 = createConversionChecker(3);
+  const checker3 = createConversionChecker(4);
+  const checker4 = createConversionChecker(5);
+  assert.same(hypot(checker1, checker2, checker3, checker4), sqrt(2 * 2 + 3 * 3 + 4 * 4 + 5 * 5), 'object wrapper');
+  assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
+  assert.same(checker1.$toString, 0, 'checker1 toString calls');
+  assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
+  assert.same(checker2.$toString, 0, 'checker2 toString calls');
+  assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
+  assert.same(checker3.$toString, 0, 'checker3 toString calls');
+  assert.same(checker4.$valueOf, 1, 'checker4 valueOf calls');
+  assert.same(checker4.$toString, 0, 'checker4 toString calls');
 });

tests/pure/es.math.imul.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import imul from 'core-js-pure/es/math/imul';
 
 QUnit.test('Math.imul', assert => {
@@ -37,4 +39,12 @@ QUnit.test('Math.imul', assert => {
   assert.same(imul(7, 1.1), 7);
   assert.same(imul(1.9, 7), 7);
   assert.same(imul(7, 1.9), 7);
+
+  const checker1 = createConversionChecker(-123);
+  const checker2 = createConversionChecker(456);
+  assert.same(imul(checker1, checker2), -56088, 'object wrapper');
+  assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
+  assert.same(checker1.$toString, 0, 'checker1 toString calls');
+  assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
+  assert.same(checker2.$toString, 0, 'checker2 toString calls');
 });

tests/pure/es.math.log10.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import log10 from 'core-js-pure/es/math/log10';
 
 QUnit.test('Math.log10', assert => {
@@ -15,4 +17,9 @@ QUnit.test('Math.log10', assert => {
   assert.epsilon(log10(5), 0.6989700043360189);
   assert.epsilon(log10(50), 1.6989700043360187);
   assert.epsilon(log10(1000), 3);
+
+  const checker = createConversionChecker(0.5);
+  assert.epsilon(log10(checker), -0.3010299956639812);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.log1p.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import log1p from 'core-js-pure/es/math/log1p';
 
 QUnit.test('Math.log1p', assert => {
@@ -11,4 +13,9 @@ QUnit.test('Math.log1p', assert => {
   assert.same(log1p(Infinity), Infinity);
   assert.epsilon(log1p(5), 1.791759469228055);
   assert.epsilon(log1p(50), 3.9318256327243257);
+
+  const checker = createConversionChecker(5);
+  assert.epsilon(log1p(checker), 1.791759469228055);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.log2.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import log2 from 'core-js-pure/es/math/log2';
 
 QUnit.test('Math.log2', assert => {
@@ -12,4 +14,9 @@ QUnit.test('Math.log2', assert => {
   assert.same(log2(0.5), -1);
   assert.same(log2(32), 5);
   assert.epsilon(log2(5), 2.321928094887362);
+
+  const checker = createConversionChecker(5);
+  assert.epsilon(log2(checker), 2.321928094887362);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.sign.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import sign from 'core-js-pure/es/math/sign';
 
 QUnit.test('Math.sign', assert => {
@@ -12,4 +14,9 @@ QUnit.test('Math.sign', assert => {
   assert.same(sign(-13510798882111488), -1);
   assert.same(sign(42.5), 1);
   assert.same(sign(-42.5), -1);
+
+  const checker = createConversionChecker(-42.5);
+  assert.same(sign(checker), -1, 'object wrapper');
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.sinh.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import sinh from 'core-js-pure/es/math/sinh';
 
 QUnit.test('Math.sinh', assert => {
@@ -10,4 +12,9 @@ QUnit.test('Math.sinh', assert => {
   assert.epsilon(sinh(-5), -74.20321057778875);
   assert.epsilon(sinh(2), 3.6268604078470186);
   assert.same(sinh(-2e-17), -2e-17);
+
+  const checker = createConversionChecker(-5);
+  assert.epsilon(sinh(checker), -74.20321057778875);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.tanh.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import tanh from 'core-js-pure/es/math/tanh';
 
 QUnit.test('Math.tanh', assert => {
@@ -8,4 +10,9 @@ QUnit.test('Math.tanh', assert => {
   assert.same(tanh(Infinity), 1);
   assert.same(tanh(90), 1);
   assert.epsilon(tanh(10), 0.9999999958776927);
+
+  const checker = createConversionChecker(10);
+  assert.epsilon(tanh(checker), 0.9999999958776927);
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/es.math.trunc.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import trunc from 'core-js-pure/es/math/trunc';
 
 QUnit.test('Math.trunc', assert => {
@@ -17,4 +19,9 @@ QUnit.test('Math.trunc', assert => {
   assert.same(trunc(-555.555), -555, '-555.555 -> -555');
   assert.same(trunc(0x20000000000001), 0x20000000000001, '0x20000000000001 -> 0x20000000000001');
   assert.same(trunc(-0x20000000000001), -0x20000000000001, '-0x20000000000001 -> -0x20000000000001');
+
+  const checker = createConversionChecker(-1.99);
+  assert.same(trunc(checker), -1, 'object wrapper');
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/esnext.math.clamp.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import clamp from 'core-js-pure/full/math/clamp';
 
 QUnit.test('Math.clamp', assert => {
@@ -6,4 +8,15 @@ QUnit.test('Math.clamp', assert => {
   assert.same(clamp(2, 4, 6), 4);
   assert.same(clamp(4, 2, 6), 4);
   assert.same(clamp(6, 2, 4), 4);
+
+  const checker1 = createConversionChecker(2);
+  const checker2 = createConversionChecker(4);
+  const checker3 = createConversionChecker(5);
+  assert.same(clamp(checker1, checker2, checker3), 4, 'object wrapper');
+  assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
+  assert.same(checker1.$toString, 0, 'checker1 toString calls');
+  assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
+  assert.same(checker2.$toString, 0, 'checker2 toString calls');
+  assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
+  assert.same(checker3.$toString, 0, 'checker3 toString calls');
 });

tests/pure/esnext.math.degrees.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import degrees from 'core-js-pure/full/math/degrees';
 
 QUnit.test('Math.degrees', assert => {
@@ -7,4 +9,9 @@ QUnit.test('Math.degrees', assert => {
   assert.same(degrees(Math.PI / 2), 90);
   assert.same(degrees(Math.PI), 180);
   assert.same(degrees(3 * Math.PI / 2), 270);
+
+  const checker = createConversionChecker(3 * PI / 2);
+  assert.same(degrees(checker), 270, 'object wrapper');
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });

tests/pure/esnext.math.fscale.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import fscale from 'core-js-pure/full/math/fscale';
 
 QUnit.test('Math.fscale', assert => {
@@ -7,4 +9,21 @@ QUnit.test('Math.fscale', assert => {
   assert.same(fscale(0, 3, 5, 8, 10), 5);
   assert.same(fscale(1, 1, 1, 1, 1), NaN);
   assert.same(fscale(-1, -1, -1, -1, -1), NaN);
+
+  const checker1 = createConversionChecker(3);
+  const checker2 = createConversionChecker(1);
+  const checker3 = createConversionChecker(2);
+  const checker4 = createConversionChecker(1);
+  const checker5 = createConversionChecker(2);
+  assert.same(fscale(checker1, checker2, checker3, checker4, checker5), 3, 'object wrapper');
+  assert.same(checker1.$valueOf, 1, 'checker1 valueOf calls');
+  assert.same(checker1.$toString, 0, 'checker1 toString calls');
+  assert.same(checker2.$valueOf, 1, 'checker2 valueOf calls');
+  assert.same(checker2.$toString, 0, 'checker2 toString calls');
+  assert.same(checker3.$valueOf, 1, 'checker3 valueOf calls');
+  assert.same(checker3.$toString, 0, 'checker3 toString calls');
+  assert.same(checker4.$valueOf, 1, 'checker4 valueOf calls');
+  assert.same(checker4.$toString, 0, 'checker4 toString calls');
+  assert.same(checker5.$valueOf, 1, 'checker5 valueOf calls');
+  assert.same(checker5.$toString, 0, 'checker5 toString calls');
 });

tests/pure/esnext.math.radians.js

@@ -1,3 +1,5 @@
+import { createConversionChecker } from '../helpers/helpers';
+
 import radians from 'core-js-pure/full/math/radians';
 
 QUnit.test('Math.radians', assert => {
@@ -7,4 +9,9 @@ QUnit.test('Math.radians', assert => {
   assert.same(radians(90), Math.PI / 2);
   assert.same(radians(180), Math.PI);
   assert.same(radians(270), 3 * Math.PI / 2);
+
+  const checker = createConversionChecker(270);
+  assert.same(radians(checker), 3 * PI / 2, 'object wrapper');
+  assert.same(checker.$valueOf, 1, 'valueOf calls');
+  assert.same(checker.$toString, 0, 'toString calls');
 });