// |reftest| shell-option(--enable-iterator-range) skip-if(!Iterator.hasOwnProperty('range'))

/*---
features: [Iterator.range]
---*/

// Invalid start parameter types
assertThrowsInstanceOf(() => Iterator.range('1'), TypeError);
assertThrowsInstanceOf(() => Iterator.range(null), TypeError);
assertThrowsInstanceOf(() => Iterator.range(undefined), TypeError);
assertThrowsInstanceOf(() => Iterator.range({}), TypeError);
assertThrowsInstanceOf(() => Iterator.range([]), TypeError);
assertThrowsInstanceOf(() => Iterator.range(true), TypeError);
assertThrowsInstanceOf(() => Iterator.range(Symbol()), TypeError);

// Invalid end parameter types
assertThrowsInstanceOf(() => Iterator.range(0, '1'), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, null), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, undefined), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, {}), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, []), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, true), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, Symbol()), TypeError);

// Invalid step parameter types
assertThrowsInstanceOf(() => Iterator.range(0, 10, '1'), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, 10, true), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, 10, Symbol()), TypeError);

// NaN and Infinity tests
assertThrowsInstanceOf(() => Iterator.range(NaN), RangeError);
assertThrowsInstanceOf(() => Iterator.range(0, NaN), RangeError);
assertThrowsInstanceOf(() => Iterator.range(Infinity), TypeError);

// Step type and value tests
assertThrowsInstanceOf(() => Iterator.range(0, 10, NaN), RangeError);
assertThrowsInstanceOf(() => Iterator.range(0, 10, Infinity), RangeError);

// Zero step tests
assertThrowsInstanceOf(() => Iterator.range(0, 10, 0), RangeError);
Iterator.range(0, 0, 0);

// Step configuration object tests
Iterator.range(0, 10, { step: 2 });
Iterator.range(0, 10, { step: -1 });
Iterator.range(0, 10, { inclusiveEnd: true });
assertThrowsInstanceOf(() => Iterator.range(0, 10, { step: '2' }), TypeError);

// Basic number inputs
Iterator.range(0, 10);
Iterator.range(0, 10, 2);


