Wes xx mediapipe integration

Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/TimestampTest.cs

@@ -0,0 +1,254 @@
+// Copyright (c) 2021 homuler
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+using NUnit.Framework;
+
+namespace Mediapipe.Tests
+{
+  public class TimestampTest
+  {
+    #region #isDisposed
+    [Test]
+    public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
+    {
+      using (var timestamp = new Timestamp(1))
+      {
+        Assert.False(timestamp.isDisposed);
+      }
+    }
+
+    [Test]
+    public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
+    {
+      var timestamp = new Timestamp(1);
+      timestamp.Dispose();
+
+      Assert.True(timestamp.isDisposed);
+    }
+    #endregion
+
+    #region #Value
+    [Test]
+    public void Value_ShouldReturnValue()
+    {
+      using (var timestamp = new Timestamp(10))
+      {
+        Assert.AreEqual(10, timestamp.Value());
+      }
+    }
+    #endregion
+
+    #region #Seconds
+    [Test]
+    public void Seconds_ShouldReturnValueInSeconds()
+    {
+      using (var timestamp = new Timestamp(1_000_000))
+      {
+        Assert.AreEqual(1d, timestamp.Seconds(), 1e-9);
+      }
+    }
+    #endregion
+
+    #region #Microseconds
+    [Test]
+    public void Microseconds_ShouldReturnValueInMicroseconds()
+    {
+      using (var timestamp = new Timestamp(1_000_000))
+      {
+        Assert.AreEqual(1_000_000, timestamp.Microseconds());
+      }
+    }
+    #endregion
+
+    #region #IsSpecialValue
+    [Test]
+    public void IsSpecialValue_ShouldReturnFalse_When_ValueIsInRange()
+    {
+      using (var timestamp = new Timestamp(1))
+      {
+        Assert.False(timestamp.IsSpecialValue());
+      }
+    }
+
+    [Test]
+    public void IsSpecialValue_ShouldReturnTrue_When_TimestampIsUnset()
+    {
+      using (var timestamp = Timestamp.Unset())
+      {
+        Assert.True(timestamp.IsSpecialValue());
+      }
+    }
+
+    [Test]
+    public void IsSpecialValue_ShouldReturnTrue_When_TimestampIsUnstarted()
+    {
+      using (var timestamp = Timestamp.Unstarted())
+      {
+        Assert.True(timestamp.IsSpecialValue());
+      }
+    }
+    #endregion
+
+    #region #IsRangeValue
+    [Test]
+    public void IsRangeValue_ShouldReturnTrue_When_ValueIsInRange()
+    {
+      using (var timestamp = new Timestamp(1))
+      {
+        Assert.True(timestamp.IsRangeValue());
+      }
+    }
+
+    [Test]
+    public void IsRangeValue_ShouldReturnFalse_When_TimestampIsPreStream()
+    {
+      using (var timestamp = Timestamp.PreStream())
+      {
+        Assert.False(timestamp.IsRangeValue());
+      }
+    }
+
+    [Test]
+    public void IsRangeValue_ShouldReturnFalse_When_TimestampIsPostStream()
+    {
+      using (var timestamp = Timestamp.PostStream())
+      {
+        Assert.False(timestamp.IsRangeValue());
+      }
+    }
+
+    [Test]
+    public void IsRangeValue_ShouldReturnTrue_When_TimestampIsMin()
+    {
+      using (var timestamp = Timestamp.Min())
+      {
+        Assert.True(timestamp.IsRangeValue());
+      }
+    }
+
+    [Test]
+    public void IsRangeValue_ShouldReturnTrue_When_TimestampIsMax()
+    {
+      using (var timestamp = Timestamp.Max())
+      {
+        Assert.True(timestamp.IsRangeValue());
+      }
+    }
+    #endregion
+
+    #region #IsAllowedInStream
+    [Test]
+    public void IsAllowedInStream_ShouldReturnTrue_When_ValueIsInRange()
+    {
+      using (var timestamp = new Timestamp(1))
+      {
+        Assert.True(timestamp.IsAllowedInStream());
+      }
+    }
+
+    [Test]
+    public void IsAllowedInStream_ShouldReturnFalse_When_TimestampIsOneOverPostStream()
+    {
+      using (var timestamp = Timestamp.OneOverPostStream())
+      {
+        Assert.False(timestamp.IsAllowedInStream());
+      }
+    }
+
+    [Test]
+    public void IsAllowedInStream_ShouldReturnFalse_When_TimestampIsDone()
+    {
+      using (var timestamp = Timestamp.Done())
+      {
+        Assert.False(timestamp.IsAllowedInStream());
+      }
+    }
+    #endregion
+
+    #region #DebugString
+    [Test]
+    public void DebugString_ShouldReturnDebugString()
+    {
+      using (var timestamp = new Timestamp(1))
+      {
+        Assert.AreEqual("1", timestamp.DebugString());
+      }
+    }
+
+    [Test]
+    public void DebugString_ShouldReturnDebugString_When_TimestampIsUnset()
+    {
+      using (var timestamp = Timestamp.Unset())
+      {
+        Assert.AreEqual("Timestamp::Unset()", timestamp.DebugString());
+      }
+    }
+    #endregion
+
+    #region #NextAllowedInStream
+    [Test]
+    public void NextAllowedInStream_ShouldReturnNextTimestamp_When_ValueIsInRange()
+    {
+      using (var timestamp = new Timestamp(1))
+      {
+        using (var nextTimestamp = timestamp.NextAllowedInStream())
+        {
+          Assert.AreEqual(2, nextTimestamp.Microseconds());
+        }
+      }
+    }
+
+    [Test]
+    public void NextAllowedInStream_ShouldReturnOneOverPostStream_When_TimestampIsPostStream()
+    {
+      using (var timestamp = Timestamp.PostStream())
+      {
+        using (var nextTimestamp = timestamp.NextAllowedInStream())
+        {
+          Assert.AreEqual(Timestamp.OneOverPostStream(), nextTimestamp);
+        }
+      }
+    }
+    #endregion
+
+    #region #PreviousAllowedInStream
+    [Test]
+    public void PreviousAllowedInStream_ShouldReturnPreviousTimestamp_When_ValueIsInRange()
+    {
+      using (var timestamp = new Timestamp(1))
+      {
+        using (var nextTimestamp = timestamp.PreviousAllowedInStream())
+        {
+          Assert.AreEqual(0, nextTimestamp.Microseconds());
+        }
+      }
+    }
+
+    [Test]
+    public void PreviousAllowedInStream_ShouldReturnUnstarted_When_TimestampIsPreStream()
+    {
+      using (var timestamp = Timestamp.PreStream())
+      {
+        using (var nextTimestamp = timestamp.PreviousAllowedInStream())
+        {
+          Assert.AreEqual(Timestamp.Unstarted(), nextTimestamp);
+        }
+      }
+    }
+    #endregion
+
+    #region #FromSeconds
+    [Test]
+    public void FromSeconds_ShouldReturnTimestamp()
+    {
+      using (var timestamp = Timestamp.FromSeconds(1d))
+      {
+        Assert.AreEqual(1_000_000, timestamp.Microseconds());
+      }
+    }
+    #endregion
+  }
+}