Align new test project configurations with existing conventions

MetaData/Tests/FaceDistanceInfoTests.cs

@@ -21,6 +21,7 @@
 #region Usings
 
 using System;
+using System.Linq;
 using NUnit.Framework;
 
 #endregion
@@ -42,10 +43,28 @@ public void EqualsTest()
     }
 
     [Test]
-    public void FromJsonStringArrayTest() { }
+    public void FromJsonStringArrayTest()
+    {
+        var items = new[] { TestData.FaceDistanceInfo1, TestData.FaceDistanceInfo2 };
+        string json = "[" + string.Join(",", items.Select(i => i.ToJsonString())) + "]";
+        var parsed = FaceDistanceInfo.FromJsonStringArray(json).ToArray();
+        Assert.That(parsed.Length, Is.EqualTo(2));
+        Assert.That(parsed[0], Is.EqualTo(TestData.FaceDistanceInfo1));
+        Assert.That(parsed[1], Is.EqualTo(TestData.FaceDistanceInfo2));
+
+        // Empty/null string returns empty
+        var empty = FaceDistanceInfo.FromJsonStringArray("").ToArray();
+        Assert.That(empty.Length, Is.EqualTo(0));
+    }
 
     [Test]
-    public void FromJsonStringTest() { }
+    public void FromJsonStringTest()
+    {
+        FaceDistanceInfo original = TestData.FaceDistanceInfo1;
+        string json = original.ToJsonString();
+        FaceDistanceInfo parsed = FaceDistanceInfo.FromJsonString(json);
+        Assert.That(parsed, Is.EqualTo(original));
+    }
 
     [Test]
     public void GetHashCodeTest()

MetaData/Tests/FaceInfoTests.cs

@@ -42,7 +42,20 @@ public void EqualsTest()
     }
 
     [Test]
-    public void FaceInfoTest() { }
+    public void FaceInfoTest()
+    {
+        FaceInfo fi = TestData.FaceInfo1;
+        Assert.That(fi.FileId, Is.EqualTo(1));
+        Assert.That(fi.FaceId, Is.EqualTo(2));
+        Assert.That(fi.PersonId, Is.EqualTo(3));
+        Assert.That(fi.FaceMode, Is.EqualTo(FaceMode.DlibCnn));
+        Assert.That(fi.FaceQuality, Is.EqualTo(FaceQuality.Normal));
+        Assert.That(fi.FaceDescriptor, Is.Not.Null);
+
+        // PersonId == EmptyPersonId should map to InvalidId
+        var fi2 = new FaceInfo(1, 2, Constants.EmptyPersonId, FaceMode.DlibFront, FaceQuality.Good, null);
+        Assert.That(fi2.PersonId, Is.EqualTo(Constants.InvalidId));
+    }
 
     [Test]
     public void FromJsonStringTest()
@@ -70,8 +83,18 @@ public void GetHashCodeTest()
     }
 
     [Test]
-    public void ToJsonStringArrayTest() { }
+    public void ToJsonStringArrayTest()
+    {
+        var faceInfos = new[] { TestData.FaceInfo1, TestData.FaceInfo2 };
+        string json = FaceInfo.ToJsonStringArray(faceInfos);
+        Assert.That(json, Is.Not.Empty);
+        Assert.That(json, Does.StartWith("["));
+    }
 
     [Test]
-    public void ToJsonStringTest() { }
+    public void ToJsonStringTest()
+    {
+        string json = TestData.FaceInfo1.ToJsonString();
+        Assert.That(json, Is.Not.Empty);
+    }
 }

MetaData/Tests/FaceTests.cs

@@ -42,7 +42,37 @@ public void EqualsTest()
     }
 
     [Test]
