add initial fuzz test for partial_ratio

Author: maxbachmann

fuzzing/CMakeLists.txt

@@ -20,3 +20,5 @@ create_fuzzer(osa_distance)
 create_fuzzer(damerau_levenshtein_distance)
 
 create_fuzzer(jaro_similarity)
+
+create_fuzzer(partial_ratio)

fuzzing/fuzz_partial_ratio.cpp

@@ -0,0 +1,53 @@
+/* SPDX-License-Identifier: MIT */
+/* Copyright © 2021 Max Bachmann */
+
+#include "../rapidfuzz_reference/fuzz.hpp"
+#include "fuzzing.hpp"
+#include <cstdint>
+#include <rapidfuzz/fuzz.hpp>
+#include <stdexcept>
+#include <string>
+
+bool is_close(double a, double b, double epsilon)
+{
+    return fabs(a - b) <= ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
+}
+
+void validate_distance(const std::vector<uint8_t>& s1, const std::vector<uint8_t>& s2)
+{
+    auto sim = rapidfuzz::fuzz::partial_ratio(s1, s2);
+    auto reference_sim = rapidfuzz_reference::partial_ratio(s1, s2);
+    if (!is_close(sim, reference_sim, 0.0001)) {
+        print_seq("s1: ", s1);
+        print_seq("s2: ", s2);
+        throw std::logic_error(std::string("partial_ratio failed (reference_score = ") +
+                               std::to_string(reference_sim) + std::string(", score = ") +
+                               std::to_string(sim) + ")");
+    }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    std::vector<uint8_t> s1, s2;
+    if (!extract_strings(data, size, s1, s2)) return 0;
+
+    validate_distance(s1, s2);
+    validate_distance(s2, s1);
+
+    /* test long sequences */
+    for (unsigned int i = 2; i < 9; ++i) {
+        std::vector<uint8_t> s1_ = vec_multiply(s1, pow<size_t>(2, i));
+        std::vector<uint8_t> s2_ = vec_multiply(s2, pow<size_t>(2, i));
+
+        if (s1_.size() > 10000 || s2_.size() > 10000) break;
+
+        validate_distance(s1_, s2_);
+        validate_distance(s2_, s1_);
+        validate_distance(s1, s2_);
+        validate_distance(s2_, s1);
+        validate_distance(s1_, s2);
+        validate_distance(s2, s1_);
+    }
+
+    return 0;
+}

rapidfuzz_reference/Indel.hpp

@@ -22,4 +22,17 @@ size_t indel_distance(const Sentence1& s1, const Sentence2& s2,
     return levenshtein_distance(s1, s2, {1, 1, 2}, score_cutoff);
 }
 
+template <typename InputIt1, typename InputIt2>
+double indel_similarity(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
+                        double score_cutoff = 0.0)
+{
+    return levenshtein_similarity(first1, last1, first2, last2, {1, 1, 2}, score_cutoff);
+}
+
+template <typename Sentence1, typename Sentence2>
+double indel_similarity(const Sentence1& s1, const Sentence2& s2, double score_cutoff = 0.0)
+{
+    return levenshtein_similarity(s1, s2, {1, 1, 2}, score_cutoff);
+}
+
 } // namespace rapidfuzz_reference

rapidfuzz_reference/Levenshtein.hpp

@@ -16,6 +16,18 @@ struct LevenshteinWeightTable {
     size_t replace_cost;
 };
 
+static inline size_t levenshtein_maximum(size_t len1, size_t len2, LevenshteinWeightTable weights)
+{
+    size_t max_dist = len1 * weights.delete_cost + len2 * weights.insert_cost;
+
+    if (len1 >= len2)
+        max_dist = std::min(max_dist, len2 * weights.replace_cost + (len1 - len2) * weights.delete_cost);
+    else
+        max_dist = std::min(max_dist, len1 * weights.replace_cost + (len2 - len1) * weights.insert_cost);
+
+    return max_dist;
+}
+
 template <typename InputIt1, typename InputIt2>
 Matrix<size_t> levenshtein_matrix(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                                   LevenshteinWeightTable weights = {1, 1, 1})
