408 lines
16 KiB
C#
408 lines
16 KiB
C#
using Humanizer;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
using Phares.Shared;
|
|
using Serilog;
|
|
using System.Diagnostics;
|
|
using System.Reflection;
|
|
using View_by_Distance.Shared.Models;
|
|
using View_by_Distance.Shared.Models.Stateless.Methods;
|
|
using View_by_Distance.Tests.Models;
|
|
|
|
namespace View_by_Distance.Tests;
|
|
|
|
[TestClass]
|
|
public partial class UnitTestCalculations
|
|
{
|
|
|
|
private readonly ILogger _Logger;
|
|
private readonly AppSettings _AppSettings;
|
|
private readonly string _WorkingDirectory;
|
|
private readonly Configuration _Configuration;
|
|
private readonly IsEnvironment _IsEnvironment;
|
|
private readonly IConfigurationRoot _ConfigurationRoot;
|
|
private readonly Property.Models.Configuration _PropertyConfiguration;
|
|
|
|
public UnitTestCalculations()
|
|
{
|
|
ILogger logger;
|
|
AppSettings appSettings;
|
|
string workingDirectory;
|
|
Configuration configuration;
|
|
IsEnvironment isEnvironment;
|
|
IConfigurationRoot configurationRoot;
|
|
LoggerConfiguration loggerConfiguration = new();
|
|
Property.Models.Configuration propertyConfiguration;
|
|
Assembly assembly = Assembly.GetExecutingAssembly();
|
|
bool debuggerWasAttachedAtLineZero = Debugger.IsAttached || assembly.Location.Contains(@"\bin\Debug");
|
|
isEnvironment = new(processesCount: null, nullASPNetCoreEnvironmentIsDevelopment: debuggerWasAttachedAtLineZero, nullASPNetCoreEnvironmentIsProduction: !debuggerWasAttachedAtLineZero);
|
|
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
|
|
.AddEnvironmentVariables()
|
|
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
|
|
.AddJsonFile(isEnvironment.AppSettingsFileName, optional: false, reloadOnChange: true);
|
|
configurationRoot = configurationBuilder.Build();
|
|
appSettings = Models.Binder.AppSettings.Get(configurationRoot);
|
|
if (string.IsNullOrEmpty(appSettings.WorkingDirectoryName))
|
|
throw new Exception("Working directory name must have a value!");
|
|
workingDirectory = IWorkingDirectory.GetWorkingDirectory(assembly.GetName().Name, appSettings.WorkingDirectoryName);
|
|
Environment.SetEnvironmentVariable(nameof(workingDirectory), workingDirectory);
|
|
_ = ConfigurationLoggerConfigurationExtensions.Configuration(loggerConfiguration.ReadFrom, configurationRoot);
|
|
Log.Logger = loggerConfiguration.CreateLogger();
|
|
logger = Log.ForContext<UnitTestCalculations>();
|
|
propertyConfiguration = Property.Models.Binder.Configuration.Get(isEnvironment, configurationRoot);
|
|
configuration = Models.Binder.Configuration.Get(isEnvironment, configurationRoot, propertyConfiguration);
|
|
logger.Information("Complete");
|
|
_Logger = logger;
|
|
_AppSettings = appSettings;
|
|
_Configuration = configuration;
|
|
_IsEnvironment = isEnvironment;
|
|
_WorkingDirectory = workingDirectory;
|
|
_ConfigurationRoot = configurationRoot;
|
|
_PropertyConfiguration = propertyConfiguration;
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMethodNull()
|
|
{
|
|
Assert.IsFalse(_Logger is null);
|
|
Assert.IsFalse(_AppSettings is null);
|
|
Assert.IsFalse(_Configuration is null);
|
|
Assert.IsFalse(_IsEnvironment is null);
|
|
Assert.IsFalse(_WorkingDirectory is null);
|
|
Assert.IsFalse(_ConfigurationRoot is null);
|
|
Assert.IsFalse(_PropertyConfiguration is null);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMethodGetSort() => Assert.IsTrue(new bool[] { true, false }.OrderByDescending(l => l).First());
|
|
|
|
[TestMethod]
|
|
public void TestMethodGetAge()
|
|
{
|
|
PersonBirthday personBirthday = new(new(1980, 1, 17));
|
|
double? age = IPersonBirthday.GetAge(personBirthday);
|
|
if (age is null)
|
|
throw new NullReferenceException(nameof(age));
|
|
Assert.IsNotNull(age);
|
|
Assert.IsTrue(age.Value > 42.6092);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMethodParse()
|
|
{
|
|
Assert.IsTrue(long.TryParse("(637967784888423594)"[1..^1], out long ticks));
|
|
Assert.IsTrue(ticks == 637967784888423594);
|
|
Assert.IsFalse(long.TryParse("(637967784888423594.61)"[1..^1], out ticks));
|
|
Assert.IsTrue(ticks == 0);
|
|
Assert.IsFalse(long.TryParse("(637967784888423594.00)"[1..^1], out ticks));
|
|
Assert.IsTrue(ticks == 0);
|
|
long l = 637967784888423594;
|
|
double d;
|
|
d = 0.61;
|
|
Assert.IsTrue($"({l}{d.ToString("0.00")[1..]})" == "(637967784888423594.61)");
|
|
d = 0.6;
|
|
Assert.IsTrue($"({l}{d.ToString("0.00")[1..]})" == "(637967784888423594.60)");
|
|
d = 0.615;
|
|
Assert.IsTrue($"({l}{d.ToString("0.00")[1..]})" == "(637967784888423594.62)");
|
|
d = 0.45;
|
|
Assert.IsTrue($"({l}{d.ToString("0.00")[1..]})" == "(637967784888423594.45)");
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMethodHumanize()
|
|
{
|
|
string successfull = $"_ {"ManualCopy".Humanize(LetterCasing.Title)} Successfull";
|
|
Assert.IsTrue(successfull == "_ Manual Copy Successfull");
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMethodDamn()
|
|
{
|
|
// string name;
|
|
// string[] directories;
|
|
// string? directoryName;
|
|
// string checkDirectory;
|
|
// string sourceDirectory = @"F:\Tmp\Phares\Compare\Images 2022-09-15 - 7390c13 - III - Results\E) Distance\2022-09-15\7680 x 4320\7680x4320 - Hog - Large\()";
|
|
// directories = Directory.GetDirectories(sourceDirectory, "*", SearchOption.TopDirectoryOnly);
|
|
// foreach (string directory in directories)
|
|
// {
|
|
// directoryName = Path.GetDirectoryName(directory);
|
|
// if (directoryName is null)
|
|
// continue;
|
|
// name = Path.GetFileName(directory);
|
|
// if (name.Length is 1 or 20)
|
|
// continue;
|
|
// checkDirectory = Path.Combine(directoryName, "b", name);
|
|
// Directory.Move(directory, checkDirectory);
|
|
// }
|
|
// directories = Directory.GetDirectories(Path.Combine(sourceDirectory, "b"), "*", SearchOption.TopDirectoryOnly);
|
|
// foreach (string directory in directories)
|
|
// {
|
|
// directoryName = Path.GetDirectoryName(directory);
|
|
// if (directoryName is null)
|
|
// continue;
|
|
// name = Path.GetFileName(directory);
|
|
// if (name.Length is 1 or 20)
|
|
// continue;
|
|
// checkDirectory = Path.Combine(directoryName, $"{name[..^4]})");
|
|
// if (Directory.Exists(checkDirectory))
|
|
// continue;
|
|
// Directory.Move(directory, checkDirectory);
|
|
// }
|
|
// Assert.IsTrue(true);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMethodDel()
|
|
{
|
|
string source = @"F:\Tmp\Phares\Compare\Images 2022-09-15 - 7390c13 - III - Results\E) Distance\2022-09-15\7680 x 4320\7680x4320 - Hog - Large\()\(637992984751968513)";
|
|
for (int i = 1; i < 11; i++)
|
|
_ = IPath.DeleteEmptyDirectories(source);
|
|
Assert.IsTrue(true);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMethodDirectory()
|
|
{
|
|
string[] names;
|
|
names = IPath.GetDirectoryNames(@"C:\Tmp\phares");
|
|
Assert.IsTrue(names.Length == 3);
|
|
names = IPath.GetDirectoryNames(@"C:\Tmp\phares\");
|
|
Assert.IsTrue(names.Length == 3);
|
|
// names = IPath.GetDirectoryNames(@"C:\Tmp\phares\Pictures - Results\E) Distance\2022-09-15\7680 x 4320\7680x4320 - Hog - Large\()\(637991752537712052)\1976-03-08_00\#2019\K\-735727008.520765.jpg");
|
|
// Assert.IsTrue(names.Length == 13);
|
|
// Length = 13
|
|
// [0] [string]:
|
|
// "C:\\"
|
|
// [1] [string]:
|
|
// "Tmp"
|
|
// [2] [string]:
|
|
// "phares"
|
|
// [3] [string]:
|
|
// "Pictures - Results"
|
|
// [4] [string]:
|
|
// "E) Distance"
|
|
// [5] [string]:
|
|
// "2022-09-15"
|
|
// [6] [string]:
|
|
// "7680 x 4320"
|
|
// [7] [string]:
|
|
// "7680x4320 - Hog - Large"
|
|
// [8] [string]:
|
|
// "()"
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestGetLocation()
|
|
{
|
|
double confidence = 0.1D;
|
|
int left, top, right, bottom, width, height;
|
|
left = 20;
|
|
right = 60;
|
|
top = 40;
|
|
bottom = 80;
|
|
width = 100;
|
|
height = 100;
|
|
Location location = new(bottom, confidence, left, right, top);
|
|
_ = new Location(confidence, height, location, Shared.Models.Stateless.ILocation.Digits, Shared.Models.Stateless.ILocation.Factor, width, 1);
|
|
_ = new Location(bottom, confidence, height, left, Shared.Models.Stateless.ILocation.Digits, Shared.Models.Stateless.ILocation.Factor, right, top, width, 1);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestAreaPermille()
|
|
{
|
|
int faceAreaPermille = 1000;
|
|
Location location;
|
|
double confidence = 0.1D;
|
|
int areaPermille, left, top, right, bottom, width, height;
|
|
left = 0;
|
|
right = 100;
|
|
top = 0;
|
|
bottom = 100;
|
|
width = 100;
|
|
height = 100;
|
|
areaPermille = IMapping.GetAreaPermille(faceAreaPermille, bottom, height, left, right, top, width);
|
|
Assert.IsTrue(areaPermille == 1000);
|
|
left = 0;
|
|
right = 50;
|
|
top = 0;
|
|
bottom = 50;
|
|
width = 100;
|
|
height = 100;
|
|
location = new(bottom, confidence, height, left, Shared.Models.Stateless.ILocation.Digits, Shared.Models.Stateless.ILocation.Factor, right, top, width, 1);
|
|
areaPermille = IMapping.GetAreaPermille(faceAreaPermille, height, location, width);
|
|
Assert.IsTrue(areaPermille == 250);
|
|
left = 0;
|
|
right = 25;
|
|
top = 0;
|
|
bottom = 25;
|
|
width = 100;
|
|
height = 100;
|
|
location = new(bottom, confidence, height, left, Shared.Models.Stateless.ILocation.Digits, Shared.Models.Stateless.ILocation.Factor, right, top, width, 1);
|
|
OutputResolution outputResolution = new(height, 0, width);
|
|
areaPermille = IMapping.GetAreaPermille(faceAreaPermille, location, outputResolution);
|
|
Assert.IsTrue(areaPermille == 62);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestNormalizedRectangle()
|
|
{
|
|
int? x, y;
|
|
int normalizedRectangle;
|
|
int bottom, height, left, right, top, width;
|
|
string normalizedRectanglePadded;
|
|
width = 2048;
|
|
height = 1365;
|
|
normalizedRectanglePadded = "617214031";
|
|
(x, y) = ILocation.GetXY(Shared.Models.Stateless.ILocation.Digits, Shared.Models.Stateless.ILocation.Factor, width, height, normalizedRectanglePadded);
|
|
if (x is null || y is null)
|
|
throw new Exception();
|
|
Assert.IsTrue(x.Value == 1264);
|
|
Assert.IsTrue(y.Value == 192);
|
|
left = x.Value;
|
|
right = x.Value + 125;
|
|
top = y.Value;
|
|
bottom = y.Value + 100;
|
|
normalizedRectangle = ILocation.GetNormalizedRectangle(bottom, height, left, Shared.Models.Stateless.ILocation.Digits, right, top, width);
|
|
Assert.IsTrue(normalizedRectangle == 461140607);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestGetDistance()
|
|
{
|
|
double x1, x2, y1, y2;
|
|
x1 = 12f;
|
|
x2 = 13f;
|
|
y1 = 11f;
|
|
y2 = 10f;
|
|
double distance = Math.Sqrt(Math.Pow(x1 - x2, 2) + Math.Pow(y1 - y2, 2));
|
|
Assert.IsTrue(distance == 1.4142135623730951);
|
|
}
|
|
|
|
private static (string?, string, string) Get(string[] segments)
|
|
{
|
|
(string?, string, string) result;
|
|
if ((!segments[0].Contains('#') && (segments[3].Contains('~') || segments[3].Contains('#'))) || (segments[0].Contains('#') && !segments[3].Contains('#')))
|
|
result = new(null, segments[3], segments[4]);
|
|
else
|
|
result = new(segments[0], segments[3], segments[4]);
|
|
return result;
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMoveToVerify()
|
|
{
|
|
string http;
|
|
string[] lines;
|
|
string? minusOne;
|
|
string? minusTwo;
|
|
string[] segments;
|
|
string[] beforeSegments;
|
|
string[] matchDirectories;
|
|
string? personKeyFormattedNew;
|
|
string? personDisplayDirectory;
|
|
string personDisplayDirectoryNew;
|
|
string personDisplayDirectoryNameNew;
|
|
string personKeyFormattedDirectoryNew;
|
|
string sourceDirectory = @"";
|
|
string sourceFile = @"\People - C.tsv";
|
|
if (!File.Exists(sourceFile))
|
|
lines = Array.Empty<string>();
|
|
else
|
|
lines = File.ReadAllLines(sourceFile);
|
|
for (int i = 0; i < lines.Length; i++)
|
|
{
|
|
if (!lines[i].Contains("https://"))
|
|
continue;
|
|
segments = lines[i].Split('\t');
|
|
beforeSegments = lines[i - 1].Split('\t');
|
|
if (beforeSegments.Length < 4 || segments.Length < 5)
|
|
continue;
|
|
matchDirectories = Directory.GetDirectories(sourceDirectory, beforeSegments[0], SearchOption.AllDirectories);
|
|
if (matchDirectories.Length != 1)
|
|
continue;
|
|
personDisplayDirectory = Path.GetDirectoryName(matchDirectories[0]);
|
|
if (personDisplayDirectory is null)
|
|
continue;
|
|
minusOne = Path.GetDirectoryName(personDisplayDirectory);
|
|
if (minusOne is null)
|
|
continue;
|
|
minusTwo = Path.GetDirectoryName(minusOne);
|
|
if (minusTwo is null)
|
|
continue;
|
|
(personKeyFormattedNew, personDisplayDirectoryNameNew, http) = Get(segments);
|
|
if (personKeyFormattedNew is null)
|
|
continue;
|
|
personDisplayDirectoryNew = Path.Combine(minusTwo, "Verify", personDisplayDirectoryNameNew);
|
|
if (Directory.Exists(personDisplayDirectoryNew))
|
|
continue;
|
|
personKeyFormattedDirectoryNew = Path.Combine(personDisplayDirectoryNew, personKeyFormattedNew);
|
|
Directory.Move(personDisplayDirectory, personDisplayDirectoryNew);
|
|
_ = Directory.CreateDirectory(personKeyFormattedDirectoryNew);
|
|
File.WriteAllText(Path.Combine(personKeyFormattedDirectoryNew, "Facebook.txt"), http);
|
|
}
|
|
Assert.IsNotNull(lines);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestGetConfidencePercent()
|
|
{
|
|
int faceConfidencePercent = 100;
|
|
double minimum, target, maximum, value, check;
|
|
minimum = 0.8f;
|
|
target = 0.8f;
|
|
maximum = int.MaxValue;
|
|
value = 0f;
|
|
check = ILocation.GetConfidencePercent(faceConfidencePercent, new double[] { minimum, target, maximum }, value);
|
|
Assert.IsTrue(check == 0);
|
|
target = 0.8f;
|
|
value = 0.4f;
|
|
check = ILocation.GetConfidencePercent(faceConfidencePercent, new double[] { minimum, target, maximum }, value);
|
|
Assert.IsTrue(check == 50);
|
|
target = 0.8f;
|
|
value = 0.8f;
|
|
check = ILocation.GetConfidencePercent(faceConfidencePercent, new double[] { minimum, target, maximum }, value);
|
|
Assert.IsTrue(check == 100);
|
|
target = 0.8f;
|
|
value = 1.6f;
|
|
check = ILocation.GetConfidencePercent(faceConfidencePercent, new double[] { minimum, target, maximum }, value);
|
|
Assert.IsTrue(check == 200);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestMovingFiles()
|
|
{
|
|
char directory;
|
|
string fileName;
|
|
string checkFile;
|
|
int directoryIndex;
|
|
string checkDirectory;
|
|
List<string> collection = new();
|
|
string source = "C:/1234567890123456789";
|
|
if (Directory.Exists(source))
|
|
{
|
|
for (int i = 0; i < 11; i++)
|
|
{
|
|
if (i == 10)
|
|
checkDirectory = Path.Combine(source, "-");
|
|
else
|
|
checkDirectory = Path.Combine(source, i.ToString());
|
|
if (!Directory.Exists(checkDirectory))
|
|
_ = Directory.CreateDirectory(checkDirectory);
|
|
collection.Add(checkDirectory);
|
|
}
|
|
Dictionary<string, string[]> jsonGroups = new() { { "{}", collection.ToArray() } };
|
|
foreach (string file in Directory.GetFiles(source))
|
|
{
|
|
fileName = Path.GetFileName(file);
|
|
directory = IDirectory.GetDirectory(fileName);
|
|
directoryIndex = IDirectory.GetDirectory(directory);
|
|
checkFile = Path.Combine(jsonGroups["{}"][directoryIndex], fileName);
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
File.Move(file, checkFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
} |