-    public void FaceTest() { }
+    public void FaceTest()
+    {
+        Face face = TestData.Face1;
+        Assert.That(face.Id, Is.EqualTo(1));
+        Assert.That(face.FaceMode, Is.EqualTo(FaceMode.DlibFront));
+        Assert.That(face.FaceQuality, Is.EqualTo(FaceQuality.Good));
+        Assert.That(face.Visible, Is.True);
+        Assert.That(face.IsFrontFace, Is.True);
+        Assert.That(face.HasFaceDescriptor, Is.True);
+        Assert.That(face.FaceDescriptor.Count, Is.EqualTo(128));
+
+        Face zero = TestData.FaceZero;
+        Assert.That(zero.IsFrontFace, Is.False);
+        Assert.That(zero.HasFaceDescriptor, Is.False);
+
+        // Face descriptor with wrong length is discarded
+        var wrongDesc = new FixedPoint64[5];
+        var faceWithWrongDesc = new Face(1, TestData.Rectangle1, FaceMode.DlibFront, FaceQuality.Normal, true, wrongDesc);
+        Assert.That(faceWithWrongDesc.HasFaceDescriptor, Is.False);
+    }
+
+    [Test]
+    public void InvalidateIdTest()
+    {
+        Face invalidated = TestData.Face1.InvalidateId();
+        Assert.That(invalidated.Id, Is.EqualTo(Constants.InvalidId));
+        Assert.That(invalidated.Rectangle, Is.EqualTo(TestData.Face1.Rectangle));
+        Assert.That(invalidated.FaceMode, Is.EqualTo(TestData.Face1.FaceMode));
+        Assert.That(invalidated.FaceQuality, Is.EqualTo(TestData.Face1.FaceQuality));
+        Assert.That(invalidated.Visible, Is.EqualTo(TestData.Face1.Visible));
+    }
 
     [Test]
     public void FromJsonStringTest()
@@ -68,7 +98,4 @@ public void GetHashCodeTest()
         TestUtil.GetHashCodeTest(TestData.FaceZero, TestData.Face1,
             TestData.Face2, copyOfData1);
     }
-
-    [Test]
-    public void InvalidateIdTest() { }
 }

MetaData/Tests/FileAndPersonTagTests.cs

@@ -21,6 +21,7 @@
 #region Usings
 
 using System;
+using System.Linq;
 using NUnit.Framework;
 
 #endregion
@@ -42,10 +43,31 @@ public void EqualsTest()
     }
 
     [Test]
-    public void FileAndPersonTagTest() { }
+    public void FileAndPersonTagTest()
+    {
+        FileAndPersonTag fpt = TestData.FileAndPersonTag1;
+        Assert.That(fpt.FileName, Is.EqualTo("file1"));
+        Assert.That(fpt.PersonTag, Is.EqualTo(TestData.PersonTag1));
+
+        // null filename defaults to empty string
+        FileAndPersonTag zero = TestData.FileAndPersonTagZero;
+        Assert.That(zero.FileName, Is.EqualTo(string.Empty));
+    }
 
     [Test]
-    public void FromJsonStringArrayTest() { }
+    public void FromJsonStringArrayTest()
+    {
+        var items = new[] { TestData.FileAndPersonTag1, TestData.FileAndPersonTag2 };
+        string json = FileAndPersonTag.ToJsonStringArray(items);
+        var parsed = FileAndPersonTag.FromJsonStringArray(json).ToArray();
+        Assert.That(parsed.Length, Is.EqualTo(2));
+        Assert.That(parsed[0], Is.EqualTo(TestData.FileAndPersonTag1));
+        Assert.That(parsed[1], Is.EqualTo(TestData.FileAndPersonTag2));
+
+        // Empty string returns empty
+        var empty = FileAndPersonTag.FromJsonStringArray("").ToArray();
+        Assert.That(empty.Length, Is.EqualTo(0));
+    }
 
     [Test]
     public void FromJsonStringTest()
@@ -73,11 +95,25 @@ public void GetHashCodeTest()
     }
 
     [Test]
-    public void ToJsonStringArrayTest() { }
+    public void ToJsonStringArrayTest()
+    {
+        var items = new[] { TestData.FileAndPersonTag1, TestData.FileAndPersonTag2 };
+        string json = FileAndPersonTag.ToJsonStringArray(items);
+        Assert.That(json, Is.Not.Empty);
+        Assert.That(json, Does.StartWith("["));
+    }
 
     [Test]
-    public void ToJsonStringTest() { }
+    public void ToJsonStringTest()
+    {
+        string json = TestData.FileAndPersonTag1.ToJsonString();
+        Assert.That(json, Is.Not.Empty);
+    }
 
     [Test]