@@ -69,4 +81,24 @@ size_t levenshtein_distance(const Sentence1& s1, const Sentence2& s2,
                                 score_cutoff);
 }
 
+template <typename InputIt1, typename InputIt2>
+double levenshtein_similarity(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
+                              LevenshteinWeightTable weights = {1, 1, 1}, double score_cutoff = 0.0)
+{
+    size_t len1 = static_cast<size_t>(std::distance(first1, last1));
+    size_t len2 = static_cast<size_t>(std::distance(first2, last2));
+    size_t dist = levenshtein_distance(first1, last1, first2, last2, weights);
+    size_t max = levenshtein_maximum(len1, len2, weights);
+    double sim = 1.0 - (double)dist / max;
+    return (sim >= score_cutoff) ? sim : 0.0;
+}
+
+template <typename Sentence1, typename Sentence2>
+double levenshtein_similarity(const Sentence1& s1, const Sentence2& s2,
+                              LevenshteinWeightTable weights = {1, 1, 1}, double score_cutoff = 0.0)
+{
+    return levenshtein_similarity(std::begin(s1), std::end(s1), std::begin(s2), std::end(s2), weights,
+                                  score_cutoff);
+}
+
 } // namespace rapidfuzz_reference

rapidfuzz_reference/fuzz.hpp

@@ -0,0 +1,63 @@
+/* SPDX-License-Identifier: MIT */
+/* Copyright © 2022-present Max Bachmann */
+
+#pragma once
+
+#include "Indel.hpp"
+
+namespace rapidfuzz_reference {
+
+template <typename InputIt1, typename InputIt2>
+double ratio(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, double score_cutoff = 0.0)
+{
+    return indel_similarity(first1, last1, first2, last2, score_cutoff / 100.0) * 100;
+}
+
+template <typename Sentence1, typename Sentence2>
+double ratio(const Sentence1& s1, const Sentence2& s2, double score_cutoff = 0.0)
+{
+    return indel_similarity(s1, s2, score_cutoff / 100.0) * 100;
+}
+
+template <typename InputIt1, typename InputIt2>
+double partial_ratio_impl(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
+                          double score_cutoff = 0.0)
+{
+    size_t len1 = static_cast<size_t>(std::distance(first1, last1));
+    size_t len2 = static_cast<size_t>(std::distance(first2, last2));
+    if (len1 == 0 && len2 == 0) return 100.0;
+
+    if (len1 == 0 || len2 == 0) return 0.0;
+
+    if (len1 > len2) return partial_ratio_impl(first2, last2, first1, last1, score_cutoff);
+
+    double res = 0.0;
+    for (ptrdiff_t i = -1 * (ptrdiff_t)len1; i < (ptrdiff_t)len2; i++) {
+        ptrdiff_t start = std::max(ptrdiff_t(0), i);
+        ptrdiff_t end = std::min(ptrdiff_t(len2), i + ptrdiff_t(len1));
+        InputIt2 first2_ = first2 + start;
+        InputIt2 last2_ = first2 + end;
+        res = std::max(res, ratio(first1, last1, first2_, last2_, score_cutoff));
+    }
+    return res;
+}
+
+template <typename InputIt1, typename InputIt2>
+double partial_ratio(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
+                     double score_cutoff = 0.0)
+{
+    size_t len1 = static_cast<size_t>(std::distance(first1, last1));
+    size_t len2 = static_cast<size_t>(std::distance(first2, last2));
+    if (len1 != len2) return partial_ratio_impl(first1, last1, first2, last2, score_cutoff);
+
+    return std::max(partial_ratio_impl(first1, last1, first2, last2, score_cutoff),
+                    partial_ratio_impl(first2, last2, first1, last1, score_cutoff));
+}
+
+template <typename Sentence1, typename Sentence2>
+double partial_ratio(const Sentence1& s1, const Sentence2& s2, double score_cutoff = 0.0)
+{
+    return partial_ratio(std::begin(s1), std::end(s1), std::begin(s2), std::end(s2), score_cutoff);
+}
+
+} // namespace rapidfuzz_reference