✅ Autofix completed

test/OpenCvSharp.Tests/core/VecTest.cs (2)

242-247: Specify the string comparison mode in these assertions.

These Assert.Contains calls are triggering CA1307 in CI. Passing StringComparison.Ordinal keeps the tests explicit and removes the analyzer noise.

🩹 Suggested cleanup

-        Assert.Contains("Vec2b", new Vec2b(1, 2).ToString());
-        Assert.Contains("1", new Vec2b(1, 2).ToString());
+        Assert.Contains("Vec2b", new Vec2b(1, 2).ToString(), StringComparison.Ordinal);
+        Assert.Contains("1", new Vec2b(1, 2).ToString(), StringComparison.Ordinal);

-        Assert.Contains("Vec3f", new Vec3f(1f, 2f, 3f).ToString());
-        Assert.Contains("Vec6i", new Vec6i(1, 2, 3, 4, 5, 6).ToString());
-        Assert.Contains("Vec4d", new Vec4d(1.0, 2.0, 3.0, 4.0).ToString());
+        Assert.Contains("Vec3f", new Vec3f(1f, 2f, 3f).ToString(), StringComparison.Ordinal);
+        Assert.Contains("Vec6i", new Vec6i(1, 2, 3, 4, 5, 6).ToString(), StringComparison.Ordinal);
+        Assert.Contains("Vec4d", new Vec4d(1.0, 2.0, 3.0, 4.0).ToString(), StringComparison.Ordinal);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/OpenCvSharp.Tests/core/VecTest.cs` around lines 242 - 247, The
Assert.Contains calls for Vec2b/Vec3f/Vec6i/Vec4d ToString() are triggering
CA1307; update each Assert.Contains invocation to use the overload that accepts
a StringComparison and pass StringComparison.Ordinal (e.g.,
Assert.Contains("Vec2b", new Vec2b(...).ToString(), StringComparison.Ordinal)),
referencing the Assert.Contains method and the ToString() results on Vec2b,
Vec3f, Vec6i, and Vec4d.

---

309-326: Avoid x == x / x != x in these operator tests.

The semantics being tested are good, but the self-comparisons generate CS1718 on every target. Compare against an equivalent copy/value instead so the NaN behavior stays covered without compiler noise.

🩹 Suggested cleanup

         var vfNaN = new Vec2f(float.NaN, 1f);
+        var vfNaNCopy = new Vec2f(float.NaN, 1f);
         Assert.True(vfNaN.Equals(vfNaN));   // IEquatable contract: reflexive
-        Assert.False(vfNaN == vfNaN);        // IEEE 754: NaN != NaN
-        Assert.True(vfNaN != vfNaN);
+        Assert.False(vfNaN == vfNaNCopy);   // IEEE 754: NaN != NaN
+        Assert.True(vfNaN != vfNaNCopy);

         var vfNormal = new Vec2f(1f, 2f);
-        Assert.True(vfNormal == vfNormal);
-        Assert.False(vfNormal != vfNormal);
+        var vfNormalCopy = new Vec2f(1f, 2f);
+        Assert.True(vfNormal == vfNormalCopy);
+        Assert.False(vfNormal != vfNormalCopy);

         // double
         var vdNaN = new Vec3d(double.NaN, 1.0, 2.0);
+        var vdNaNCopy = new Vec3d(double.NaN, 1.0, 2.0);
         Assert.True(vdNaN.Equals(vdNaN));
-        Assert.False(vdNaN == vdNaN);
-        Assert.True(vdNaN != vdNaN);
+        Assert.False(vdNaN == vdNaNCopy);
+        Assert.True(vdNaN != vdNaNCopy);

         var vdNormal = new Vec3d(1.0, 2.0, 3.0);
-        Assert.True(vdNormal == vdNormal);
-        Assert.False(vdNormal != vdNormal);
+        var vdNormalCopy = new Vec3d(1.0, 2.0, 3.0);
+        Assert.True(vdNormal == vdNormalCopy);
+        Assert.False(vdNormal != vdNormalCopy);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/OpenCvSharp.Tests/core/VecTest.cs` around lines 309 - 326, Replace the
self-comparisons that trigger CS1718 by creating equivalent copy/value instances
and using those for operator tests: instead of asserting vfNaN == vfNaN or vfNaN
!= vfNaN, construct a same-valued copy (e.g., vfNaNCopy) and assert vfNaN ==
vfNaNCopy and vfNaN != vfNaNCopy as appropriate; do the same for vfNormal, vdNaN
and vdNormal with Vec2f/Vec3d so the IEquatable.Equals reflexive checks remain
but operator ==/!= tests compare distinct but equal values.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