// Basic sequences with increasing steps of 1
const result1 = Array.from(Iterator.range(0, 10));
assertDeepEq(result1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

const result2 = Array.from(Iterator.range(2, 6));
assertDeepEq(result2, [2, 3, 4, 5]);

// Test empty range
const result3 = Array.from(Iterator.range(0, 0));
assertDeepEq(result3, []);

const result4 = Array.from(Iterator.range(5, 5));
assertDeepEq(result4, []);

// testing reverse range
const result5 = Array.from(Iterator.range(10, 0, -2));
assertDeepEq(result5, [10, 8, 6, 4, 2]);

// inclusive end
const result6 = Array.from(Iterator.range(0, 10, { step: 2, inclusiveEnd: true }));
assertDeepEq(result6, [0, 2, 4, 6, 8, 10]);

// overlapping step with range limits
const result7 = Array.from(Iterator.range(0, 10, 15));
assertDeepEq(result7, [0]);

// negative numbers in the range
const result8 = Array.from(Iterator.range(-10, 0));
assertDeepEq(result8, [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1]);

// floating point
const resultFloat1 = Array.from(Iterator.range(0.5, 3.5));
assertDeepEq(resultFloat1, [0.5, 1.5, 2.5]);

const resultFloat3 = Array.from(Iterator.range(0, 0.3, 0.1));
assertDeepEq(resultFloat3, [0, 0.1, 0.2]);


// floating point precision
function approximatelyEqual(a, b) {
    // If inputs are arrays, compare each element
    if (Array.isArray(a) && Array.isArray(b)) {
        assertEq(a.length, b.length);
        // Compare each element
        for (let i = 0; i < a.length; i++) {
            approximatelyEqual(a[i], b[i]);
        }
        return true;
    }

    // For single numbers
    var r = (a != a && b != b) || Math.abs(a - b) < 0.001;
    if (!r) {
        print('Got', a, ', to be approximately equal to', b);
        assertEq(false, true);
    }
    return true;
}

const resultFloat2 = Array.from(Iterator.range(0, 1, 0.2));
approximatelyEqual(resultFloat2, [0, 0.2, 0.4, 0.6, 0.8]);

const resultStep2 = Array.from(Iterator.range(0, 10, 3.3));
approximatelyEqual(resultStep2, [0, 3.3, 6.6, 9.9]);

// invalid mixed-type parameters
assertThrowsInstanceOf(() => Iterator.range(0, 10, { step: NaN, inclusiveEnd: true }), RangeError);

// bigint
Iterator.range(0n, 10n);
Iterator.range(0n, 10n, 2n);

const bigintResult1 = Array.from(Iterator.range(0n, 5n));
assertDeepEq(bigintResult1, [0n, 1n, 2n, 3n, 4n]);

const bigintResult2 = Array.from(Iterator.range(0n, 10n, 2n));
assertDeepEq(bigintResult2, [0n, 2n, 4n, 6n, 8n]);

// inclusive end with BigInt
const bigintResult3 = Array.from(Iterator.range(0n, 5n, { step: 2n, inclusiveEnd: true }));
assertDeepEq(bigintResult3, [0n, 2n, 4n]);

// empty BigInt range
const bigintResult4 = Array.from(Iterator.range(0n, 0n));
assertDeepEq(bigintResult4, []);

// negative step with BigInt
const bigintResult5 = Array.from(Iterator.range(5n, 0n, -1n));
assertDeepEq(bigintResult5, [5n, 4n, 3n, 2n, 1n]);


// test invalid this
const invalidValues = [
    null,
    undefined,
    42,
    'string',
    true,
    {},
    Symbol('test'),
    [],
    new Date()
];

const iterator = Iterator.range(0, 10);

invalidValues.forEach(value => {
    assertThrowsInstanceOf(() => {
        iterator.next.call(value);
    }, TypeError, `Should throw TypeError for ${typeof value}`);
});

// this value is a valid iterator object from another compartment
const g = newGlobal({ newCompartment: true });
const localIterator = Iterator.range(0, 10);
const otherIterator = g.eval("Iterator.range(0, 10)");

const result = localIterator.next.call(otherIterator);

assertEq(typeof result, 'object');
assertEq(result.value, 0);
assertEq(result.done, false);

// infinite tests for iterator sequences
const infiniteRange = Iterator.range(0, Infinity);
assertEq(typeof infiniteRange.next, 'function');

const first = infiniteRange.next();
assertEq(first.value, 0);
assertEq(infiniteRange.next().value, 1);
assertEq(first.done, false);

// negative infinity
const negativeInfiniteRange = Iterator.range(0, -Infinity, -1);
assertEq(negativeInfiniteRange.next().value, 0);
assertEq(negativeInfiniteRange.next().value, -1);
assertEq(negativeInfiniteRange.next().value, -2);

// steps
const stepRange = Iterator.range(0, Infinity, 2);
assertEq(stepRange.next().value, 0);
assertEq(stepRange.next().value, 2);
assertEq(stepRange.next().value, 4);

// test with an option object
const options = Iterator.range(0, Infinity, { step: 3 });
assertEq(options.next().value, 0);
assertEq(options.next().value, 3);
assertEq(options.next().value, 6);

// test that inclusive end is ignored for infinite ranges
const infiniteRangeInclusive = Iterator.range(0, Infinity, { inclusiveEnd: true });
assertEq(infiniteRangeInclusive.next().value, 0);
assertEq(infiniteRangeInclusive.next().value, 1);

// test negative infinity with inclusive end
const negativeInfiniteRangeInclusive = Iterator.range(0, -Infinity, -1, { inclusiveEnd: true });
assertEq(negativeInfiniteRangeInclusive.next().value, 0);
assertEq(negativeInfiniteRangeInclusive.next().value, -1);
assertEq(negativeInfiniteRangeInclusive.next().value, -2);

// test negative infinity with step and inclusive end
const negativeInfiniteRangeStepInclusive = Iterator.range(0, -Infinity, -2, { inclusiveEnd: true });
assertEq(negativeInfiniteRangeStepInclusive.next().value, 0);
assertEq(negativeInfiniteRangeStepInclusive.next().value, -2);

// bigint and infinite range
assertThrowsInstanceOf(() => Iterator.range(0n, Infinity), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0n, -Infinity), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, Infinity, 2n), TypeError);
assertThrowsInstanceOf(() => Iterator.range(0, 10, Infinity), RangeError);


if (typeof reportCompare === 'function')
    reportCompare(0, 0);