-    public void ToStringTest() { }
+    public void ToStringTest()
+    {
+        string str = TestData.FileAndPersonTag1.ToString();
+        Assert.That(str, Is.Not.Empty);
+    }
 }

MetaData/Tests/FixedPoint32Tests.cs

@@ -42,7 +42,32 @@ public void EqualsTest()
     }
 
     [Test]
-    public void FixedPoint32Test() { }
+    public void FixedPoint32Test()
+    {
+        // Constructor from raw int
+        var fp = new FixedPoint32(100);
+        Assert.That(fp.RawValue, Is.EqualTo(100));
+
+        // Constructor from float: value * (1 << 16)
+        var fpFloat = new FixedPoint32(1.0f);
+        Assert.That(fpFloat.RawValue, Is.EqualTo(1 << 16));
+        Assert.That(fpFloat.Value, Is.EqualTo(1.0f).Within(1e-4f));
+
+        var fpNeg = new FixedPoint32(-2.0f);
+        Assert.That(fpNeg.Value, Is.EqualTo(-2.0f).Within(1e-4f));
+
+        // Zero
+        Assert.That(TestData.FixedPoint32Zero.Value, Is.EqualTo(0.0f));
+
+        // Comparison operators
+        Assert.That(TestData.FixedPoint321 < TestData.FixedPoint322, Is.True);
+        Assert.That(TestData.FixedPoint322 > TestData.FixedPoint321, Is.True);
+        var fp1Copy = new FixedPoint32(TestData.FixedPoint321.RawValue);
+        Assert.That(TestData.FixedPoint321 <= fp1Copy, Is.True);
+        Assert.That(TestData.FixedPoint321 >= fp1Copy, Is.True);
+        Assert.That(TestData.FixedPoint321 == fp1Copy, Is.True);
+        Assert.That(TestData.FixedPoint321 != TestData.FixedPoint322, Is.True);
+    }
 
     [Test]
     public void FromJsonStringTest()
@@ -74,5 +99,11 @@ public void GetHashCodeTest()
     }
 
     [Test]
-    public void ToStringTest() { }
+    public void ToStringTest()
+    {
+        string s = new FixedPoint32(1.5f).ToString();
+        Assert.That(s, Is.Not.Empty);
+        // Should use invariant culture (dot as decimal separator)
+        Assert.That(s, Does.Contain("."));
+    }
 }

MetaData/Tests/FixedPoint64Tests.cs

@@ -42,7 +42,28 @@ public void EqualsTest()
     }
 
     [Test]
-    public void FixedPoint64Test() { }
+    public void FixedPoint64Test()
+    {
+        // Constructor from raw long
+        var fp = new FixedPoint64(100L);
+        Assert.That(fp.RawValue, Is.EqualTo(100L));
+
+        // Constructor from double: value * (1L << 32)
+        var fpDouble = new FixedPoint64(1.0);
+        Assert.That(fpDouble.RawValue, Is.EqualTo(1L << 32));
+        Assert.That(fpDouble.Value, Is.EqualTo(1.0).Within(1e-9));
+
+        var fpNeg = new FixedPoint64(-2.0);
+        Assert.That(fpNeg.Value, Is.EqualTo(-2.0).Within(1e-9));
+
+        // Zero
+        Assert.That(TestData.FixedPoint64Zero.Value, Is.EqualTo(0.0));
+
+        // Operators
+        var fp641Copy = new FixedPoint64(TestData.FixedPoint641.RawValue);
+        Assert.That(TestData.FixedPoint641 == fp641Copy, Is.True);
+        Assert.That(TestData.FixedPoint641 != TestData.FixedPoint642, Is.True);
+    }
 
     [Test]
     public void FromJsonStringTest()
@@ -75,5 +96,10 @@ public void GetHashCodeTest()
     }
 
     [Test]
-    public void ToStringTest() { }
+    public void ToStringTest()
+    {
+        string s = new FixedPoint64(1.5).ToString();
+        Assert.That(s, Is.Not.Empty);
+        Assert.That(s, Does.Contain("."));
+    }
 }