WeSign/unity-application
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 6 Wiki Activity

Merge branch 'WES-113-write-tests' into 'development'

Browse Source 
Resolve WES-113 "Write tests"

See merge request wesign/unity-application!44
This commit was merged in pull request #44.
This commit is contained in:
Dries Van Schuylenbergh
2023-03-16 12:36:47 +00:00
parent 96fb3c89c3 f6e6afe340
commit 5e26970bad
78 changed files with 184 additions and 5598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
Assets/Accounts/Scripts/AccountsScripts.asmdef Normal file
View File

@@ -0,0 +1,17 @@
{
"name": "AccountsScripts",
"rootNamespace": "",
"references": [
"GUID:6055be8ebefd69e48b49212b09b47b2f",
"GUID:df9d7b70293a2e14d9d3a018c3956f7a"
],
"includePlatforms": [],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

2
Assets/EditModeTests/EditModeTests.asmdef.meta → Assets/Accounts/Scripts/AccountsScripts.asmdef.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: b3d66002fb543bf3fa03c11006f8cb3a
guid: 1631ed2680c61245b8211d943c1639a8
AssemblyDefinitionImporter:
externalObjects: {}
userData:

0
Assets/Common/Scripts/SystemController.cs → Assets/Accounts/Scripts/SystemController.cs
View File

2
Assets/Common/Scripts/SystemController.cs.meta → Assets/Accounts/Scripts/SystemController.cs.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: e901944427bb1104a881881efebd3737
guid: bf5ea73aa43049e45a0ad926db15f315
MonoImporter:
externalObjects: {}
serializedVersion: 2

27
Assets/Accounts/Tests/AccountsTests.asmdef Normal file
View File

@@ -0,0 +1,27 @@
{
"name": "AccountsTests",
"rootNamespace": "",
"references": [
"UnityEngine.TestRunner",
"UnityEditor.TestRunner",
"AccountsScripts",
"InterfacesScripts"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": true,
"precompiledReferences": [
"nunit.framework.dll",
"nunit.framework.dll"
],
"autoReferenced": false,
"defineConstraints": [
"UNITY_INCLUDE_TESTS",
"UNITY_INCLUDE_TESTS"
],
"versionDefines": [],
"noEngineReferences": false
}

5
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Format.meta → Assets/Accounts/Tests/AccountsTests.asmdef.meta
View File

@@ -1,7 +1,6 @@
fileFormatVersion: 2
guid: 4a55a1703b7efe449be66773a42e7ff0
folderAsset: yes
DefaultImporter:
guid: 8500f5aede7627729bd8c97b15e541c4
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:

16
Assets/Accounts/Tests/TestProgress.cs
View File

@@ -1,3 +1,4 @@
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
@@ -90,6 +91,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test for creation of a new progress
/// </summary>
[Test]
public void TestNewProgress()
{
Progress progress = new Progress();
@@ -99,6 +101,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether invalid data will not be added
/// </summary>
[Test]
public void TestProgressAddInvalidData()
{
Progress progress = new Progress();
@@ -108,6 +111,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a duplicated key will be added
/// </summary>
[Test]
public void TestProgressAddDuplicateKey()
{
Progress progress = new Progress();
@@ -118,6 +122,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a <c>int</c> value can be added
/// </summary>
[Test]
public void TestProgressAddInt()
{
Progress progress = new Progress();
@@ -127,6 +132,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a <c>double</c> value can be added
/// </summary>
[Test]
public void TestProgressAddDouble()
{
Progress progress = new Progress();
@@ -136,6 +142,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a <c>string</c> value can be added
/// </summary>
[Test]
public void TestProgressAddString()
{
Progress progress = new Progress();
@@ -145,6 +152,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a serializable struct can be added
/// </summary>
[Test]
public void TestProgressAddSerializableStruct()
{
Progress progress = new Progress();
@@ -154,6 +162,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a non-serializable struct will throw an error
/// </summary>
[Test]
public void TestProgressAddNonSerializableStruct()
{
Debug.Assert(AddNonSerializableStruct());
@@ -162,6 +171,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether an invalid key will throw an error
/// </summary>
[Test]
public void TestProgressGetInvalidKey()
{
Debug.Assert(AccessInvalidKey());
@@ -170,6 +180,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether an invalid type will throw an error
/// </summary>
[Test]
public void TestProgressGetInvalidType()
{
Debug.Assert(AccessInvalidType());
@@ -178,6 +189,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a value is correctly updated
/// </summary>
[Test]
public void TestProgressUpdate()
{
Progress progress = new Progress();
@@ -190,6 +202,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a <c>int</c> value can be read
/// </summary>
[Test]
public void TestProgressGetInt()
{
Progress progress = new Progress();
@@ -200,6 +213,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a <c>double</c> value can be read
/// </summary>
[Test]
public void TestProgressGetDouble()
{
Progress progress = new Progress();
@@ -210,6 +224,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a <c>string</c> value can be read
/// </summary>
[Test]
public void TestProgressGetString()
{
Progress progress = new Progress();
@@ -220,6 +235,7 @@ public class TestProgress : MonoBehaviour
/// <summary>
/// Test whether a serializable struct can be read
/// </summary>
[Test]
public void TestProgressGetStruct()
{
Progress progress = new Progress();

2
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework.meta → Assets/Common/Interfaces.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 3ec4b51665a3e7b499aa9c64fc9c7462
guid: e88996685ebf2274ea70a64e08b7ddd7
folderAsset: yes
DefaultImporter:
externalObjects: {}

0
Assets/Courses/Scripts/CourseIndex.cs → Assets/Common/Interfaces/CourseIndex.cs
View File

2
Assets/Courses/Scripts/CourseIndex.cs.meta → Assets/Common/Interfaces/CourseIndex.cs.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 3ac4eb825ce7bf5499f083eaf34d5d4d
guid: a5bf21dee022ed0489face1c734359de
MonoImporter:
externalObjects: {}
serializedVersion: 2

3
Assets/Common/Interfaces/InterfacesScripts.asmdef Normal file
View File

@@ -0,0 +1,3 @@
{
"name": "InterfacesScripts"
}

5
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet.meta → Assets/Common/Interfaces/InterfacesScripts.asmdef.meta
View File

@@ -1,7 +1,6 @@
fileFormatVersion: 2
guid: 55cd80546e3f9d043b59677c12f0e891
folderAsset: yes
DefaultImporter:
guid: df9d7b70293a2e14d9d3a018c3956f7a
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:

0
Assets/Common/Scripts/MinigameIndex.cs → Assets/Common/Interfaces/MinigameIndex.cs
View File

2
Assets/Common/Scripts/MinigameIndex.cs.meta → Assets/Common/Interfaces/MinigameIndex.cs.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 44a1fb926248fe240bed2d5c3820630b
guid: 97282ff3b465e3c4682d218b3819b2e8
MonoImporter:
externalObjects: {}
serializedVersion: 2

12
Assets/Common/Interfaces/Score.cs Normal file
View File

@@ -0,0 +1,12 @@
using System;
/// <summary>
/// Score class TODO: Move to separate file
/// </summary>
[Serializable]
public class Score
{
public int scoreValue;
public string time;
}

2
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Format/ImageFrameTest.cs.meta → Assets/Common/Interfaces/Score.cs.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: efccb8a8c7f87c9629872169190107db
guid: 295706da5995d69468daf35ad5527089
MonoImporter:
externalObjects: {}
serializedVersion: 2

19
Assets/Common/Scripts/CommonScripts.asmdef Normal file
View File

@@ -0,0 +1,19 @@
{
"name": "CommonScripts",
"rootNamespace": "",
"references": [
"GUID:6055be8ebefd69e48b49212b09b47b2f",
"GUID:63c63e721f65ebb7d871cb9ef49f4752",
"GUID:1631ed2680c61245b8211d943c1639a8",
"GUID:df9d7b70293a2e14d9d3a018c3956f7a"
],
"includePlatforms": [],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

7
Assets/Common/Scripts/CommonScripts.asmdef.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 3444c67d5a3a93e5a95a48906078c372
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

12
Assets/Common/Scripts/MinigameActivityScreen.cs
View File

@@ -107,7 +107,7 @@ public class MinigameActivityScreen : MonoBehaviour
int index = minigameList.currentMinigameIndex;
Minigame minigame = minigameList.minigames[index];
List<Tuple<string, Sprite, GameController.Score>> allScores = new List<Tuple<string, Sprite, GameController.Score>>();
List<Tuple<string, Sprite, Score>> allScores = new List<Tuple<string, Sprite, Score>>();
foreach (User user in userList.GetUsers())
{
// Get user's progress for this minigame
@@ -115,10 +115,10 @@ public class MinigameActivityScreen : MonoBehaviour
if (progress != null)
{
// Add scores to dictionary
List<GameController.Score> scores = progress.Get<List<GameController.Score>>("scores");
foreach (GameController.Score score in scores)
List<Score> scores = progress.Get<List<Score>>("scores");
foreach (Score score in scores)
{
allScores.Add(new Tuple<string, Sprite, GameController.Score>(user.username, user.avatar, score));
allScores.Add(new Tuple<string, Sprite, Score>(user.username, user.avatar, score));
}
}
}
@@ -127,11 +127,11 @@ public class MinigameActivityScreen : MonoBehaviour
allScores.Sort((a, b) => b.Item3.scoreValue.CompareTo(a.Item3.scoreValue));
// Instantiate scoreboard entries
foreach (Tuple<string, Sprite, GameController.Score> tup in allScores.Take(3))
foreach (Tuple<string, Sprite, Score> tup in allScores.Take(3))
{
string username = tup.Item1;
Sprite sprite = tup.Item2;
GameController.Score score = tup.Item3;
Score score = tup.Item3;
GameObject instance = GameObject.Instantiate(prefab, userContainer);
instance.transform.Find("Title").GetComponent<TMP_Text>().text = username;

18
Assets/Courses/Scripts/CourseScripts.asmdef Normal file
View File

@@ -0,0 +1,18 @@
{
"name": "CourseScripts",
"rootNamespace": "",
"references": [
"Unity.TextMeshPro",
"AccountsScripts",
"InterfacesScripts"
],
"includePlatforms": [],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

7
Assets/Courses/Scripts/CourseScripts.asmdef.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 63c63e721f65ebb7d871cb9ef49f4752
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

11
Assets/EditModeTests/BasicTest.cs
View File

@@ -1,11 +0,0 @@
using NUnit.Framework;
public class BasicTest
{
// check if edit mode tests works
[Test]
public void AlwaysTrueTest()
{
Assert.True(true);
}
}

9
Assets/EditModeTests/EditModeTests.asmdef
View File

@@ -1,9 +0,0 @@
{
"name": "EditModeTests",
"optionalUnityReferences": [
"TestAssemblies"
],
"includePlatforms": [
"Editor"
]
}

12
Assets/SpellingBee/Scripts/GameController.cs
View File

@@ -6,7 +6,7 @@ using TMPro;
using UnityEngine;
using UnityEngine.UI;
public class GameController : MonoBehaviour
public partial class GameController : MonoBehaviour
{
/// <summary>
/// All of the words that can be used in this session
@@ -191,16 +191,6 @@ public class GameController : MonoBehaviour
/// </summary>
public GameObject scoreboardEntry;
/// <summary>
/// Score class TODO: Move to separate file
/// </summary>
[Serializable]
public class Score
{
public int scoreValue;
public string time;
}
/// <summary>
/// Start is called before the first frame update

14
Assets/SpellingBee/Scripts/Score.cs Normal file
View File

@@ -0,0 +1,14 @@
using System;
public partial class GameController
{
/// <summary>
/// Score class TODO: Move to separate file
/// </summary>
[Serializable]
public class Score
{
public int scoreValue;
public string time;
}
}

2
Assets/EditModeTests/BasicTest.cs.meta → Assets/SpellingBee/Scripts/Score.cs.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 74f8b297e568e071198f12d32c3f32c0
guid: 44c1f8e0fa862b44485ebaa3c81698fc
MonoImporter:
externalObjects: {}
serializedVersion: 2

19
Assets/SpellingBee/Scripts/SpellingBeeScripts.asmdef Normal file
View File

@@ -0,0 +1,19 @@
{
"name": "SpellingBeeScripts",
"rootNamespace": "",
"references": [
"GUID:6055be8ebefd69e48b49212b09b47b2f",
"GUID:1631ed2680c61245b8211d943c1639a8",
"GUID:3444c67d5a3a93e5a95a48906078c372",
"GUID:df9d7b70293a2e14d9d3a018c3956f7a"
],
"includePlatforms": [],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

7
Assets/SpellingBee/Scripts/SpellingBeeScripts.asmdef.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 49d8025a5c8c313cea12c9a1de36c09b
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

167
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/CalculatorGraphTest.cs
View File

@@ -1,167 +0,0 @@
// 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 CalculatorGraphTest
{
private const string _ValidConfigText = @"node {
calculator: ""PassThroughCalculator""
input_stream: ""in""
output_stream: ""out1""
}
node {
calculator: ""PassThroughCalculator""
input_stream: ""out1""
output_stream: ""out""
}
input_stream: ""in""
output_stream: ""out""
";
#region Constructor
[Test]
public void Ctor_ShouldInstantiateCalculatorGraph_When_CalledWithNoArguments()
{
Assert.DoesNotThrow(() =>
{
var graph = new CalculatorGraph();
graph.Dispose();
});
}
[Test]
public void Ctor_ShouldInstantiateCalculatorGraph_When_CalledWithConfigText()
{
using (var graph = new CalculatorGraph(_ValidConfigText))
{
var config = graph.Config();
Assert.AreEqual("in", config.InputStream[0]);
Assert.AreEqual("out", config.OutputStream[0]);
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var graph = new CalculatorGraph())
{
Assert.False(graph.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var graph = new CalculatorGraph();
graph.Dispose();
Assert.True(graph.isDisposed);
}
#endregion
#region #Initialize
[Test]
public void Initialize_ShouldReturnOk_When_CalledWithConfig_And_ConfigIsNotSet()
{
using (var graph = new CalculatorGraph())
{
using (var status = graph.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ValidConfigText)))
{
Assert.True(status.Ok());
}
var config = graph.Config();
Assert.AreEqual("in", config.InputStream[0]);
Assert.AreEqual("out", config.OutputStream[0]);
}
}
[Test]
public void Initialize_ShouldReturnInternalError_When_CalledWithConfig_And_ConfigIsSet()
{
using (var graph = new CalculatorGraph(_ValidConfigText))
{
using (var status = graph.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ValidConfigText)))
{
Assert.AreEqual(Status.StatusCode.Internal, status.Code());
}
}
}
[Test]
public void Initialize_ShouldReturnOk_When_CalledWithConfigAndSidePacket_And_ConfigIsNotSet()
{
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("flag", new BoolPacket(true));
using (var graph = new CalculatorGraph())
{
var config = CalculatorGraphConfig.Parser.ParseFromTextFormat(_ValidConfigText);
using (var status = graph.Initialize(config, sidePacket))
{
Assert.True(status.Ok());
}
}
}
}
[Test]
public void Initialize_ShouldReturnInternalError_When_CalledWithConfigAndSidePacket_And_ConfigIsSet()
{
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("flag", new BoolPacket(true));
using (var graph = new CalculatorGraph(_ValidConfigText))
{
var config = CalculatorGraphConfig.Parser.ParseFromTextFormat(_ValidConfigText);
using (var status = graph.Initialize(config, sidePacket))
{
Assert.AreEqual(Status.StatusCode.Internal, status.Code());
}
}
}
}
#endregion
#region lifecycle
[Test]
public void LifecycleMethods_ShouldControlGraphLifeCycle()
{
using (var graph = new CalculatorGraph(_ValidConfigText))
{
Assert.True(graph.StartRun().Ok());
Assert.False(graph.GraphInputStreamsClosed());
Assert.True(graph.WaitUntilIdle().Ok());
Assert.True(graph.CloseAllPacketSources().Ok());
Assert.True(graph.GraphInputStreamsClosed());
Assert.True(graph.WaitUntilDone().Ok());
Assert.False(graph.HasError());
}
}
[Test]
public void Cancel_ShouldCancelGraph()
{
using (var graph = new CalculatorGraph(_ValidConfigText))
{
Assert.True(graph.StartRun().Ok());
graph.Cancel();
Assert.AreEqual(Status.StatusCode.Cancelled, graph.WaitUntilDone().Code());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/CalculatorGraphTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 083c8421f4820d09290f0de495a23ec2
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

256
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Format/ImageFrameTest.cs
View File

@@ -1,256 +0,0 @@
// 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;
using System;
using System.Linq;
using Unity.Collections;
namespace Mediapipe.Tests
{
public class ImageFrameTest
{
#region Constructor
[Test]
public void Ctor_ShouldInstantiateImageFrame_When_CalledWithNoArguments()
{
using (var imageFrame = new ImageFrame())
{
Assert.AreEqual(ImageFormat.Types.Format.Unknown, imageFrame.Format());
Assert.AreEqual(0, imageFrame.Width());
Assert.AreEqual(0, imageFrame.Height(), 0);
Assert.AreEqual(0, imageFrame.ChannelSize());
Assert.AreEqual(0, imageFrame.NumberOfChannels());
Assert.AreEqual(0, imageFrame.ByteDepth());
Assert.AreEqual(0, imageFrame.WidthStep());
Assert.AreEqual(0, imageFrame.PixelDataSize());
Assert.AreEqual(0, imageFrame.PixelDataSizeStoredContiguously());
Assert.True(imageFrame.IsEmpty());
Assert.False(imageFrame.IsContiguous());
Assert.False(imageFrame.IsAligned(16));
Assert.AreEqual(IntPtr.Zero, imageFrame.MutablePixelData());
}
}
[Test]
public void Ctor_ShouldInstantiateImageFrame_When_CalledWithFormat()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Sbgra, 640, 480))
{
Assert.AreEqual(ImageFormat.Types.Format.Sbgra, imageFrame.Format());
Assert.AreEqual(640, imageFrame.Width());
Assert.AreEqual(480, imageFrame.Height());
Assert.AreEqual(1, imageFrame.ChannelSize());
Assert.AreEqual(4, imageFrame.NumberOfChannels());
Assert.AreEqual(1, imageFrame.ByteDepth());
Assert.AreEqual(640 * 4, imageFrame.WidthStep());
Assert.AreEqual(640 * 480 * 4, imageFrame.PixelDataSize());
Assert.AreEqual(640 * 480 * 4, imageFrame.PixelDataSizeStoredContiguously());
Assert.False(imageFrame.IsEmpty());
Assert.True(imageFrame.IsContiguous());
Assert.True(imageFrame.IsAligned(16));
Assert.AreNotEqual(IntPtr.Zero, imageFrame.MutablePixelData());
}
}
[Test]
public void Ctor_ShouldInstantiateImageFrame_When_CalledWithFormatAndAlignmentBoundary()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray8, 100, 100, 8))
{
Assert.AreEqual(100, imageFrame.Width());
Assert.AreEqual(1, imageFrame.NumberOfChannels());
Assert.AreEqual(104, imageFrame.WidthStep());
}
}
[Test]
public void Ctor_ShouldInstantiateImageFrame_When_CalledWithPixelData()
{
var pixelData = new NativeArray<byte>(32, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
var srcBytes = new byte[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
};
pixelData.CopyFrom(srcBytes);
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Sbgra, 4, 2, 16, pixelData))
{
Assert.AreEqual(4, imageFrame.Width());
Assert.AreEqual(2, imageFrame.Height());
Assert.False(imageFrame.IsEmpty());
var bytes = new byte[32];
imageFrame.CopyToBuffer(bytes);
Assert.IsEmpty(bytes.Where((x, i) => x != srcBytes[i]));
}
}
[Test, SignalAbort]
public void Ctor_ShouldThrowMediaPipeException_When_CalledWithInvalidArgument()
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { new ImageFrame(ImageFormat.Types.Format.Sbgra, 640, 480, 0); });
#pragma warning restore IDE0058
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var imageFrame = new ImageFrame())
{
Assert.False(imageFrame.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var imageFrame = new ImageFrame();
imageFrame.Dispose();
Assert.True(imageFrame.isDisposed);
}
#endregion
#region #SetToZero
[Test]
public void SetToZero_ShouldSetZeroToAllBytes()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray8, 10, 10))
{
imageFrame.SetToZero();
var bytes = new byte[100];
imageFrame.CopyToBuffer(bytes);
Assert.True(bytes.All((x) => x == 0));
}
}
#endregion
#region #SetAlignmentPaddingAreas
[Test]
public void SetAlignmentPaddingAreas_ShouldNotThrow()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray8, 10, 10, 16))
{
Assert.DoesNotThrow(() => { imageFrame.SetAlignmentPaddingAreas(); });
}
}
#endregion
#region CopyToBuffer
[Test, SignalAbort]
public void CopyToByteBuffer_ShouldThrowException_When_BufferDepthIsWrong()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray16, 10, 10))
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { imageFrame.CopyToBuffer(new byte[100]); });
#pragma warning restore IDE0058
}
}
[Test]
public void CopyToByteBuffer_ShouldReturnByteArray_When_BufferSizeIsLargeEnough()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray8, 10, 10))
{
var normalBuffer = new byte[100];
var largeBuffer = new byte[120];
imageFrame.CopyToBuffer(normalBuffer);
imageFrame.CopyToBuffer(largeBuffer);
Assert.IsEmpty(normalBuffer.Where((x, i) => x != largeBuffer[i]));
}
}
[Test, SignalAbort]
public void CopyToByteBuffer_ShouldThrowException_When_BufferSizeIsTooSmall()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray8, 10, 10))
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { imageFrame.CopyToBuffer(new byte[99]); });
#pragma warning restore IDE0058
}
}
[Test, SignalAbort]
public void CopyToUshortBuffer_ShouldThrowException_When_BufferDepthIsWrong()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray8, 10, 10))
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { imageFrame.CopyToBuffer(new ushort[100]); });
#pragma warning restore IDE0058
}
}
[Test]
public void CopyToUshortBuffer_ShouldReturnUshortArray_When_BufferSizeIsLargeEnough()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray16, 10, 10))
{
var normalBuffer = new ushort[100];
var largeBuffer = new ushort[120];
imageFrame.CopyToBuffer(normalBuffer);
imageFrame.CopyToBuffer(largeBuffer);
Assert.IsEmpty(normalBuffer.Where((x, i) => x != largeBuffer[i]));
}
}
[Test, SignalAbort]
public void CopyToUshortBuffer_ShouldThrowException_When_BufferSizeIsTooSmall()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray16, 10, 10))
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { imageFrame.CopyToBuffer(new ushort[99]); });
#pragma warning restore IDE0058
}
}
[Test, SignalAbort]
public void CopyToFloatBuffer_ShouldThrowException_When_BufferDepthIsWrong()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Gray8, 10, 10))
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { imageFrame.CopyToBuffer(new float[100]); });
#pragma warning restore IDE0058
}
}
[Test]
public void CopyToFloatBuffer_ShouldReturnFloatArray_When_BufferSizeIsLargeEnough()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Vec32F1, 10, 10))
{
var normalBuffer = new float[100];
var largeBuffer = new float[120];
imageFrame.CopyToBuffer(normalBuffer);
imageFrame.CopyToBuffer(largeBuffer);
Assert.IsEmpty(normalBuffer.Where((x, i) => Math.Abs(x - largeBuffer[i]) > 1e-9));
}
}
[Test, SignalAbort]
public void CopyToFloatBuffer_ShouldThrowException_When_BufferSizeIsTooSmall()
{
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Vec32F1, 10, 10))
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { imageFrame.CopyToBuffer(new float[99]); });
#pragma warning restore IDE0058
}
}
#endregion
}
}