src/OpenCvSharp/Modules/core/Struct/Vec/Vec6d.cs (1)

197-204: ⚠️ Potential issue | 🔴 Critical

Vec6d operators violate the documented IEEE 754 NaN semantics contract.

At lines 197 and 204, Vec6d uses double.Equals() for equality comparisons, causing NaN == NaN to return true. This violates the explicitly documented contract in the test file (VecTest.cs line 302–304) which requires operator == to follow IEEE 754 semantics where NaN == NaN is false. All other floating Vec types (Vec2d, Vec4d, Vec2f, Vec4f) correctly use raw ==/!= operators. Additionally, Vec6d is not covered by the FloatingPointNaNEquality test, leaving this bug undetected.

Proposed fix

-    public static bool operator ==(Vec6d a, Vec6d b) => a.Item0.Equals(b.Item0) && a.Item1.Equals(b.Item1) && a.Item2.Equals(b.Item2) && a.Item3.Equals(b.Item3) && a.Item4.Equals(b.Item4) && a.Item5.Equals(b.Item5);
+    public static bool operator ==(Vec6d a, Vec6d b) => a.Item0 == b.Item0 && a.Item1 == b.Item1 && a.Item2 == b.Item2 && a.Item3 == b.Item3 && a.Item4 == b.Item4 && a.Item5 == b.Item5;

-    public static bool operator !=(Vec6d a, Vec6d b) => !a.Item0.Equals(b.Item0) || !a.Item1.Equals(b.Item1) || !a.Item2.Equals(b.Item2) || !a.Item3.Equals(b.Item3) || !a.Item4.Equals(b.Item4) || !a.Item5.Equals(b.Item5);
+    public static bool operator !=(Vec6d a, Vec6d b) => a.Item0 != b.Item0 || a.Item1 != b.Item1 || a.Item2 != b.Item2 || a.Item3 != b.Item3 || a.Item4 != b.Item4 || a.Item5 != b.Item5;

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/OpenCvSharp/Modules/core/Struct/Vec/Vec6d.cs` around lines 197 - 204, The
Vec6d equality operators currently use double.Equals (in operator == and
operator !=) which makes NaNs compare equal; change Vec6d.operator== to use the
raw double == for each component (e.g., a.Item0 == b.Item0 && ... for all six
items) and implement operator!= as the logical negation of operator== (e.g.,
return !(a == b)) so IEEE 754 NaN semantics are preserved; update the
implementations for the methods named operator== and operator!= in the Vec6d
struct accordingly.

test/OpenCvSharp.Tests/core/VecTest.cs (1)

306-331: Consider extending NaN/AsSpan tests to newly touched floating Vec types.

Great coverage bump overall. Since this PR touches Vec4d, Vec6f, and Vec6d, adding targeted assertions for those in FloatingPointNaNEquality/AsSpan would better lock the intended behavior and prevent regressions.

Also applies to: 333-362

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/OpenCvSharp.Tests/core/VecTest.cs` around lines 306 - 331, Extend the
existing FloatingPointNaNEquality and AsSpan tests to cover the newly touched
vector types Vec4d, Vec6f, and Vec6d: for FloatingPointNaNEquality create one
NaN-containing instance per type (e.g., Vec4d with double.NaN in one element,
Vec6f/Vec6d with float/double.NaN) and one normal instance, then assert
.Equals(self) is true while == returns false and != returns true for the NaN
instance and that normal instances compare equal; for AsSpan create instances
for Vec4d, Vec6f, Vec6d and assert their AsSpan() length and element values (or
sequence equality against an expected array) match expected contents to lock in
span behavior. Ensure you reference the test method names
FloatingPointNaNEquality and AsSpan and the types Vec4d, Vec6f, Vec6d when
adding these assertions.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes