291 lines
8.9 KiB
C#
291 lines
8.9 KiB
C#
// 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
|
|
}
|
|
}
|