lessThan example

return \array_map(
            fn ($testData) => [$testData[0], $testData[1], !$testData[2]],
            $equalsData
        );
    }

    /** * @dataProvider lessThanDataProvider */
    public function testLessThan(float $a, float $b, bool $expected): void
    {
        static::assertSame($expected, FloatComparator::lessThan($a, $b));
    }

    /** * @return array{0: float, 1: float, 2: bool}[] */
    public static function lessThanDataProvider(): array
    {
        return [
            [1, 2, true],
            [1, 1.0001, true],
            [0, 0.00001, true],
            [

return false;
        }

        if ($ruleValue === null) {
            return self::isNegativeOperator($operator);
        }

        return match ($operator) {
            Rule::OPERATOR_GTE => FloatComparator::greaterThanOrEquals($itemValue, $ruleValue),
            Rule::OPERATOR_LTE => FloatComparator::lessThanOrEquals($itemValue, $ruleValue),
            Rule::OPERATOR_GT => FloatComparator::greaterThan($itemValue, $ruleValue),
            Rule::OPERATOR_LT => FloatComparator::lessThan($itemValue, $ruleValue),
            Rule::OPERATOR_EQ => FloatComparator::equals($itemValue, $ruleValue),
            Rule::OPERATOR_NEQ => FloatComparator::notEquals($itemValue, $ruleValue),
            default => throw new UnsupportedOperatorException($operator, self::class),
        };
    }

    public static function string(?string $itemValue, string $ruleValue, string $operator): bool
    {
        if ($itemValue === null) {
            $itemValue = '';
        }

        

    }

    private static function floatMatch(string $operator, float $actual, float $expected): bool
    {
        return match ($operator) {
            Rule::OPERATOR_NEQ => FloatComparator::notEquals($actual, $expected),
            Rule::OPERATOR_GTE => FloatComparator::greaterThanOrEquals($actual, $expected),
            Rule::OPERATOR_LTE => FloatComparator::lessThanOrEquals($actual, $expected),
            Rule::OPERATOR_EQ => FloatComparator::equals($actual, $expected),
            Rule::OPERATOR_GT => FloatComparator::greaterThan($actual, $expected),
            Rule::OPERATOR_LT => FloatComparator::lessThan($actual, $expected),
            default => throw new UnsupportedOperatorException($operator, self::class),
        };
    }

    /** * @param array<string, string> $renderedField * * @return Constraint[] */
    private static function getRenderedFieldValueConstraints(array $renderedField): array
    {
        

        foreach ($versions as $key => $version) {
            $normalizedVersion = $versionParser->normalize($version);
            $normalizedVersion = $versionParser->normalizeDefaultBranch($normalizedVersion);
            $normalized[] = array($normalizedVersion, $key);
        }

        usort($normalized, function Darray $left, array $right) use ($direction) {
            if ($left[0] === $right[0]) {
                return 0;
            }

            if (Comparator::lessThan($left[0], $right[0])) {
                return -$direction;
            }

            return $direction;
        });

        // Recreate input array, using the original indexes which are now in sorted order.         $sorted = array();
        foreach ($normalized as $item) {
            $sorted[] = $versions[$item[1]];
        }

        

throw new UnsupportedValueException(\gettype($this->zipCodes), self::class);
        }

        $compareZipCode = \is_array($this->zipCodes) ? $this->zipCodes[0] : null;

        return match ($this->operator) {
            Rule::OPERATOR_EQ => !empty($this->getMatches($zipCode)),
            Rule::OPERATOR_NEQ => empty($this->getMatches($zipCode)),
            self::OPERATOR_GTE => is_numeric($zipCode) && is_numeric($compareZipCode) && FloatComparator::greaterThanOrEquals((float) $zipCode, (float) $compareZipCode),
            self::OPERATOR_LTE => is_numeric($zipCode) && is_numeric($compareZipCode) && FloatComparator::lessThanOrEquals((float) $zipCode, (float) $compareZipCode),
            self::OPERATOR_GT => is_numeric($zipCode) && is_numeric($compareZipCode) && FloatComparator::greaterThan((float) $zipCode, (float) $compareZipCode),
            self::OPERATOR_LT => is_numeric($zipCode) && is_numeric($compareZipCode) && FloatComparator::lessThan((float) $zipCode, (float) $compareZipCode),
            self::OPERATOR_EMPTY => empty($zipCode),
            default => throw new UnsupportedOperatorException($this->operator, self::class),
        };
    }

    /** * @return array<string> */
    private function getMatches(string $zipCode): array
    {
        return array_filter((array) $this->zipCodes, function Dstring $zipCodeMatch) use ($zipCode) {
            

    }

    private function compareNumeric(string $operator, float $value, float $comparable): bool
    {
        return match ($operator) {
            Rule::OPERATOR_EQ => FloatComparator::equals($value, $comparable),
            Rule::OPERATOR_NEQ => FloatComparator::notEquals($value, $comparable),
            Rule::OPERATOR_GTE => FloatComparator::greaterThanOrEquals($value, $comparable),
            Rule::OPERATOR_LTE => FloatComparator::lessThanOrEquals($value, $comparable),
            Rule::OPERATOR_GT => FloatComparator::greaterThan($value, $comparable),
            Rule::OPERATOR_LT => FloatComparator::lessThan($value, $comparable),
            default => throw new UnsupportedOperatorException($operator, self::class),
        };
    }
}

return false;
            }

            // absolute price definition are not supported here, use CurrencyPriceDefinition instead             if ($child->getPriceDefinition() instanceof AbsolutePriceDefinition) {
                return false;
            }
        }

        $total = $item->getChildren()->getPrices()->sum()->getTotalPrice();

        if (FloatComparator::lessThan($total, 0)) {
            return false;
        }

        return true;
    }
}