132
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/BoolPacketTest.cs
View File

@@ -1,132 +0,0 @@
// 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;
using System;
namespace Mediapipe.Tests
{
public class BoolPacketTest
{
#region Constructor
[Test, SignalAbort]
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
using (var packet = new BoolPacket())
{
#pragma warning disable IDE0058
Assert.AreEqual(Status.StatusCode.Internal, packet.ValidateAsType().Code());
Assert.Throws<MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
#pragma warning restore IDE0058
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithTrue()
{
using (var packet = new BoolPacket(true))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.True(packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithFalse()
{
using (var packet = new BoolPacket(false))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.False(packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithValueAndTimestamp()
{
using (var timestamp = new Timestamp(1))
{
using (var packet = new BoolPacket(true, timestamp))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.True(packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new BoolPacket())
{
Assert.False(packet.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new BoolPacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
#endregion
#region #At
[Test]
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
var packet = new BoolPacket(true).At(timestamp);
Assert.True(packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.True(newPacket.Get());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
#endregion
#region #Consume
[Test]
public void Consume_ShouldThrowNotSupportedException()
{
using (var packet = new BoolPacket())
{
#pragma warning disable IDE0058
Assert.Throws<NotSupportedException>(() => { packet.Consume(); });
#pragma warning restore IDE0058
}
}
#endregion
#region #ValidateAsType
[Test]
public void ValidateAsType_ShouldReturnOk_When_ValueIsSet()
{
using (var packet = new BoolPacket(true))
{
Assert.True(packet.ValidateAsType().Ok());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/BoolPacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: b59151b6708d204ee970450f8028d00b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

137
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/FloatArrayPacketTest.cs
View File

@@ -1,137 +0,0 @@
// 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;
using System;
namespace Mediapipe.Tests
{
public class FloatArrayPacketTest
{
#region Constructor
[Test, SignalAbort]
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
using (var packet = new FloatArrayPacket())
{
#pragma warning disable IDE0058
packet.length = 0;
Assert.AreEqual(Status.StatusCode.Internal, packet.ValidateAsType().Code());
Assert.Throws<MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
#pragma warning restore IDE0058
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithEmptyArray()
{
float[] array = { };
using (var packet = new FloatArrayPacket(array))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(array, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithArray()
{
float[] array = { 0.01f };
using (var packet = new FloatArrayPacket(array))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(array, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithValueAndTimestamp()
{
float[] array = { 0.01f, 0.02f };
using (var timestamp = new Timestamp(1))
{
using (var packet = new FloatArrayPacket(array, timestamp))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(array, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new FloatArrayPacket())
{
Assert.False(packet.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new FloatArrayPacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
#endregion
#region #At
[Test]
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
float[] array = { 0.0f };
var packet = new FloatArrayPacket(array).At(timestamp);
Assert.AreEqual(array, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.AreEqual(array, newPacket.Get());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
#endregion
#region #Consume
[Test]
public void Consume_ShouldThrowNotSupportedException()
{
using (var packet = new FloatArrayPacket())
{
#pragma warning disable IDE0058
Assert.Throws<NotSupportedException>(() => { packet.Consume(); });
#pragma warning restore IDE0058
}
}
#endregion
#region #ValidateAsType
[Test]
public void ValidateAsType_ShouldReturnOk_When_ValueIsSet()
{
float[] array = { 0.01f };
using (var packet = new FloatArrayPacket(array))
{
Assert.True(packet.ValidateAsType().Ok());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/FloatArrayPacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 43430c0ef642804f9a6347fce4ec497a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

120
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/FloatPacketTest.cs
View File

@@ -1,120 +0,0 @@
// 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;
using System;
namespace Mediapipe.Tests
{
public class FloatPacketTest
{
#region Constructor
[Test, SignalAbort]
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
using (var packet = new FloatPacket())
{
#pragma warning disable IDE0058
Assert.AreEqual(Status.StatusCode.Internal, packet.ValidateAsType().Code());
Assert.Throws<MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
#pragma warning restore IDE0058
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithValue()
{
using (var packet = new FloatPacket(0.01f))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(0.01f, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithValueAndTimestamp()
{
using (var timestamp = new Timestamp(1))
{
using (var packet = new FloatPacket(0.01f, timestamp))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(0.01f, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new FloatPacket())
{
Assert.False(packet.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new FloatPacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
#endregion
#region #At
[Test]
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
var packet = new FloatPacket(0).At(timestamp);
Assert.AreEqual(0.0f, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.AreEqual(0.0f, newPacket.Get());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
#endregion
#region #Consume
[Test]
public void Consume_ShouldThrowNotSupportedException()
{
using (var packet = new FloatPacket())
{
#pragma warning disable IDE0058
Assert.Throws<NotSupportedException>(() => { packet.Consume(); });
#pragma warning restore IDE0058
}
}
#endregion
#region #ValidateAsType
[Test]
public void ValidateAsType_ShouldReturnOk_When_ValueIsSet()
{
using (var packet = new FloatPacket(0.01f))
{
Assert.True(packet.ValidateAsType().Ok());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/FloatPacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 39a81137616a1218b9b2b11d2feeadd0
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

176
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/FloatVectorPacketTest.cs
View File

@@ -1,176 +0,0 @@
// 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;
using System;
using System.Collections.Generic;
namespace Mediapipe.Tests
{
public class FloatVectorPacketTest
{
#region Constructor
[Test, SignalAbort]
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
using (var packet = new FloatVectorPacket())
{
#pragma warning disable IDE0058
Assert.AreEqual(Status.StatusCode.Internal, packet.ValidateAsType().Code());
Assert.Throws<MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
#pragma warning restore IDE0058
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithEmptyArray()
{
float[] data = { };
using (var packet = new FloatVectorPacket(data))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(data, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithArray()
{
float[] data = { 0.01f };
using (var packet = new FloatVectorPacket(data))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(data, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithValueAndTimestamp()
{
float[] data = { 0.01f, 0.02f };
using (var timestamp = new Timestamp(1))
{
using (var packet = new FloatVectorPacket(data, timestamp))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(data, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithEmptyList()
{
var data = new List<float>();
using (var packet = new FloatVectorPacket(data))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(data, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithList()
{
var data = new List<float>() { 0.01f };
using (var packet = new FloatVectorPacket(data))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(data, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithListAndTimestamp()
{
var data = new List<float>() { 0.01f, 0.02f };
using (var timestamp = new Timestamp(1))
{
using (var packet = new FloatVectorPacket(data, timestamp))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(data, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new FloatVectorPacket())
{
Assert.False(packet.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new FloatVectorPacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
#endregion
#region #At
[Test]
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
var data = new List<float>() { 0.0f };
var packet = new FloatVectorPacket(data).At(timestamp);
Assert.AreEqual(data, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.AreEqual(data, newPacket.Get());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
#endregion
#region #Consume
[Test]
public void Consume_ShouldThrowNotSupportedException()
{
using (var packet = new FloatVectorPacket())
{
#pragma warning disable IDE0058
Assert.Throws<NotSupportedException>(() => { packet.Consume(); });
#pragma warning restore IDE0058
}
}
#endregion
#region #ValidateAsType
[Test]
public void ValidateAsType_ShouldReturnOk_When_ValueIsSet()
{
float[] array = { 0.01f };
using (var packet = new FloatVectorPacket(array))
{
Assert.True(packet.ValidateAsType().Ok());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/FloatVectorPacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 8a567519c65348c47ae2c5784431179e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

178
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/ImageFramePacketTest.cs
View File

@@ -1,178 +0,0 @@
// 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 ImageFramePacketTest
{
#region Constructor
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
using (var packet = new ImageFramePacket())
{
using (var statusOrImageFrame = packet.Consume())
{
Assert.AreEqual(Status.StatusCode.Internal, packet.ValidateAsType().Code());
Assert.AreEqual(Status.StatusCode.Internal, statusOrImageFrame.status.Code());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithValue()
{
var srcImageFrame = new ImageFrame();
using (var packet = new ImageFramePacket(srcImageFrame))
{
Assert.True(srcImageFrame.isDisposed);
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
using (var statusOrImageFrame = packet.Consume())
{
Assert.True(statusOrImageFrame.Ok());
using (var imageFrame = statusOrImageFrame.Value())
{
Assert.AreEqual(ImageFormat.Types.Format.Unknown, imageFrame.Format());
}
}
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithValueAndTimestamp()
{
var srcImageFrame = new ImageFrame();
using (var timestamp = new Timestamp(1))
{
using (var packet = new ImageFramePacket(srcImageFrame, timestamp))
{
Assert.True(srcImageFrame.isDisposed);
Assert.True(packet.ValidateAsType().Ok());
using (var statusOrImageFrame = packet.Consume())
{
Assert.True(statusOrImageFrame.Ok());
using (var imageFrame = statusOrImageFrame.Value())
{
Assert.AreEqual(ImageFormat.Types.Format.Unknown, imageFrame.Format());
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
}
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new ImageFramePacket())
{
Assert.False(packet.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new ImageFramePacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
#endregion
#region #At
[Test]
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
var packet = new ImageFramePacket(new ImageFrame(ImageFormat.Types.Format.Srgba, 10, 10)).At(timestamp);
Assert.AreEqual(10, packet.Get().Width());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.AreEqual(10, newPacket.Get().Width());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
#endregion
#region #Get
[Test, SignalAbort]
public void Get_ShouldThrowMediaPipeException_When_DataIsEmpty()
{
using (var packet = new ImageFramePacket())
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { packet.Get(); });
#pragma warning restore IDE0058
}
}
public void Get_ShouldReturnImageFrame_When_DataIsNotEmpty()
{
using (var packet = new ImageFramePacket(new ImageFrame(ImageFormat.Types.Format.Sbgra, 10, 10)))
{
using (var imageFrame = packet.Get())
{
Assert.AreEqual(ImageFormat.Types.Format.Sbgra, imageFrame.Format());
Assert.AreEqual(10, imageFrame.Width());
Assert.AreEqual(10, imageFrame.Height());
}
}
}
#endregion
#region #Consume
[Test]
public void Consume_ShouldReturnImageFrame()
{
using (var packet = new ImageFramePacket(new ImageFrame(ImageFormat.Types.Format.Sbgra, 10, 10)))
{
using (var statusOrImageFrame = packet.Consume())
{
Assert.True(statusOrImageFrame.Ok());
using (var imageFrame = statusOrImageFrame.Value())
{
Assert.AreEqual(ImageFormat.Types.Format.Sbgra, imageFrame.Format());
Assert.AreEqual(10, imageFrame.Width());
Assert.AreEqual(10, imageFrame.Height());
}
}
}
}
#endregion
#region #ValidateAsType
[Test]
public void ValidateAsType_ShouldReturnOk_When_ValueIsSet()
{
using (var packet = new ImageFramePacket(new ImageFrame()))
{
Assert.True(packet.ValidateAsType().Ok());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/ImageFramePacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: a3eb7f3538d626cd68495da48b11e6f7
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

111
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/MatrixPacketTest.cs
View File

@@ -1,111 +0,0 @@
// 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 System.Collections.Generic;
using NUnit.Framework;
using System;
namespace Mediapipe.Tests
{
public class MatrixPacketTest
{
#region Constructor
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithValue()
{
var matrix = CreateMatrixInputData();
using (var packet = new MatrixPacket(matrix))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(matrix, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new MatrixPacket())
{
Assert.False(packet.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new MatrixPacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
#endregion
#region #At
[Test]
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
var matrix = CreateMatrixInputData();
var packet = new MatrixPacket(matrix).At(timestamp);
Assert.AreEqual(matrix, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.AreEqual(matrix, newPacket.Get());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
#endregion
#region #Consume
[Test]
public void Consume_ShouldThrowNotSupportedException()
{
using (var packet = new MatrixPacket())
{
#pragma warning disable IDE0058
Assert.Throws<NotSupportedException>(() => { packet.Consume(); });
#pragma warning restore IDE0058
}
}
#endregion
#region #ValidateAsType
[Test]
public void ValidateAsType_ShouldReturnOk_When_ValueIsSet()
{
using (var packet = new MatrixPacket(CreateMatrixInputData()))
{
Assert.True(packet.ValidateAsType().Ok());
}
}
#endregion
private static MatrixData CreateMatrixInputData()
{
var matrix = new MatrixData();
matrix.PackedData.Add(0);
matrix.PackedData.Add(1);
matrix.PackedData.Add(2);
matrix.PackedData.Add(3);
matrix.PackedData.Add(4);
matrix.PackedData.Add(5);
matrix.Rows = 2;
matrix.Cols = 3;
return matrix;
}
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/MatrixPacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: a3a4963f37dcdcc43a8292c2493c19bc
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

57
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/PacketTest.cs
View File

@@ -1,57 +0,0 @@
// 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 PacketTest
{
#region #DebugString
[Test]
public void DebugString_ShouldReturnDebugString_When_InstantiatedWithDefaultConstructor()
{
using (var packet = new BoolPacket())
{
Assert.AreEqual("mediapipe::Packet with timestamp: Timestamp::Unset() and no data", packet.DebugString());
}
}
#endregion
#region #DebugTypeName
[Test]
public void DebugTypeName_ShouldReturnTypeName_When_ValueIsNotSet()
{
using (var packet = new BoolPacket())
{
Assert.AreEqual("{empty}", packet.DebugTypeName());
}
}
#endregion
#region #RegisteredTypeName
[Test]
public void RegisteredTypeName_ShouldReturnEmptyString()
{
using (var packet = new BoolPacket())
{
Assert.AreEqual("", packet.RegisteredTypeName());
}
}
#endregion
#region #ValidateAsProtoMessageLite
[Test]
public void ValidateAsProtoMessageLite_ShouldReturnInvalidArgument_When_ValueIsBool()
{
using (var packet = new BoolPacket(true))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, packet.ValidateAsProtoMessageLite().Code());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/PacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 8c8b062f481adfe73be16b679e3c1cca
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

129
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/SidePacketTest.cs
View File

@@ -1,129 +0,0 @@
// 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 SidePacketTest
{
#region #size
[Test]
public void Size_ShouldReturnZero_When_Initialized()
{
using (var sidePacket = new SidePacket())
{
Assert.AreEqual(0, sidePacket.size);
}
}
[Test]
public void Size_ShouldReturnSize_When_AfterPacketsAreEmplaced()
{
using (var sidePacket = new SidePacket())
{
var flagPacket = new BoolPacket(true);
var valuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("flag", flagPacket);
sidePacket.Emplace("value", valuePacket);
Assert.AreEqual(2, sidePacket.size);
Assert.True(flagPacket.isDisposed);
Assert.True(valuePacket.isDisposed);
}
}
#endregion
#region #Emplace
[Test]
public void Emplace_ShouldInsertAndDisposePacket()
{
using (var sidePacket = new SidePacket())
{
Assert.AreEqual(0, sidePacket.size);
Assert.IsNull(sidePacket.At<FloatPacket, float>("value"));
var flagPacket = new FloatPacket(1.0f);
sidePacket.Emplace("value", flagPacket);
Assert.AreEqual(1, sidePacket.size);
Assert.AreEqual(1.0f, sidePacket.At<FloatPacket, float>("value").Get());
Assert.True(flagPacket.isDisposed);
}
}
[Test]
public void Emplace_ShouldIgnoreValue_When_KeyExists()
{
using (var sidePacket = new SidePacket())
{
var oldValuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("value", oldValuePacket);
Assert.AreEqual(1.0f, sidePacket.At<FloatPacket, float>("value").Get());
var newValuePacket = new FloatPacket(2.0f);
sidePacket.Emplace("value", newValuePacket);
Assert.AreEqual(1.0f, sidePacket.At<FloatPacket, float>("value").Get());
}
}
#endregion
#region #Erase
[Test]
public void Erase_ShouldDoNothing_When_KeyDoesNotExist()
{
using (var sidePacket = new SidePacket())
{
var count = sidePacket.Erase("value");
Assert.AreEqual(0, sidePacket.size);
Assert.AreEqual(0, count);
}
}
[Test]
public void Erase_ShouldEraseKey_When_KeyExists()
{
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("value", new BoolPacket(true));
Assert.AreEqual(1, sidePacket.size);
var count = sidePacket.Erase("value");
Assert.AreEqual(0, sidePacket.size);
Assert.AreEqual(1, count);
}
}
#endregion
#region #Clear
[Test]
public void Clear_ShouldDoNothing_When_SizeIsZero()
{
using (var sidePacket = new SidePacket())
{
sidePacket.Clear();
Assert.AreEqual(0, sidePacket.size);
}
}
[Test]
public void Clear_ShouldClearAllKeys_When_SizeIsNotZero()
{
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("flag", new BoolPacket(true));
sidePacket.Emplace("value", new FloatPacket(1.0f));
Assert.AreEqual(2, sidePacket.size);
sidePacket.Clear();
Assert.AreEqual(0, sidePacket.size);
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/SidePacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 148809b5633f2f8cd9f277e01bb7b0ca
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

177
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/StringPacketTest.cs
View File

@@ -1,177 +0,0 @@
// 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;
using System.Text.RegularExpressions;
namespace Mediapipe.Tests
{
public class StringPacketTest
{
#region Constructor
[Test, SignalAbort]
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
using (var packet = new StringPacket())
{
#pragma warning disable IDE0058
Assert.AreEqual(Status.StatusCode.Internal, packet.ValidateAsType().Code());
Assert.Throws<MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
#pragma warning restore IDE0058
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithString()
{
using (var packet = new StringPacket("test"))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual("test", packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithByteArray()
{
var bytes = new byte[] { (byte)'t', (byte)'e', (byte)'s', (byte)'t' };
using (var packet = new StringPacket(bytes))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual("test", packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithStringAndTimestamp()
{
using (var timestamp = new Timestamp(1))
{
using (var packet = new StringPacket("test", timestamp))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual("test", packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
}
[Test]
public void Ctor_ShouldInstantiatePacket_When_CalledWithByteArrayAndTimestamp()
{
var bytes = new byte[] { (byte)'t', (byte)'e', (byte)'s', (byte)'t' };
using (var timestamp = new Timestamp(1))
{
using (var packet = new StringPacket(bytes, timestamp))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual("test", packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new StringPacket())
{
Assert.False(packet.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new StringPacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
#endregion
#region #At
[Test]
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
var str = "str";
var packet = new StringPacket(str).At(timestamp);
Assert.AreEqual(str, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.AreEqual(str, newPacket.Get());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
#endregion
#region #GetByteArray
[Test]
public void GetByteArray_ShouldReturnByteArray()
{
var bytes = new byte[] { (byte)'a', (byte)'b', 0, (byte)'c' };
using (var packet = new StringPacket(bytes))
{
Assert.AreEqual(bytes, packet.GetByteArray());
Assert.AreEqual("ab", packet.Get());
}
}
#endregion
#region #Consume
[Test]
public void Consume_ShouldReturnStatusOrString_When_PacketIsEmpty()
{
using (var packet = new StringPacket())
{
using (var statusOrString = packet.Consume())
{
Assert.False(statusOrString.Ok());
Assert.AreEqual(Status.StatusCode.Internal, statusOrString.status.Code());
}
}
}
[Test]
public void Consume_ShouldReturnStatusOrString_When_PacketIsNotEmpty()
{
using (var packet = new StringPacket("abc"))
{
using (var statusOrString = packet.Consume())
{
Assert.True(statusOrString.Ok());
Assert.AreEqual("abc", statusOrString.Value());
}
Assert.True(packet.IsEmpty());
}
}
#endregion
#region #ValidateAsType
[Test]
public void ValidateAsType_ShouldReturnOk_When_ValueIsSet()
{
using (var packet = new StringPacket("test"))
{
Assert.True(packet.ValidateAsType().Ok());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Packet/StringPacketTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 1fc360374ea123c28b7da8b9b81ebac6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 62cf7906c5d34b94b984c3b13300b589
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

61
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port/StatusOrGpuResourcesTest.cs
View File

@@ -1,61 +0,0 @@
// 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 StatusOrGpuResourcesTest
{
#region #status
[Test, GpuOnly]
public void Status_ShouldReturnOk_When_StatusIsOk()
{
using (var statusOrGpuResources = GpuResources.Create())
{
Assert.AreEqual(Status.StatusCode.Ok, statusOrGpuResources.status.Code());
}
}
#endregion
#region #isDisposed
[Test, GpuOnly]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var statusOrGpuResources = GpuResources.Create())
{
Assert.False(statusOrGpuResources.isDisposed);
}
}
[Test, GpuOnly]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var statusOrGpuResources = GpuResources.Create();
statusOrGpuResources.Dispose();
Assert.True(statusOrGpuResources.isDisposed);
}
#endregion
#region #Value
[Test, GpuOnly]
public void Value_ShouldReturnGpuResources_When_StatusIsOk()
{
using (var statusOrGpuResources = GpuResources.Create())
{
Assert.True(statusOrGpuResources.Ok());
using (var gpuResources = statusOrGpuResources.Value())
{
Assert.IsInstanceOf<GpuResources>(gpuResources);
Assert.True(statusOrGpuResources.isDisposed);
}
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port/StatusOrGpuResourcesTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 744f3edd2e0a5c864b1e59a13c017bbd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

71
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port/StatusOrImageFrameTest.cs
View File

@@ -1,71 +0,0 @@
// 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 StatusOrImageFrameTest
{
#region #status
[Test]
public void Status_ShouldReturnOk_When_StatusIsOk()
{
using (var statusOrImageFrame = InitializeSubject())
{
Assert.True(statusOrImageFrame.Ok());
Assert.AreEqual(Status.StatusCode.Ok, statusOrImageFrame.status.Code());
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var statusOrImageFrame = InitializeSubject())
{
Assert.False(statusOrImageFrame.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var statusOrImageFrame = InitializeSubject();
statusOrImageFrame.Dispose();
Assert.True(statusOrImageFrame.isDisposed);
}
#endregion
#region #Value
[Test]
public void Value_ShouldReturnImageFrame_When_StatusIsOk()
{
using (var statusOrImageFrame = InitializeSubject())
{
Assert.True(statusOrImageFrame.Ok());
using (var imageFrame = statusOrImageFrame.Value())
{
Assert.AreEqual(10, imageFrame.Width());
Assert.AreEqual(10, imageFrame.Height());
Assert.True(statusOrImageFrame.isDisposed);
}
}
}
#endregion
private StatusOrImageFrame InitializeSubject()
{
var imageFrame = new ImageFrame(ImageFormat.Types.Format.Sbgra, 10, 10);
var packet = new ImageFramePacket(imageFrame, new Timestamp(1));
return (StatusOrImageFrame)packet.Consume();
}
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port/StatusOrImageFrameTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 466caabcab9db68b9bf6cd8b2ea6829a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

87
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port/StatusOrStringTest.cs
View File

@@ -1,87 +0,0 @@
// 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 StatusOrStringTest
{
#region #status
[Test]
public void Status_ShouldReturnOk_When_StatusIsOk()
{
using (var statusOrString = InitializeSubject(""))
{
Assert.True(statusOrString.Ok());
Assert.AreEqual(Status.StatusCode.Ok, statusOrString.status.Code());
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var statusOrString = InitializeSubject(""))
{
Assert.False(statusOrString.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var statusOrString = InitializeSubject("");
statusOrString.Dispose();
Assert.True(statusOrString.isDisposed);
}
#endregion
#region #Value
[Test]
public void Value_ShouldReturnString_When_StatusIsOk()
{
var bytes = new byte[] { (byte)'a', (byte)'b', 0, (byte)'c' };
using (var statusOrString = InitializeSubject(bytes))
{
Assert.True(statusOrString.Ok());
Assert.AreEqual("ab", statusOrString.Value());
}
}
#endregion
#region #ValueAsByteArray
[Test]
public void ValueAsByteArray_ShouldReturnByteArray_When_StatusIsOk()
{
var bytes = new byte[] { (byte)'a', (byte)'b', 0, (byte)'c' };
using (var statusOrString = InitializeSubject(bytes))
{
Assert.True(statusOrString.Ok());
Assert.AreEqual(bytes, statusOrString.ValueAsByteArray());
}
}
#endregion
private StatusOrString InitializeSubject(string str)
{
using (var packet = new StringPacket(str))
{
return (StatusOrString)packet.Consume();
}
}
private StatusOrString InitializeSubject(byte[] bytes)
{
using (var packet = new StringPacket(bytes))
{
return (StatusOrString)packet.Consume();
}
}
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port/StatusOrStringTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 033bc341009a18e46920a405cd163bfb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

286
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port/StatusTest.cs
View File

@@ -1,286 +0,0 @@
// 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 StatusTest
{
#region #Code
[Test]
public void Code_ShouldReturnStatusCode_When_StatusIsOk()
{
using (var status = Status.Ok())
{
Assert.AreEqual(Status.StatusCode.Ok, status.Code());
}
}
[Test]
public void Code_ShouldReturnStatusCode_When_StatusIsFailedPrecondition()
{
using (var status = Status.FailedPrecondition())
{
Assert.AreEqual(Status.StatusCode.FailedPrecondition, status.Code());
}
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var status = Status.Ok())
{
Assert.False(status.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var status = Status.Ok();
status.Dispose();
Assert.True(status.isDisposed);
}
#endregion
#region #RawCode
[Test]
public void RawCode_ShouldReturnRawCode_When_StatusIsOk()
{
using (var status = Status.Ok())
{
Assert.AreEqual(0, status.RawCode());
}
}
[Test]
public void RawCode_ShouldReturnRawCode_When_StatusIsFailedPrecondition()
{
using (var status = Status.FailedPrecondition())
{
Assert.AreEqual(9, status.RawCode());
}
}
#endregion
#region #Ok
[Test]
public void Ok_ShouldReturnTrue_When_StatusIsOk()
{
using (var status = Status.Ok())
{
Assert.True(status.Ok());
}
}
[Test]
public void Ok_ShouldReturnFalse_When_StatusIsFailedPrecondition()
{
using (var status = Status.FailedPrecondition())
{
Assert.False(status.Ok());
}
}
#endregion
#region #AssertOk
[Test]
public void AssertOk_ShouldNotThrow_When_StatusIsOk()
{
using (var status = Status.Ok())
{
Assert.DoesNotThrow(() => { status.AssertOk(); });
}
}
[Test]
public void AssertOk_ShouldThrow_When_StatusIsNotOk()
{
using (var status = Status.FailedPrecondition())
{
#pragma warning disable IDE0058
Assert.Throws<MediaPipeException>(() => { status.AssertOk(); });
#pragma warning restore IDE0058
}
}
#endregion
#region #ToString
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsOk()
{
using (var status = Status.Ok())
{
Assert.AreEqual("OK", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsCancelled()
{
var message = "Some error";
using (var status = Status.Cancelled(message))
{
Assert.AreEqual($"CANCELLED: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsUnknown()
{
var message = "Some error";
using (var status = Status.Unknown(message))
{
Assert.AreEqual($"UNKNOWN: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsInvalidArgument()
{
var message = "Some error";
using (var status = Status.InvalidArgument(message))
{
Assert.AreEqual($"INVALID_ARGUMENT: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsDeadlineExceeded()
{
var message = "Some error";
using (var status = Status.DeadlineExceeded(message))
{
Assert.AreEqual($"DEADLINE_EXCEEDED: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsNotFound()
{
var message = "Some error";
using (var status = Status.NotFound(message))
{
Assert.AreEqual($"NOT_FOUND: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsAlreadyExists()
{
var message = "Some error";
using (var status = Status.AlreadyExists(message))
{
Assert.AreEqual($"ALREADY_EXISTS: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsPermissionDenied()
{
var message = "Some error";
using (var status = Status.PermissionDenied(message))
{
Assert.AreEqual($"PERMISSION_DENIED: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsResourceExhausted()
{
var message = "Some error";
using (var status = Status.ResourceExhausted(message))
{
Assert.AreEqual($"RESOURCE_EXHAUSTED: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsFailedPrecondition()
{
var message = "Some error";
using (var status = Status.FailedPrecondition(message))
{
Assert.AreEqual($"FAILED_PRECONDITION: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsAborted()
{
var message = "Some error";
using (var status = Status.Aborted(message))
{
Assert.AreEqual($"ABORTED: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsOutOfRange()
{
var message = "Some error";
using (var status = Status.OutOfRange(message))
{
Assert.AreEqual($"OUT_OF_RANGE: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsUnimplemented()
{
var message = "Some error";
using (var status = Status.Unimplemented(message))
{
Assert.AreEqual($"UNIMPLEMENTED: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsInternal()
{
var message = "Some error";
using (var status = Status.Internal(message))
{
Assert.AreEqual($"INTERNAL: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsUnavailable()
{
var message = "Some error";
using (var status = Status.Unavailable(message))
{
Assert.AreEqual($"UNAVAILABLE: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsDataLoss()
{
var message = "Some error";
using (var status = Status.DataLoss(message))
{
Assert.AreEqual($"DATA_LOSS: {message}", status.ToString());
}
}
[Test]
public void ToString_ShouldReturnMessage_When_StatusIsUnauthenticated()
{
var message = "Some error";
using (var status = Status.Unauthenticated(message))
{
Assert.AreEqual($"UNAUTHENTICATED: {message}", status.ToString());
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Port/StatusTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: cb9c4c0cb4b7c323db90d8592b4684cb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

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

@@ -1,254 +0,0 @@
// 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
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/TimestampTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 4a89b44de17930bf6bcbf5f75f57c100
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Tool.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: b737c0d514315064ebd2a4180cc065a3
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

156
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Tool/NameUtilTest.cs
View File

@@ -1,156 +0,0 @@
// 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;
using System;
namespace Mediapipe.Tests
{
public class NameUtilTest
{
[TestCase("{}", "base", "base")]
[TestCase(@"{""node"":[{""name"":""a""}]}", "base", "base")]
[TestCase(@"{""node"":[{},{}]}", "", "")]
[TestCase(@"{""node"":[{""name"":""base""},{""name"":""base_02""}]}", "base", "base_03")]
public void GetUnusedNodeName_ShouldReturnUniqueName(string configJson, string nameBase, string uniqueName)
{
var config = CalculatorGraphConfig.Parser.ParseJson(configJson);
Assert.AreEqual(uniqueName, Tool.GetUnusedNodeName(config, nameBase));
}
[TestCase("{}", "base", "base")]
[TestCase(@"{""node"":[{""input_side_packet"":[""a""]}]}", "base", "base")]
[TestCase(@"{""node"":[{},{""input_side_packet"":[]}]}", "", "")]
[TestCase(@"{""node"":[{""input_side_packet"":[""base""]},{""input_side_packet"":[""TAG:base_02""]}]}", "base", "base_03")]
public void GetUnusedSidePacketName_ShouldReturnUniqueName(string configJson, string nameBase, string uniqueName)
{
var config = CalculatorGraphConfig.Parser.ParseJson(configJson);
Assert.AreEqual(uniqueName, Tool.GetUnusedSidePacketName(config, nameBase));
}
[TestCase(@"{""node"":[{""name"":""x""}]}", 0, "x")]
[TestCase(@"{""node"":[{""name"":""x""},{""name"":""x""},{""name"":""y""},{""name"":""x""}]}", 0, "x_1")]
[TestCase(@"{""node"":[{""name"":""x""},{""name"":""x""},{""name"":""y""},{""name"":""x""}]}", 1, "x_2")]
[TestCase(@"{""node"":[{""name"":""x""},{""name"":""x""},{""name"":""y""},{""name"":""x""}]}", 2, "y")]
[TestCase(@"{""node"":[{""name"":""x""},{""name"":""x""},{""name"":""y""},{""name"":""x""}]}", 3, "x_3")]
[TestCase(@"{""node"":[{""calculator"":""x""},{""name"":""x""}]}", 0, "x_1")]
[TestCase(@"{""node"":[{""calculator"":""x""},{""name"":""x""}]}", 1, "x_2")]
[TestCase(@"{""node"":[{""name"":""x""},{""calculator"":""x""}]}", 0, "x_1")]
[TestCase(@"{""node"":[{""name"":""x""},{""calculator"":""x""}]}", 1, "x_2")]
public void CanonicalNodeName_ShouldReturnCanonicalNodeName_When_NodeIdIsValid(string configJson, int nodeId, string name)
{
var config = CalculatorGraphConfig.Parser.ParseJson(configJson);
Assert.AreEqual(name, Tool.CanonicalNodeName(config, nodeId));
}
[Test]
public void CanonicalNodeName_ShouldThrow_When_NodeIdIsNegative()
{
var config = CalculatorGraphConfig.Parser.ParseJson(@"{""node"":[{""name"":""name""}]}");
#pragma warning disable IDE0058
Assert.Throws<ArgumentOutOfRangeException>(() => { Tool.CanonicalNodeName(config, -1); });
#pragma warning restore IDE0058
}
[Test]
public void CanonicalNodeName_ShouldThrow_When_NodeIdIsInvalid()
{
var config = CalculatorGraphConfig.Parser.ParseJson(@"{""node"":[{""name"":""name""}]}");
#pragma warning disable IDE0058
Assert.Throws<ArgumentOutOfRangeException>(() => { Tool.CanonicalNodeName(config, 1); });
#pragma warning restore IDE0058
}
[Test]
public void CanonicalNodeName_ShouldThrow_When_NodeIsEmpty()
{
var config = CalculatorGraphConfig.Parser.ParseJson("{}");
#pragma warning disable IDE0058
Assert.Throws<ArgumentOutOfRangeException>(() => { Tool.CanonicalNodeName(config, 0); });
#pragma warning restore IDE0058
}
[TestCase("stream", "stream")]
[TestCase("TAG:x", "x")]
[TestCase("TAG:1:x", "x")]
public void ParseNameFromStream_ShouldReturnName_When_InputIsValid(string stream, string name)
{
Assert.AreEqual(name, Tool.ParseNameFromStream(stream));
}
[TestCase(":stream")]
[TestCase("TAG::stream")]
[TestCase("TAG:1:")]
public void ParseNameFromStream_ShouldThrow_When_InputIsInvalid(string stream)
{
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ParseNameFromStream(stream); });
#pragma warning restore IDE0058
}
[TestCase("", "", 0)]
[TestCase("TAG", "TAG", 0)]
[TestCase(":1", "", 1)]
[TestCase("TAG:1", "TAG", 1)]
public void ParseTagIndex_ShouldReturnTagIndexPair_When_InputIsValid(string tagIndex, string tag, int index)
{
var output = Tool.ParseTagIndex(tagIndex);
Assert.AreEqual(tag, output.Item1);
Assert.AreEqual(index, output.Item2);
}
[TestCase("tag")]
[TestCase(":")]
[TestCase("TAG:")]
[TestCase("1")]
public void ParseTagIndex_ShouldThrow_When_InputIsInvalid(string tagIndex)
{
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ParseTagIndex(tagIndex); });
#pragma warning restore IDE0058
}
[TestCase("stream", "", -1)]
[TestCase("TAG:x", "TAG", 0)]
[TestCase("TAG:1:x", "TAG", 1)]
public void ParseTagIndexFromStream_ShouldReturnTagIndexPair_When_InputIsValid(string stream, string tag, int index)
{
var output = Tool.ParseTagIndexFromStream(stream);
Assert.AreEqual(tag, output.Item1);
Assert.AreEqual(index, output.Item2);
}
[TestCase(":stream")]
[TestCase("TAG::stream")]
[TestCase("TAG:1:")]
public void ParseTagIndexFromStream_ShouldThrow_When_InputIsInvalid(string stream)
{
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ParseTagIndexFromStream(stream); });
#pragma warning restore IDE0058
}
[TestCase("", -1, "")]
[TestCase("", 1, "")]
[TestCase("TAG", -1, "TAG")]
[TestCase("TAG", 1, "TAG:1")]
public void CatTag_ShouldReturnTag(string tag, int index, string output)
{
Assert.AreEqual(output, Tool.CatTag(tag, index));
}
[TestCase("", -1, "x", "x")]
[TestCase("", 1, "x", "x")]
[TestCase("TAG", -1, "x", "TAG:x")]
[TestCase("TAG", 1, "x", "TAG:1:x")]
public void CatStream_ShouldReturnStream(string tag, int index, string name, string output)
{
Assert.AreEqual(output, Tool.CatStream((tag, index), name));
}
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Tool/NameUtilTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7707b1c1356d57b29b1ad8932beca1a4
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

290
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Tool/ValidateNameTest.cs
View File

@@ -1,290 +0,0 @@
// 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;
using System;
namespace Mediapipe.Tests
{
public class ValidateNameTest
{
#region .ValidateName
[TestCase("humphrey")]
[TestCase("humphrey_bogart")]
[TestCase("humphrey_bogart_1899")]
[TestCase("aa")]
[TestCase("b1")]
[TestCase("_1")]
public void ValidateName_ShouldNotThrow_WhenNameIsValid(string name)
{
Assert.DoesNotThrow(() => { Tool.ValidateName(name); });
}
[TestCase("")]
[TestCase("humphrey bogart")]
[TestCase("humphreyBogart")]
[TestCase("humphrey-bogart")]
[TestCase("humphrey/bogart")]
[TestCase("humphrey.bogart")]
[TestCase("humphrey:bogart")]
[TestCase("1ST")]
[TestCase("7_ELEVEN")]
[TestCase("401K")]
[TestCase("0")]
[TestCase("1")]
[TestCase("11")]
[TestCase("92091")]
[TestCase("1st")]
[TestCase("7_eleven")]
[TestCase("401k")]
[TestCase("\0contains_escapes\t")]
public void ValidateName_ShouldThrow_WhenNameIsInvalid(string name)
{
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ValidateName(name); });
#pragma warning restore IDE0058
}
#endregion
#region .ValidateNumber
[TestCase("0")]
[TestCase("10")]
[TestCase("1234567890")]
public void ValidateNumber_ShouldNotThrow_WhenNumberIsValid(string number)
{
Assert.DoesNotThrow(() => { Tool.ValidateNumber(number); });
}
[TestCase("01")]
[TestCase("1a")]
public void ValidateNumber_ShouldThrow_WhenNumberIsInvalid(string number)
{
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ValidateNumber(number); });
#pragma warning restore IDE0058
}
#endregion
#region .ValidateTag
[TestCase("MALE")]
[TestCase("MALE_ACTOR")]
[TestCase("ACTOR_1899")]
[TestCase("AA")]
[TestCase("B1")]
[TestCase("_1")]
public void ValidateTag_ShouldNotThrow_WhenTagIsValid(string tag)
{
Assert.DoesNotThrow(() => { Tool.ValidateTag(tag); });
}
[TestCase("")]
[TestCase("MALE ACTOR")]
[TestCase("MALEaCTOR")]
[TestCase("MALE-ACTOR")]
[TestCase("MALE/ACTOR")]
[TestCase("MALE.ACTOR")]
[TestCase("MALE:ACTOR")]
[TestCase("0")]
[TestCase("1")]
[TestCase("11")]
[TestCase("92091")]
[TestCase("1ST")]
[TestCase("7_ELEVEN")]
[TestCase("401K")]
[TestCase("\0CONTAINS_ESCAPES\t")]
public void ValidateTag_ShouldThrow_WhenTagIsInvalid(string tag)
{
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ValidateTag(tag); });
#pragma warning restore IDE0058
}
#endregion
#region .ParseTagAndName
[TestCase("MALE:humphrey", "MALE", "humphrey")]
[TestCase("ACTOR:humphrey_bogart", "ACTOR", "humphrey_bogart")]
[TestCase("ACTOR_1899:humphrey_1899", "ACTOR_1899", "humphrey_1899")]
[TestCase("humphrey_bogart", "", "humphrey_bogart")]
[TestCase("ACTOR:humphrey", "ACTOR", "humphrey")]
public void ParseTagAndName_ShouldParseInput_When_InputIsValid(string input, string expectedTag, string expectedName)
{
Tool.ParseTagAndName(input, out var tag, out var name);
Assert.AreEqual(expectedTag, tag);
Assert.AreEqual(expectedName, name);
}
[TestCase(":humphrey")]
[TestCase("humphrey bogart")]
[TestCase("actor:humphrey")]
[TestCase("actor:humphrey")]
[TestCase("ACTOR:HUMPHREY")]
public void ParseTagAndName_ShouldThrow_When_InputIsInvalid(string input)
{
var tag = "UNTOUCHED";
var name = "untouched";
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ParseTagAndName(input, out tag, out name); });
Assert.AreEqual("UNTOUCHED", tag);
Assert.AreEqual("untouched", name);
#pragma warning restore IDE0058
}
[Test]
public void ParseTagAndName_ShouldThrow_When_InputIncludesBadCharacters(
[Values(' ', '-', '/', '.', ':')] char ch,
[Values("MALE$0ACTOR:humphrey", "ACTOR:humphrey$0:bogart")] string str
)
{
ParseTagAndName_ShouldThrow_When_InputIsInvalid(str.Replace("$0", $"{ch}"));
}
#endregion
#region .ParseTagIndexName
[TestCase("MALE:humphrey", "MALE", 0, "humphrey")]
[TestCase("ACTOR:humphrey_bogart", "ACTOR", 0, "humphrey_bogart")]
[TestCase("ACTOR_1899:humphrey_1899", "ACTOR_1899", 0, "humphrey_1899")]
[TestCase("humphrey_bogart", "", -1, "humphrey_bogart")]
[TestCase("ACTRESS:3:mieko_harada", "ACTRESS", 3, "mieko_harada")]
[TestCase("ACTRESS:0:mieko_harada", "ACTRESS", 0, "mieko_harada")]
[TestCase("A1:100:mieko1", "A1", 100, "mieko1")]
[TestCase("A1:10000:mieko1", "A1", 10000, "mieko1")]
public void ParseTagIndexName_ShouldParseInput_When_InputIsValid(string input, string expectedTag, int expectedIndex, string expectedName)
{
Tool.ParseTagIndexName(input, out var tag, out var index, out var name);
Assert.AreEqual(expectedTag, tag);
Assert.AreEqual(expectedIndex, index);
Assert.AreEqual(expectedName, name);
}
[TestCase("")]
[TestCase("A")]
[TestCase("Aa")]
[TestCase("aA")]
[TestCase("1a")]
[TestCase("1")]
[TestCase(":name")]
[TestCase("A:")]
[TestCase("a:name")]
[TestCase("Aa:name")]
[TestCase("aA:name")]
[TestCase("1A:name")]
[TestCase("1:name")]
[TestCase(":1:name")]
[TestCase("A:1:")]
[TestCase("A::name")]
[TestCase("a:1:name")]
[TestCase("Aa:1:name")]
[TestCase("aA:1:name")]
[TestCase("1A:1:name")]
[TestCase("1:1:name")]
[TestCase("A:1:N")]
[TestCase("A:1:nN")]
[TestCase("A:1:Nn")]
[TestCase("A:1:1name")]
[TestCase("A:1:1")]
[TestCase("A:-0:name")]
[TestCase("A:-1:name")]
[TestCase("A:01:name")]
[TestCase("A:00:name")]
[TestCase("A:10001:a")]
[TestCase("A:1:a:")]
[TestCase(":A:1:a")]
[TestCase("A:1:a:a")]
[TestCase("A:1:a:A")]
[TestCase("A:1:a:1")]
public void ParseTagIndexName_ShouldThrow_When_InputIsInvalid(string input)
{
var tag = "UNTOUCHED";
var index = -1;
var name = "untouched";
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ParseTagIndexName(input, out tag, out index, out name); });
Assert.AreEqual("UNTOUCHED", tag);
Assert.AreEqual(-1, index);
Assert.AreEqual("untouched", name);
#pragma warning restore IDE0058
}
[Test]
public void ParseTagIndexName_ShouldThrow_When_InputIncludesBadCharacters(
[Values('!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '{', '}', '[', ']',
'/', '=', '?', '+', '\\', '|', '-', ';', ':', '\'', '"', '<', '.', '>')] char ch,
[Values("$0", "$0a", "a$0", "$0:a", "A$0:a", "$0A:a", "A:$0:a", "A:$01:a", "A:1$0:a", "A:1:a$0", "$0A:1:a")] string str
)
{
ParseTagIndexName_ShouldThrow_When_InputIsInvalid(str.Replace("$0", $"{ch}"));
}
#endregion
#region .ParseTagIndex
[TestCase("", "", 0)]
[TestCase("VIDEO:0", "VIDEO", 0)]
[TestCase("VIDEO:1", "VIDEO", 1)]
[TestCase("AUDIO:2", "AUDIO", 2)]
[TestCase(":0", "", 0)]
[TestCase(":1", "", 1)]
[TestCase(":100", "", 100)]
[TestCase("VIDEO:10000", "VIDEO", 10000)]
public void ParseTagIndex_ShouldParseInput_When_InputIsValid(string input, string expectedTag, int expectedIndex)
{
Tool.ParseTagIndex(input, out var tag, out var index);
Assert.AreEqual(expectedTag, tag);
Assert.AreEqual(expectedIndex, index);
}
[TestCase("a")]
[TestCase("Aa")]
[TestCase("aA")]
[TestCase("1A")]
[TestCase("1")]
[TestCase(":")]
[TestCase(":a")]
[TestCase(":A")]
[TestCase(":-0")]
[TestCase(":-1")]
[TestCase(":01")]
[TestCase(":00")]
[TestCase("A:")]
[TestCase("A:a")]
[TestCase("A:A")]
[TestCase("A:-0")]
[TestCase("A:-1")]
[TestCase("A:01")]
[TestCase("A:00")]
[TestCase("A:10001")]
[TestCase("A:1:")]
[TestCase(":A:1")]
[TestCase("A:1:2")]
[TestCase("A:A:1")]
public void ParseTagIndex_ShouldThrow_When_InputIsInvalid(string input)
{
var tag = "UNTOUCHED";
var index = -1;
#pragma warning disable IDE0058
Assert.Throws<ArgumentException>(() => { Tool.ParseTagIndex(input, out tag, out index); });
Assert.AreEqual("UNTOUCHED", tag);
Assert.AreEqual(-1, index);
#pragma warning restore IDE0058
}
[Test]
public void ParseTagIndex_ShouldThrow_When_InputIncludesBadCharacters(
[Values('!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '{', '}', '[', ']',
'/', '=', '?', '+', '\\', '|', '-', ';', ':', '\'', '"', '<', '.', '>')] char ch,
[Values("$0", "$0A", "A$0", "$0:1", "A$0:1", "$0A:1", "A:1$0", "A:$01")] string str
)
{
ParseTagIndex_ShouldThrow_When_InputIsInvalid(str.Replace("$0", $"{ch}"));
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/Tool/ValidateNameTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 17bfd5c3db2e476b6b04101190819090
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

743
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/ValidatedGraphConfigTest.cs
View File

@@ -1,743 +0,0 @@
// 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;
using System.Linq;
namespace Mediapipe.Tests
{
public class ValidatedGraphConfigTest
{
private const string _PassThroughConfigText = @"
node {
calculator: ""PassThroughCalculator""
input_stream: ""in""
output_stream: ""out1""
}
node {
calculator: ""PassThroughCalculator""
input_stream: ""out1""
output_stream: ""out""
}
input_stream: ""in""
output_stream: ""out""
";
private const string _FlowLimiterConfigText = @"
input_stream: ""input_video""
input_stream: ""output""
node {
calculator: ""FlowLimiterCalculator""
input_stream: ""input_video""
input_stream: ""FINISHED:output""
input_stream_info: {
tag_index: ""FINISHED""
back_edge: true
}
input_side_packet: ""MAX_IN_FLIGHT:max_in_flight""
input_side_packet: ""OPTIONS:flow_limiter_calculator_options""
output_stream: ""throttled_input_video""
}
";
private const string _ImageTransformationConfigText = @"
input_stream: ""input_video""
node: {
calculator: ""ImageTransformationCalculator""
input_stream: ""IMAGE:input_video""
input_side_packet: ""ROTATION_DEGREES:input_rotation""
input_side_packet: ""FLIP_HORIZONTALLY:input_horizontally_flipped""
input_side_packet: ""FLIP_VERTICALLY:input_vertically_flipped""
output_stream: ""IMAGE:transformed_input_video""
}
";
private const string _ConstantSidePacketConfigText = @"
node {
calculator: ""ConstantSidePacketCalculator""
output_side_packet: ""PACKET:0:int_packet""
output_side_packet: ""PACKET:1:float_packet""
output_side_packet: ""PACKET:2:bool_packet""
output_side_packet: ""PACKET:3:string_packet""
options: {
[mediapipe.ConstantSidePacketCalculatorOptions.ext]: {
packet { int_value: 256 }
packet { float_value: 0.5f }
packet { bool_value: false }
packet { string_value: ""string"" }
}
}
}
";
private const string _FaceDetectionShortRangeConfigText = @"
input_stream: ""image""
input_stream: ""roi""
node {
calculator: ""FaceDetectionShortRange""
input_stream: ""IMAGE:image""
input_stream: ""ROI:roi""
output_stream: ""DETECTIONS:detections""
}
";
#region Constructor
[Test]
public void Ctor_ShouldInstantiateValidatedGraphConfig()
{
Assert.DoesNotThrow(() =>
{
var config = new ValidatedGraphConfig();
config.Dispose();
});
}
#endregion
#region #isDisposed
[Test]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var config = new ValidatedGraphConfig())
{
Assert.False(config.isDisposed);
}
}
[Test]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var config = new ValidatedGraphConfig();
config.Dispose();
Assert.True(config.isDisposed);
}
#endregion
#region #Initialize
[Test]
public void Initialize_ShouldReturnOk_When_CalledWithConfig()
{
using (var config = new ValidatedGraphConfig())
{
using (var status = config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)))
{
Assert.True(status.Ok());
}
Assert.True(config.Initialized());
}
}
[Test]
public void Initialize_ShouldReturnOk_When_CalledWithValidGraphType()
{
using (var config = new ValidatedGraphConfig())
{
using (var status = config.Initialize("SwitchContainer"))
{
Assert.True(status.Ok());
}
Assert.True(config.Initialized());
}
}
[Test]
public void Initialize_ShouldReturnInternalError_When_CalledWithInvalidGraphType()
{
using (var config = new ValidatedGraphConfig())
{
using (var status = config.Initialize("InvalidSubgraph"))
{
Assert.AreEqual(Status.StatusCode.NotFound, status.Code());
}
Assert.False(config.Initialized());
}
}
#endregion
#region #ValidateRequiredSidePackets
[Test]
public void ValidateRequiredSidePackets_ShouldReturnOk_When_TheConfigDoesNotRequireSidePackets_And_SidePacketIsEmpty()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.True(status.Ok());
}
}
}
}
[Test]
public void ValidateRequiredSidePackets_ShouldReturnOk_When_TheConfigDoesNotRequireSidePackets_And_SidePacketIsNotEmpty()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("in", new IntPacket(0));
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.True(status.Ok());
}
}
}
}
[Test]
public void ValidateRequiredSidePackets_ShouldReturnOk_When_AllTheSidePacketsAreOptional_And_SidePacketIsEmpty()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_FlowLimiterConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.True(status.Ok());
}
}
}
}
[Test]
public void ValidateRequiredSidePackets_ShouldReturnInvalidArgumentError_When_TheConfigRequiresSidePackets_And_SidePacketIsEmpty()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ImageTransformationConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, status.Code());
}
}
}
}
[Test]
public void ValidateRequiredSidePackets_ShouldReturnInvalidArgumentError_When_AllTheRequiredSidePacketsAreNotGiven()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ImageTransformationConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("input_horizontally_flipped", new BoolPacket(false));
sidePacket.Emplace("input_vertically_flipped", new BoolPacket(true));
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, status.Code());
}
}
}
}
[Test]
public void ValidateRequiredSidePackets_ShouldReturnInvalidArgumentError_When_TheSidePacketValuesAreWrong()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ImageTransformationConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("input_horizontally_flipped", new BoolPacket(false));
sidePacket.Emplace("input_vertically_flipped", new BoolPacket(true));
sidePacket.Emplace("input_rotation", new StringPacket("0"));
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, status.Code());
}
}
}
}
[Test]
public void ValidateRequiredSidePackets_ShouldReturnOk_When_AllTheRequiredSidePacketsAreGiven()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ImageTransformationConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("input_horizontally_flipped", new BoolPacket(false));
sidePacket.Emplace("input_vertically_flipped", new BoolPacket(true));
sidePacket.Emplace("input_rotation", new IntPacket(0));
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.True(status.Ok());
}
}
}
}
#endregion
#region Config
[Test]
public void Config_ShouldReturnAnEmptyConfig_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
var canonicalizedConfig = config.Config();
Assert.AreEqual(canonicalizedConfig.CalculateSize(), 0);
}
}
[Test]
public void Config_ShouldReturnTheCanonicalizedConfig_When_TheConfigIsPassThroughConfig()
{
using (var config = new ValidatedGraphConfig())
{
var originalConfig = CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText);
config.Initialize(originalConfig).AssertOk();
var canonicalizedConfig = config.Config();
Assert.AreEqual(originalConfig.Node, canonicalizedConfig.Node);
Assert.AreEqual(originalConfig.InputStream, canonicalizedConfig.InputStream);
Assert.AreEqual(originalConfig.OutputStream, canonicalizedConfig.OutputStream);
Assert.IsEmpty(originalConfig.Executor);
Assert.AreEqual(1, canonicalizedConfig.Executor.Count);
Assert.AreEqual(0, canonicalizedConfig.Executor[0].CalculateSize());
Assert.AreEqual(80, originalConfig.CalculateSize());
Assert.AreEqual(82, canonicalizedConfig.CalculateSize());
}
}
[Test]
public void Config_ShouldReturnTheCanonicalizedConfig_When_TheConfigIsFaceDetectionShortRangeCommonConfig()
{
using (var config = new ValidatedGraphConfig())
{
var originalConfig = CalculatorGraphConfig.Parser.ParseFromTextFormat(_FaceDetectionShortRangeConfigText);
config.Initialize(originalConfig).AssertOk();
var canonicalizedConfig = config.Config();
Assert.AreEqual(84, originalConfig.CalculateSize());
// 2167 on CPU, 2166 on GPU
Assert.AreEqual(2166, canonicalizedConfig.CalculateSize(), 1);
}
}
#endregion
#region InputStreamInfos
[Test]
public void InputStreamInfos_ShouldReturnEmptyList_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.IsEmpty(config.InputStreamInfos());
}
}
[Test]
public void InputStreamInfos_ShouldReturnEmptyList_When_NoInputStreamExists()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
Assert.IsEmpty(config.InputStreamInfos());
}
}
[Test]
public void InputStreamInfos_ShouldReturnEdgeInfoList_When_InputStreamsExist()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
var inputStreamInfos = config.InputStreamInfos();
Assert.AreEqual(inputStreamInfos.Count, 2);
var inStream = inputStreamInfos.First((edgeInfo) => edgeInfo.name == "in");
Assert.AreEqual(0, inStream.upstream);
Assert.AreEqual(NodeType.Calculator, inStream.parentNode.type);
Assert.AreEqual(0, inStream.parentNode.index);
Assert.False(inStream.backEdge);
var out1Stream = inputStreamInfos.First((edgeInfo) => edgeInfo.name == "out1");
Assert.AreEqual(1, out1Stream.upstream);
Assert.AreEqual(NodeType.Calculator, out1Stream.parentNode.type);
Assert.AreEqual(1, out1Stream.parentNode.index);
Assert.False(out1Stream.backEdge);
}
}
#endregion
#region OutputStreamInfos
[Test]
public void OutputStreamInfos_ShouldReturnEmptyList_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.IsEmpty(config.OutputStreamInfos());
}
}
[Test]
public void OutputStreamInfos_ShouldReturnEdgeInfoList_When_OutputStreamsExist()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
var outputStreamInfos = config.OutputStreamInfos();
Assert.AreEqual(3, outputStreamInfos.Count);
var inStream = outputStreamInfos.First((edgeInfo) => edgeInfo.name == "in");
Assert.AreEqual(-1, inStream.upstream);
Assert.AreEqual(NodeType.GraphInputStream, inStream.parentNode.type);
Assert.AreEqual(2, inStream.parentNode.index, 2);
Assert.False(inStream.backEdge);
var out1Stream = outputStreamInfos.First((edgeInfo) => edgeInfo.name == "out1");
Assert.AreEqual(-1, out1Stream.upstream);
Assert.AreEqual(NodeType.Calculator, out1Stream.parentNode.type);
Assert.AreEqual(0, out1Stream.parentNode.index);
Assert.False(out1Stream.backEdge);
var outStream = outputStreamInfos.First((edgeInfo) => edgeInfo.name == "out");
Assert.AreEqual(-1, outStream.upstream);
Assert.AreEqual(NodeType.Calculator, outStream.parentNode.type);
Assert.AreEqual(1, outStream.parentNode.index);
Assert.False(outStream.backEdge);
}
}
#endregion
#region InputSidePacketInfos
[Test]
public void InputSidePacketInfos_ShouldReturnEmptyList_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.IsEmpty(config.InputSidePacketInfos());
}
}
[Test]
public void InputSidePacketInfos_ShouldReturnEmptyList_When_NoInputSidePacketExists()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.IsEmpty(config.InputSidePacketInfos());
}
}
[Test]
public void InputSidePacketInfos_ShouldReturnEdgeInfoList_When_InputSidePacketsExist()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_FlowLimiterConfigText)).AssertOk();
var inputSidePacketInfos = config.InputSidePacketInfos();
Assert.True(inputSidePacketInfos.Count >= 2);
var maxInFlightPacket = inputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "max_in_flight");
Assert.AreEqual(-1, maxInFlightPacket.upstream);
Assert.AreEqual(NodeType.Calculator, maxInFlightPacket.parentNode.type);
Assert.False(maxInFlightPacket.backEdge);
var flowLimiterCalculatorOptionsPacket = inputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "flow_limiter_calculator_options");
Assert.AreEqual(-1, flowLimiterCalculatorOptionsPacket.upstream);
Assert.AreEqual(NodeType.Calculator, flowLimiterCalculatorOptionsPacket.parentNode.type);
Assert.False(flowLimiterCalculatorOptionsPacket.backEdge);
}
}
#endregion
#region OutputSidePacketInfos
[Test]
public void OutputSidePacketInfos_ShouldReturnEmptyList_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.IsEmpty(config.OutputSidePacketInfos());
}
}
[Test]
public void OutputSidePacketInfos_ShouldReturnEmptyList_When_NoOutputSidePacketExists()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.IsEmpty(config.OutputSidePacketInfos());
}
}
[Test]
public void OutputSidePacketInfos_ShouldReturnEdgeInfoList_When_OutputSidePacketsExist()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
var outputSidePacketInfos = config.OutputSidePacketInfos();
Assert.AreEqual(4, outputSidePacketInfos.Count);
var intPacket = outputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "int_packet");
Assert.AreEqual(-1, intPacket.upstream);
Assert.AreEqual(NodeType.Calculator, intPacket.parentNode.type);
Assert.False(intPacket.backEdge);
var floatPacket = outputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "float_packet");
Assert.AreEqual(-1, floatPacket.upstream);
Assert.AreEqual(NodeType.Calculator, floatPacket.parentNode.type);
Assert.False(floatPacket.backEdge);
var boolPacket = outputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "bool_packet");
Assert.AreEqual(-1, boolPacket.upstream);
Assert.AreEqual(NodeType.Calculator, boolPacket.parentNode.type);
Assert.False(boolPacket.backEdge);
var stringPacket = outputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "string_packet");
Assert.AreEqual(-1, stringPacket.upstream);
Assert.AreEqual(NodeType.Calculator, stringPacket.parentNode.type);
Assert.False(stringPacket.backEdge);
}
}
#endregion
#region OutputStreamIndex
[Test]
public void OutputStreamIndex_ShouldReturnNegativeValue_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.AreEqual(-1, config.OutputStreamIndex(""));
}
}
[Test]
public void OutputStreamIndex_ShouldReturnNegativeValue_When_TheNameIsInvalid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.AreEqual(-1, config.OutputStreamIndex("unknown"));
}
}
[Test]
public void OutputStreamIndex_ShouldReturnIndex_When_TheNameIsValid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.AreEqual(2, config.OutputStreamIndex("out"));
}
}
[Test]
public void OutputStreamIndex_ShouldReturnIndex_When_TheStreamIsNotPublic()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.AreEqual(1, config.OutputStreamIndex("out1"));
}
}
#endregion
#region OutputSidePacketIndex
[Test]
public void OutputSidePacketIndex_ShouldReturnNegativeValue_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.AreEqual(-1, config.OutputSidePacketIndex(""));
}
}
[Test]
public void OutputSidePacketIndex_ShouldReturnNegativeValue_When_TheNameIsInvalid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
Assert.AreEqual(-1, config.OutputSidePacketIndex("unknown"));
}
}
[Test]
public void OutputSidePacketIndex_ShouldReturnIndex_When_TheNameIsValid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
Assert.AreEqual(0, config.OutputSidePacketIndex("int_packet"));
}
}
#endregion
#region OutputStreamToNode
[Test]
public void OutputStreamToNode_ShouldReturnNegativeValue_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.AreEqual(-1, config.OutputStreamToNode(""));
}
}
[Test]
public void OutputStreamToNode_ShouldReturnNegativeValue_When_TheNameIsInvalid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.AreEqual(-1, config.OutputStreamToNode("unknown"));
}
}
[Test]
public void OutputStreamToNode_ShouldReturnIndex_When_TheNameIsValid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.AreEqual(0, config.OutputStreamToNode("out1"));
}
}
#endregion
#region RegisteredSidePacketTypeName
[Test]
public void RegisteredSidePacketTypeName_ShouldReturnInvalidArgumentError_When_TheSidePacketDoesNotExist()
{
using (var config = new ValidatedGraphConfig())
{
using (var statusOrString = config.RegisteredSidePacketTypeName("max_in_flight"))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, statusOrString.status.Code());
}
}
}
[Test]
public void RegisteredSidePacketTypeName_ShouldReturnUnknownError_When_TheSidePacketTypeCannotBeDetermined()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_FlowLimiterConfigText)).AssertOk();
using (var statusOrString = config.RegisteredSidePacketTypeName("max_in_flight"))
{
Assert.AreEqual(Status.StatusCode.Unknown, statusOrString.status.Code());
}
}
}
#endregion
#region RegisteredStreamTypeName
[Test]
public void RegisteredStreamTypeName_ShouldReturnInvalidArgumentError_When_TheStreamDoesNotExist()
{
using (var config = new ValidatedGraphConfig())
{
using (var statusOrString = config.RegisteredStreamTypeName("in"))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, statusOrString.status.Code());
}
}
}
[Test]
public void RegisteredStreamTypeName_ShouldReturnUnknownError_When_TheStreamTypeCannotBeDetermined()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
using (var statusOrString = config.RegisteredStreamTypeName("in"))
{
Assert.AreEqual(Status.StatusCode.Unknown, statusOrString.status.Code());
}
}
}
#endregion
#region Package
[Test]
public void Package_ShouldReturnNull_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.IsNull(config.Package());
}
}
[Test]
public void Package_ShouldReturnNull_When_TheNamespaceIsNotSet()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.IsNull(config.Package());
}
}
#endregion
#region IsReservedExecutorName
[Test]
public void IsReservedExecutorName_ShouldReturnFalse_When_TheNameIsNotReserved()
{
Assert.False(ValidatedGraphConfig.IsReservedExecutorName("unknown"));
}
[Test]
public void IsReservedExecutorName_ShouldReturnFalse_When_TheNameIsReserved()
{
Assert.True(ValidatedGraphConfig.IsReservedExecutorName("default"));
Assert.True(ValidatedGraphConfig.IsReservedExecutorName("gpu"));
Assert.True(ValidatedGraphConfig.IsReservedExecutorName("__gpu"));
}
#endregion
#region IsExternalSidePacket
[Test]
public void IsExternalSidePacket_ShouldReturnFalse_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.False(config.IsExternalSidePacket("max_in_flight"));
}
}
[Test]
public void IsExternalSidePacket_ShouldReturnFalse_When_TheSidePacketIsInternal()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
Assert.False(config.IsExternalSidePacket("int_packet"));
}
}
[Test]
public void IsExternalSidePacket_ShouldReturnTrue_When_TheSidePacketIsExternal()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_FlowLimiterConfigText)).AssertOk();
Assert.True(config.IsExternalSidePacket("max_in_flight"));
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Framework/ValidatedGraphConfigTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 593d3340196fca643b5346fb3cd60f7e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 34ad49218cadf094e8bc99057c757771
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

192
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu/GlCalculatorHelperTest.cs
View File

@@ -1,192 +0,0 @@
// 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;
using System;
namespace Mediapipe.Tests
{
public class GlCalculatorHelperTest
{
#region Constructor
[Test, GpuOnly]
public void Ctor_ShouldInstantiateGlCalculatorHelper()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
Assert.AreNotEqual(IntPtr.Zero, glCalculatorHelper.mpPtr);
}
}
#endregion
#region #isDisposed
[Test, GpuOnly]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
Assert.False(glCalculatorHelper.isDisposed);
}
}
[Test, GpuOnly]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.Dispose();
Assert.True(glCalculatorHelper.isDisposed);
}
#endregion
#region #InitializeForTest
[Test, GpuOnly]
public void InitializeForTest_ShouldInitialize()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
Assert.False(glCalculatorHelper.Initialized());
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
Assert.True(glCalculatorHelper.Initialized());
}
}
#endregion
#region #RunInGlContext
[Test, GpuOnly]
public void RunInGlContext_ShouldReturnOk_When_FunctionReturnsOk()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
var status = glCalculatorHelper.RunInGlContext(() => { });
Assert.True(status.Ok());
}
}
[Test, GpuOnly]
public void RunInGlContext_ShouldReturnInternal_When_FunctionThrows()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
var status = glCalculatorHelper.RunInGlContext((GlCalculatorHelper.GlFunction)(() => { throw new Exception("Function Throws"); }));
Assert.AreEqual(Status.StatusCode.Internal, status.Code());
}
}
#endregion
#region #CreateSourceTexture
[Test, GpuOnly]
public void CreateSourceTexture_ShouldReturnGlTexture_When_CalledWithImageFrame()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Srgba, 32, 24))
{
var status = glCalculatorHelper.RunInGlContext(() =>
{
var texture = glCalculatorHelper.CreateSourceTexture(imageFrame);
Assert.AreEqual(32, texture.width);
Assert.AreEqual(24, texture.height);
texture.Dispose();
});
Assert.True(status.Ok());
status.Dispose();
}
}
}
[Test, GpuOnly]
[Ignore("Skip because a thread will hang")]
public void CreateSourceTexture_ShouldFail_When_ImageFrameFormatIsInvalid()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Sbgra, 32, 24))
{
var status = glCalculatorHelper.RunInGlContext(() =>
{
using (var texture = glCalculatorHelper.CreateSourceTexture(imageFrame))
{
texture.Release();
}
});
Assert.AreEqual(Status.StatusCode.FailedPrecondition, status.Code());
status.Dispose();
}
}
}
#endregion
#region #CreateDestinationTexture
[Test, GpuOnly]
public void CreateDestinationTexture_ShouldReturnGlTexture_When_GpuBufferFormatIsValid()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
var status = glCalculatorHelper.RunInGlContext(() =>
{
var glTexture = glCalculatorHelper.CreateDestinationTexture(32, 24, GpuBufferFormat.kBGRA32);
Assert.AreEqual(32, glTexture.width);
Assert.AreEqual(24, glTexture.height);
});
Assert.True(status.Ok());
}
}
#endregion
#region #framebuffer
[Test, GpuOnly]
public void Framebuffer_ShouldReturnGLName()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
// default frame buffer
Assert.AreEqual(0, glCalculatorHelper.framebuffer);
}
}
#endregion
#region #GetGlContext
[Test, GpuOnly]
public void GetGlContext_ShouldReturnCurrentContext()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
using (var glContext = glCalculatorHelper.GetGlContext())
{
#if UNITY_EDITOR_LINUX || UNITY_STANDALONE_LINUX || UNITY_ANDROID
Assert.AreNotEqual(IntPtr.Zero, glContext.eglContext);
#elif UNITY_STANDALONE_OSX
Assert.AreNotEqual(IntPtr.Zero, glContext.nsglContext);
#elif UNITY_IOS
Assert.AreNotEqual(IntPtr.Zero, glContext.eaglContext);
#endif
}
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu/GlCalculatorHelperTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7f47dcca1b6cbd6538c87a9914863444
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

83
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu/GlContextTest.cs
View File

@@ -1,83 +0,0 @@
// 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;
using System;
namespace Mediapipe.Tests
{
public class GlContextTest
{
#region .GetCurrent
[Test, GpuOnly]
public void GetCurrent_ShouldReturnNull_When_CalledOutOfGlContext()
{
var glContext = GlContext.GetCurrent();
Assert.Null(glContext);
}
[Test, GpuOnly]
public void GetCurrent_ShouldReturnCurrentContext_When_CalledInGlContext()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
glCalculatorHelper.RunInGlContext(() =>
{
using (var glContext = GlContext.GetCurrent())
{
Assert.NotNull(glContext);
Assert.True(glContext.IsCurrent());
}
}).AssertOk();
}
}
#endregion
#region #IsCurrent
public void IsCurrent_ShouldReturnFalse_When_CalledOutOfGlContext()
{
var glContext = GetGlContext();
Assert.False(glContext.IsCurrent());
}
#endregion
#region properties
[Test, GpuOnly]
public void ShouldReturnProperties()
{
using (var glContext = GetGlContext())
{
#if UNITY_EDITOR_LINUX || UNITY_STANDALONE_LINUX || UNITY_ANDROID
Assert.AreNotEqual(IntPtr.Zero, glContext.eglDisplay);
Assert.AreNotEqual(IntPtr.Zero, glContext.eglConfig);
Assert.AreNotEqual(IntPtr.Zero, glContext.eglContext);
Assert.AreEqual(3, glContext.glMajorVersion);
Assert.AreEqual(2, glContext.glMinorVersion);
Assert.AreEqual(0, glContext.glFinishCount);
#elif UNITY_STANDALONE_OSX
Assert.AreNotEqual(IntPtr.Zero, glContext.nsglContext);
#elif UNITY_IOS
Assert.AreNotEqual(IntPtr.Zero, glContext.eaglContext);
#endif
}
}
#endregion
private GlContext GetGlContext()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
return glCalculatorHelper.GetGlContext();
}
}
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu/GlContextTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: d5e3ffbb666f2d185b043064194cbf12
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

56
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu/GlTextureTest.cs
View File

@@ -1,56 +0,0 @@
// 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 GlTextureTest
{
#region Constructor
[Test, GpuOnly]
public void Ctor_ShouldInstantiateGlTexture_When_CalledWithNoArguments()
{
using (var glTexture = new GlTexture())
{
Assert.AreEqual(0, glTexture.width);
Assert.AreEqual(0, glTexture.height);
}
}
#endregion
#region #isDisposed
[Test, GpuOnly]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var glTexture = new GlTexture())
{
Assert.False(glTexture.isDisposed);
}
}
[Test, GpuOnly]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var glTexture = new GlTexture();
glTexture.Dispose();
Assert.True(glTexture.isDisposed);
}
#endregion
#region target
[Test, GpuOnly]
public void Target_ShouldReturnTarget()
{
using (var glTexture = new GlTexture())
{
Assert.AreEqual(Gl.GL_TEXTURE_2D, glTexture.target);
}
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu/GlTextureTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: fbe1d82329bb2b09a88651d8ac9ad4fd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

44
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu/GpuResourcesTest.cs
View File

@@ -1,44 +0,0 @@
// 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 GpuResourcesTest
{
#region Create
[Test, GpuOnly]
public void Create_ShouldReturnStatusOrGpuResources()
{
using (var statusOrGpuResources = GpuResources.Create())
{
Assert.True(statusOrGpuResources.Ok());
}
}
#endregion
#region #isDisposed
[Test, GpuOnly]
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var gpuResources = GpuResources.Create().Value())
{
Assert.False(gpuResources.isDisposed);
}
}
[Test, GpuOnly]
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var gpuResources = GpuResources.Create().Value();
gpuResources.Dispose();
Assert.True(gpuResources.isDisposed);
}
#endregion
}
}

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Gpu/GpuResourcesTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7e987f90210347a37b48e4a9f9f93c53
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

1308
Packages/com.github.homuler.mediapipe/Tests/EditMode/Unity/Extension/ImageFrameExtensionTest.cs
View File

File diff suppressed because it is too large Load Diff

11
Packages/com.github.homuler.mediapipe/Tests/EditMode/Unity/Extension/ImageFrameExtensionTest.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 46cfb5995c4d2b93899f4920ae0b016a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: