public static string Unpack(this TempDirectory tempDirectory, ProcessRuntime runtime)
{
var name = runtime switch
{
ProcessRuntime.Net461 => "net4.6.1.zip",
ProcessRuntime.Net48 => "net4.8.zip",
ProcessRuntime.NetCore31 => "netcoreapp3.1.zip",
ProcessRuntime.Net50 => "net5.0.zip",
_ => throw new ArgumentException($"Runtime is not supported: {runtime}"),
};
var zipBytes = ResourcesUtilities.ReadFileAsBytes(name);
var zipPath = Path.Combine(tempDirectory.Folder, name);
File.WriteAllBytes(zipPath, zipBytes);
try
{
ZipFile.ExtractToDirectory(zipPath, tempDirectory.Folder);
}
finally
{
File.Delete(zipPath);
}
return(Path.Combine(tempDirectory.Folder, ExeName));
}
public static async Task ConvertTest(IRecognizer recognizer, string name, string expected)
{
var bytes = ResourcesUtilities.ReadFileAsBytes(name);
var actual = await recognizer.ConvertAsync(bytes);
Assert.AreEqual(expected, actual);
}
/// <summary>
///
/// </summary>
public void Sound(string name)
{
using var stream = ResourcesUtilities.ReadFileAsStream($"{name}.wav");
using var player = new SoundPlayer(stream);
player.Play();
}
public static async Task StartStreamingRecognitionTest(IRecognizer recognizer, string name, string expected, int bytesPerWrite = 8000)
{
using var recognition = await recognizer.StartStreamingRecognitionAsync();
recognition.PreviewReceived += (_, value) =>
{
Console.WriteLine($"{DateTime.Now:h:mm:ss.fff} {nameof(recognition.PreviewReceived)}: {value}");
};
recognition.Stopped += (_, value) =>
{
Console.WriteLine($"{DateTime.Now:h:mm:ss.fff} {nameof(recognition.Stopped)}: {value}");
Assert.AreEqual(expected, value);
};
var bytes = ResourcesUtilities.ReadFileAsBytes(name);
// 44 - is default wav header length
for (var i = 44; i < bytes.Length; i += bytesPerWrite)
{
var chunk = new ArraySegment <byte>(bytes, i, i < bytes.Length - bytesPerWrite ? bytesPerWrite : bytes.Length - i).ToArray();
await recognition.WriteAsync(chunk);
await Task.Delay(TimeSpan.FromMilliseconds(500));
}
await recognition.StopAsync();
}
public static async Task ConvertTest(IConverter converter, string name, string expected, CancellationToken cancellationToken = default)
{
var bytes = ResourcesUtilities.ReadFileAsBytes(name);
var actual = await converter.ConvertAsync(bytes, cancellationToken);
Assert.AreEqual(expected, actual);
}
public static async Task StartStreamingRecognitionTest(IConverter converter, string name, string expected, int bytesPerWrite = 8000)
{
using var recognition = await converter.StartStreamingRecognitionAsync();
recognition.AfterPartialResults += (_, args) => Console.WriteLine($"{DateTime.Now:h:mm:ss.fff} AfterPartialResults: {args.Text}");
recognition.AfterFinalResults += (_, args) =>
{
Console.WriteLine($"{DateTime.Now:h:mm:ss.fff} AfterFinalResults: {args.Text}");
Assert.AreEqual(expected, args.Text);
};
var bytes = ResourcesUtilities.ReadFileAsBytes(name);
// 44 - is default wav header length
for (var i = 44; i < bytes.Length; i += bytesPerWrite)
{
var chunk = new ArraySegment <byte>(bytes, i, i < bytes.Length - bytesPerWrite ? bytesPerWrite : bytes.Length - i).ToArray();
await recognition.WriteAsync(chunk);
await Task.Delay(TimeSpan.FromMilliseconds(500));
}
await recognition.StopAsync();
}
public static async Task BaseModuleTest <T1, T2>(
string name1,
string name2,
Func <ExceptionsBag, T1, T2, CancellationToken, Task> testFunc)
where T1 : class, IModule
where T2 : class, IModule
{
using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(15));
var cancellationToken = cancellationTokenSource.Token;
var exceptions = new ExceptionsBag();
await using var manager = new ModuleManager <IModule>(
Path.Combine(Path.GetTempPath(), $"H.Containers.Tests_{name1}_{name2}"));
manager.ExceptionOccurred += (_, exception) =>
{
Console.WriteLine($"ExceptionOccurred: {exception}");
exceptions.OnOccurred(exception);
// ReSharper disable once AccessToDisposedClosure
cancellationTokenSource.Cancel();
};
using var instance1 = await manager.AddModuleAsync <T1>(
CreateContainer (name1),
name1,
name1,
ResourcesUtilities.ReadFileAsBytes($"{name1}.zip"),
cancellationToken);
using var instance2 = await manager.AddModuleAsync <T2>(
CreateContainer (name2),
name2,
name2,
ResourcesUtilities.ReadFileAsBytes($"{name2}.zip"),
cancellationToken);
Assert.IsNotNull(instance1);
Assert.IsNotNull(instance2);
foreach (var instance in new IModule[] { instance1, instance2 })
{
instance.EnableLog();
}
await testFunc(exceptions, instance1, instance2, cancellationToken);
try
{
await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
}
catch (OperationCanceledException)
{
}
exceptions.EnsureNoExceptions();
}
public static string Extract(this TempDirectory directory, string name)
{
var path = Path.Combine(directory.Folder, $"{name}.zip");
var bytes = ResourcesUtilities.ReadFileAsBytes($"{name}.zip");
File.WriteAllBytes(path, bytes);
ZipFile.ExtractToDirectory(path, directory.Folder, true);
return Path.Combine(directory.Folder, $"{name}.dll");
}
public async Task SendAudioToTest()
{
using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
var cancellationToken = cancellationTokenSource.Token;
using var runner = CreateTelegramRunner();
using var stream = ResourcesUtilities.ReadFileAsStream("test.mp3");
await runner.SendAudioAsync(stream, "482553595", nameof(SendAudioToTest), cancellationToken);
}
public static async Task BaseModuleTest <T>(
string name,
Func <T, CancellationToken, Task> testFunc)
where T : class, IModule
{
using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(15));
var cancellationToken = cancellationTokenSource.Token;
var receivedException = (Exception?)null;
await using var manager = new ModuleManager <IModule>(
Path.Combine(Path.GetTempPath(), $"H.Containers.Tests_{name}"));
manager.ExceptionOccurred += (_, exception) =>
{
Console.WriteLine($"ExceptionOccurred: {exception}");
receivedException = exception;
// ReSharper disable once AccessToDisposedClosure
cancellationTokenSource.Cancel();
};
var bytes = ResourcesUtilities.ReadFileAsBytes($"{name}.zip");
using var instance = await manager.AddModuleAsync <T>(
new ProcessContainer (name),
name,
name,
bytes,
cancellationToken);
Assert.IsNotNull(instance);
instance.EnableLog();
(await manager.GetTypesAsync(cancellationToken)).Log("Available types");
instance.ShortName.Log(nameof(instance.ShortName));
instance.GetAvailableSettings().Log("Available settings");
await testFunc(instance, cancellationToken);
try
{
await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
}
catch (OperationCanceledException)
{
}
if (receivedException != null)
{
Assert.Fail(receivedException.ToString());
}
}
public async Task WitAiConverterTest()
{
await BaseModuleTest <IRecognizer>(
"H.Converters.WitAiConverter",
async (instance, cancellationToken) =>
{
instance.SetSetting("Token", "XZS4M3BUYV5LBMEWJKAGJ6HCPWZ5IDGY");
var bytes = ResourcesUtilities.ReadFileAsBytes("проверка_проверка_8000.wav");
var actual = await instance.ConvertAsync(bytes, cancellationToken);
Assert.AreEqual("проверка", actual);
});
}
public void BaseTest(string name)
{
var json = ResourcesUtilities.ReadFileAsString(name);
var paths = DepsJsonDependenciesSearcher.Search(json);
Console.WriteLine("Dependencies:");
foreach (var path in paths)
{
Console.WriteLine($" - {path}");
}
Assert.IsNotNull(paths);
Assert.IsTrue(paths.Any(), "paths.Any()");
}
public async Task TelegramAudioTest()
{
using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
var cancellationToken = cancellationTokenSource.Token;
await using var moduleService = new StaticModuleService(
TestModules.CreateTelegramRunner()
);
await using var runnerService = new RunnerService(moduleService);
using var exceptions = new IServiceBase[]
{
moduleService, runnerService
}.EnableLogging(cancellationTokenSource);
await runnerService.RunAsync(
new Command("telegram audio", new Value(string.Empty, nameof(TelegramAudioTest))
{
Data = ResourcesUtilities.ReadFileAsBytes("test.mp3"),
}), cancellationToken);
}
public void SilenceDetectorTest()
{
var bytes = ResourcesUtilities
.ReadFileAsBytes("test_test_rus_8000.wav")
.Skip(44)
.ToArray();
var isDetected = false;
var detector = new SilenceDetector(requiredCount: 200);
detector.Detected += (_, _) => isDetected = true;
var partLength = bytes.Length / 500; // One part is 10 milliseconds.
for (var i = 0; i < bytes.Length / partLength; i++)
{
var part = bytes.Skip(i * partLength).Take(partLength).ToArray();
detector.Write(part);
}
Assert.IsTrue(isDetected);
}
public async Task RealTest()
{
var receivedException = (Exception?)null;
using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(15));
await using var container = new ProcessContainer(nameof(ProcessContainerTests))
{
MethodsCancellationToken = cancellationTokenSource.Token,
};
container.ExceptionOccurred += (_, exception) =>
{
Console.WriteLine($"ExceptionOccurred: {exception}");
receivedException = exception;
// ReSharper disable once AccessToDisposedClosure
cancellationTokenSource.Cancel();
};
await container.InitializeAsync(cancellationTokenSource.Token);
await container.StartAsync(cancellationTokenSource.Token);
var directory = Path.Combine(Path.GetTempPath(), "H.Containers.Tests_WitAiConverter");
Directory.CreateDirectory(directory);
var path = Path.Combine(directory, "WitAiConverter.zip");
var bytes = ResourcesUtilities.ReadFileAsBytes("WitAiConverter.zip");
File.WriteAllBytes(path, bytes);
ZipFile.ExtractToDirectory(path, directory, true);
await container.LoadAssemblyAsync(Path.Combine(directory, "WitAiConverter.dll"), cancellationTokenSource.Token);
var instance = await container.CreateObjectAsync <IConverter>("H.NET.Converters.WitAiConverter", cancellationTokenSource.Token);
Assert.IsNotNull(instance);
Assert.AreEqual("WitAiConverter", instance.ShortName);
var availableSettings = instance.GetAvailableSettings().ToArray();
Console.WriteLine("AvailableSettings:");
foreach (var setting in availableSettings)
{
Console.WriteLine($" - {setting}");
}
CollectionAssert.AreEqual(
new[] { "Token" },
availableSettings);
instance.SetSetting("Token", "XZS4M3BUYV5LBMEWJKAGJ6HCPWZ5IDGY");
await BaseConvertersTests.ConvertTest(instance, "проверка_проверка_8000.wav", "проверка", cancellationTokenSource.Token);
try
{
await Task.Delay(TimeSpan.FromSeconds(1), cancellationTokenSource.Token);
}
catch (OperationCanceledException)
{
}
if (receivedException != null)
{
Assert.Fail(receivedException.ToString());
}
}
