public async Task Smoke(MemstateSettings settings)
{
const int NumRecords = 100;
settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log));
settings.StreamName = _randomStreamName;
var builder = new EngineBuilder(settings);
var engine = builder.Build <List <string> >();
foreach (var number in Enumerable.Range(1, NumRecords))
{
var command = new AddStringCommand(number.ToString());
var count = await engine.ExecuteAsync(command).ConfigureAwait(false);
Assert.Equal(number, count);
}
await engine.DisposeAsync().ConfigureAwait(false);
engine = builder.Build <List <string> >();
var strings = await engine.ExecuteAsync(new GetStringsQuery()).ConfigureAwait(false);
Assert.Equal(NumRecords, strings.Count);
await engine.DisposeAsync().ConfigureAwait(false);
}
private static Engine NoneMain()
{
var builder = new EngineBuilder();
Build(builder);
return(builder.Build());
}
public static void Main(string[] args)
{
var engineBuilder = new EngineBuilder()
// I don't know if using a property is nicer than a getter method, but here it is.
.WindowOptions
.Name("Game Window")
.Width(1024)
.Height(768)
.Flags(WindowFlags.Titlebar | WindowFlags.Resize | WindowFlags.Close)
// Calling the End{Section} method lets you keep using the builder fluently
.EndWindowOptions();
// Can use the builder without the End{Section} methods if you want
engineBuilder.Systems
// Just a hacky hack to display registering an instance of something to be injected
.Register(new Rectangle2D())
// Registering systems by type
.Register <MyInitSystem>()
.Register <MyUpdateSystem>()
.Register <MyDrawSystem>()
.Register <DebugTextHandler>();
// Build the engine, finalizing the DI container and all that jazz. Everything else remains the same
using var engine = engineBuilder.Build();
engine.EntityManager.Add(new Hero());
var text = engine.EntityManager.CreateEntity("Debug Info");
text.AddComponent(new TextComponent(new Text("Elapsed Time: 0.00")));
engine.Run();
}
public static void Run(JsEngines engineType, string testName, [CallerMemberName] string fixture = null)
{
var builder = new EngineBuilder().SetResourceProvider(new TestingResourceProvider());
switch (engineType)
{
case JsEngines.Jurassic: builder.UseJurassic(); break;
case JsEngines.Jint: builder.UseJint(); break;
}
var engine = builder.Build();
engine.OpenUrl($"http://test/{fixture}").Wait();
object res;
lock (engine.Document)
{
res = engine.ScriptExecutor.Evaluate("text/javascript",
@"Run('" + fixture + "', '" + testName + "');");
}
if (res != null)
{
Assert.Fail(res.ToString());
}
}
public async Task MapsToCommand()
{
//Arrange
var cfg = Config.Reset();
cfg.UseInMemoryFileSystem();
var settings = Config.Current.GetSettings <EngineSettings>();
var storageProvider = cfg.GetStorageProvider();
var builder = new EngineBuilder();
var engine = builder.Build <ITestModel>().Result;
var client = new LocalClient <ITestModel>(engine);
var proxy = client.GetDispatchProxy();
//Act
proxy.SetCustomer(new Customer());
//release the lock on the journal
await engine.DisposeAsync();
var journalEntry = storageProvider.CreateJournalReader().GetRecords().FirstOrDefault();
// If MapTo is correct, a SetCustomerCommand will be written to the journal
// if not, then a ProxyCommand will be written
Assert.NotNull(journalEntry);
Assert.IsInstanceOf <SetCustomerCommand>(journalEntry.Command);
}
public async Task Engine_With_Multiple_Compiler_And_Streaming_Mode_Should_Match_Patterns()
{
var loggerProvider = new XunitLoggerProvider(_testOutputHelper);
var engineBuilder = new EngineBuilder();
engineBuilder.WithLogger(loggerProvider.CreateLogger("Hyperscan"));
engineBuilder.WithDatabase(() => new Database());
engineBuilder.WithCompiler(() => new MultipleCompiler(new List <Expression>
{
new Expression("foo(?i)bar(?-i)baz", ExpressionFlag.HsFlagSomLeftmost),
new Expression("foo", ExpressionFlag.HsFlagSomLeftmost),
new Expression("foo(?i)bar", ExpressionFlag.HsFlagSomLeftmost)
}, CompilerMode.HsModeStream | CompilerMode.HsModeSomHorizonLarge));
await using var engine = engineBuilder.Build();
var observer = new TestScheduler().CreateObserver <Match>();
using var onMatch = engine.OnMatch.Subscribe(observer);
await engine.ScanAsync("fo", CancellationToken.None);
await engine.ScanAsync("o", CancellationToken.None);
await engine.ScanAsync("fo", CancellationToken.None);
await engine.ScanAsync("o", CancellationToken.None);
await engine.ScanAsync("barbazbaz", CancellationToken.None);
await Task.Delay(100);
observer.Messages.Count.Should().Be(4);
observer.Messages.Should().Contain(message => message.Value.Value.FullMatch == "foo");
observer.Messages.Should().Contain(message => message.Value.Value.FullMatch == "foobar");
observer.Messages.Should().Contain(message => message.Value.Value.FullMatch == "foobarbaz");
}
public void Database_Not_Configured_With_Engine_Builder_Should_Throw_Exception()
{
var engineBuilder = new EngineBuilder();
engineBuilder.WithCompiler(() => new SimpleCompiler(new Expression("", ExpressionFlag.HsFlagAllowempty), CompilerMode.HsModeBlock));
FluentActions.Invoking(() => engineBuilder.Build()).Should().Throw <HyperscanException>();
}
public void Compiler_Not_Configured_With_Engine_Builder_Should_Throw_Exception()
{
var engineBuilder = new EngineBuilder();
engineBuilder.WithDatabase(() => new Database());
FluentActions.Invoking(() => engineBuilder.Build()).Should().Throw <HyperscanException>();
}
public static CleeEngine Create(Action <IEngineConfiguration> configure)
{
var builder = new EngineBuilder();
configure(builder);
return(builder.Build());
}
public async Task Database_Size_Should_Be_Valid()
{
var engineBuilder = new EngineBuilder();
engineBuilder.WithDatabase(() => new Database());
engineBuilder.WithCompiler(() => new SimpleCompiler(new Expression("", ExpressionFlag.HsFlagAllowempty), CompilerMode.HsModeBlock));
await using var engine = engineBuilder.Build();
engine.Database.Size.Should().BeGreaterThan(0);
}
public async Task Engine_Should_Have_Valid_Version()
{
var loggerProvider = new XunitLoggerProvider(_testOutputHelper);
var engineBuilder = new EngineBuilder();
engineBuilder.WithLogger(loggerProvider.CreateLogger("Hyperscan"));
engineBuilder.WithDatabase(() => new Database());
engineBuilder.WithCompiler(() => new SimpleCompiler(new Expression("", ExpressionFlag.HsFlagAllowempty), CompilerMode.HsModeBlock));
await using var engine = engineBuilder.Build();
engine.Version.Should().NotBeNullOrEmpty();
}
public async Task Can_execute_void_commands(MemstateSettings settings)
{
settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log));
settings.StreamName = _randomStreamName;
var builder = new EngineBuilder(settings);
var engine = builder.Build <List <string> >();
await engine.ExecuteAsync(new Reverse()).ConfigureAwait(false);
await engine.DisposeAsync().ConfigureAwait(false);
}
public async Task Platform_Should_Be_Valid()
{
var loggerProvider = new XunitLoggerProvider(_testOutputHelper);
var engineBuilder = new EngineBuilder();
engineBuilder.WithLogger(loggerProvider.CreateLogger("Hyperscan"));
engineBuilder.WithDatabase(() => new Database());
engineBuilder.WithCompiler(() => new SimpleCompiler(new Expression("", ExpressionFlag.HsFlagAllowempty), CompilerMode.HsModeBlock));
await using var engine = engineBuilder.Build();
engine.PlatformInfo.Should().NotBeNull();
engine.PlatformInfo.IsPlatformValid.Should().BeTrue();
}
public async Task Logger_Should_Log_Traces()
{
var loggerProvider = new XunitLoggerProvider(_testOutputHelper);
var engineBuilder = new EngineBuilder();
engineBuilder.WithLogger(loggerProvider.CreateLogger("Hyperscan"));
engineBuilder.WithDatabase(() => new Database());
engineBuilder.WithCompiler(() => new SimpleCompiler(new Expression("foo(?i)bar(?-i)baz", ExpressionFlag.HsFlagUtf8), CompilerMode.HsModeBlock));
await using var engine = engineBuilder.Build();
var traces = loggerProvider.GetTraces();
traces.Should().ContainMatch("*1 expression(s) compiled*");
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var engineBuilder = new EngineBuilder();
engineBuilder.WithLogger(_loggerFactory.CreateLogger("Hyperscan"));
engineBuilder.WithDatabase(() => new Database());
engineBuilder.WithCompiler(() => new MultipleCompiler(new List <Expression>
{
new Expression("foo(?i)bar(?-i)baz", ExpressionFlag.HsFlagCaseless),
new Expression("foo", ExpressionFlag.HsFlagCaseless),
new Expression("foo(?i)bar", ExpressionFlag.HsFlagCaseless)
}, CompilerMode.HsModeBlock));
await using var engine = engineBuilder.Build();
using var matchSubscription = engine.OnMatch
.ObserveOn(new EventLoopScheduler())
.Do(match =>
{
var input = match.Input.Read();
Console.Write($"New match for input \"{input}\" with pattern \"{match.Expression.Pattern}\": ");
var matchQueue = new Queue <char>();
Console.BackgroundColor = ConsoleColor.Green;
foreach (var c in match.FullMatch)
{
matchQueue.Enqueue(c);
Console.Write(c);
}
Console.BackgroundColor = ConsoleColor.Red;
foreach (var current in input)
{
if (matchQueue.TryPeek(out var matched) && matched == current)
{
matchQueue.Dequeue();
continue;
}
Console.Write(current);
}
matchQueue.Clear();
Console.ResetColor();
Console.Write(Environment.NewLine);
})
.Subscribe(match => { },
ex => { },
() => { });
await engine.ScanAsync("foofoobarbazbaz", stoppingToken);
await Task.Delay(-1, stoppingToken);
}
public void Setup()
{
var settings = new MemstateSettings().WithRandomSuffixAppendedToStreamName();
/*
* var logProvider = new ConsoleLoggerProvider(filter: (cat, level) => true, includeScopes: false);
* settings.LoggerFactory.AddProvider(logProvider);
*/
settings.StorageProvider = StorageProviderTypes.AssemblyQualifiedName;
settings.Serializers.Register("newtonsoft.json", _ => new JsonSerializerAdapter(settings));
var engineBuilder = new EngineBuilder(settings);
_engine = engineBuilder.Build(new KeyValueStore <int>());
}
public void Setup()
{
var config = Config.Current;
var settings = config.GetSettings <EngineSettings>().WithRandomSuffixAppendedToStreamName();
/*
* var logProvider = new ConsoleLoggerProvider(filter: (cat, level) => true, includeScopes: false);
* settings.LoggerFactory.AddProvider(logProvider);
*/
config.StorageProviderName = StorageProviderTypes.AssemblyQualifiedName;
config.SerializerName = "newtonsoft.json";
var engineBuilder = new EngineBuilder();
_engine = engineBuilder.Build <KeyValueStore <int> >().Result;
}
public void Start()
{
var builder = new EngineBuilder()
.AddReporter(new RpmReporter(_eventBus, _adapter))
.AddReporter(new SlippingReporter(_eventBus, _adapter))
.AddReporter(new GearReporter(_eventBus, new GearboxAdapter(_gearbox)));
if (_adapter.SupportsTiltPosition())
{
builder.AddReporter(new TiltChangeReporter(_eventBus, _adapter));
}
_eventBus.Attach(new TransmissionEventListener(new LeverAdapter(_gearbox)));
builder.Build().Start();
}
public void MapsToCommand()
{
var settings = new MemstateSettings();
settings.FileSystem = new InMemoryFileSystem();
var storageProvider = settings.CreateStorageProvider();
var builder = new EngineBuilder(settings, storageProvider);
var engine = builder.Build <ITestModel>(new TestModel());
var client = new LocalClient <ITestModel>(engine);
var proxy = client.GetDispatchProxy();
proxy.SetCustomer(new Customer());
var journalEntry = storageProvider.CreateJournalReader().GetRecords().FirstOrDefault();
Assert.NotNull(journalEntry);
Assert.IsType <SetCustomerCommand>(journalEntry.Command);
}
public void MapsToCommand()
{
var config = new MemstateSettings();
config.StorageProvider = typeof(InMemoryStorageProvider).FullName;
var storageProvider = config.CreateStorageProvider();
var builder = new EngineBuilder(config, storageProvider);
var engine = builder.Build <ITestModel>(new TestModel());
var client = new LocalClient <ITestModel>(engine);
var proxy = client.GetDispatchProxy();
proxy.SetCustomer(new Customer());
var journalEntry = storageProvider.CreateJournalReader().GetRecords().FirstOrDefault();
Assert.NotNull(journalEntry);
Assert.IsType(typeof(SetCustomerCommand), journalEntry.Command);
}
public async Task Database_Serialization_Should_Serialize()
{
var engineBuilder = new EngineBuilder();
engineBuilder.WithDatabase(() => new Database());
engineBuilder.WithCompiler(() => new SimpleCompiler(new Expression("", ExpressionFlag.HsFlagAllowempty), CompilerMode.HsModeBlock));
await using var engine = engineBuilder.Build();
var bytes = engine.Database.Serialize();
bytes.Should().NotBeEmpty();
var engineBuilder2 = new EngineBuilder();
engineBuilder2.WithDatabase(() => new Database(bytes));
engineBuilder2.WithCompiler(() => new SimpleCompiler(new Expression("", ExpressionFlag.HsFlagAllowempty), CompilerMode.HsModeBlock));
await using var engine2 = engineBuilder2.Build();
engine2.Database.Size.Should().Be(engine.Database.Size);
}
public void Setup()
{
var settings = new MemstateSettings().WithRandomSuffixAppendedToStreamName();
/*
* var logProvider = new ConsoleLoggerProvider(filter: (cat, level) => true, includeScopes: false);
* settings.LoggerFactory.AddProvider(logProvider);
*/
settings.StorageProvider = StorageProviderTypes.AssemblyQualifiedName;
settings.Configuration["StorageProviders:Postgresql:ConnectionString"] = "Host=localhost; Database=postgres; Password=secret; User ID=postgres;";
settings.Configuration["StorageProviders:Postgresql:Table"] = $"memstate_commands_{Guid.NewGuid():N}";
settings.Configuration["StorageProviders:Postgresql:SubscriptionStream"] = $"memstate_notifications_{Guid.NewGuid():N}";
var engineBuilder = new EngineBuilder(settings);
_engine = engineBuilder.Build(new KeyValueStore <int>());
_setCommand = new Set <int>("Key", 42);
}
public static async Task <string> Run(byte[] moduleContent, string message, CancellationToken cancellationToken)
{
var engineBuilder = new EngineBuilder();
using var engine = engineBuilder.Build();
using var module = Module.FromBytes(engine, "module", moduleContent);
using var host = new Host(engine);
var stdinFilePath = Path.GetTempFileName();
await File.WriteAllTextAsync(stdinFilePath, message, cancellationToken);
var stdoutFilePath = Path.GetTempFileName();
var stderrFilePath = Path.GetTempFileName();
host.DefineWasi("wasi_snapshot_preview1", new WasiConfiguration()
.WithStandardInput(stdinFilePath)
.WithStandardOutput(stdoutFilePath)
.WithStandardError(stderrFilePath));
using dynamic instance = host.Instantiate(module);
string reply = await await Task.WhenAny(
Task.Run(async() =>
{
instance.run();
string errorReply = await File.ReadAllTextAsync(stderrFilePath, cancellationToken);
if (errorReply is not "")
{
throw new ModuleRunningException(errorReply);
}
string successReply = await File.ReadAllTextAsync(stdoutFilePath, cancellationToken);
return(successReply);
}),
WaitCancellation <string>(cancellationToken)
);
return(reply);
}
public static void Run(JsEngines engineType, string testName, [CallerMemberName] string fixture = null)
{
var testJs = R.GetString("Knyaz.Optimus.Tests.Resources.JsTests." + fixture + ".js");
var resources = Mocks.ResourceProvider("http://test",
"<html><script>" + R.JsTestsBase + "</script>" + "<script>" + testJs + "</script></html>")
.Resource("http://test/sample.js", R.GetString("Knyaz.Optimus.Tests.Resources.JsTests.sample.js"));
var builder = new EngineBuilder()
.SetResourceProvider(resources);
switch (engineType)
{
case JsEngines.Jurassic: builder.UseJurassic(); break;
case JsEngines.Jint: builder.UseJint(); break;
}
var engine = builder.Build();
engine.OpenUrl("http://test").Wait();
engine.Console.OnLog += o => {
Debug.WriteLine(o.ToString());
};
object res;
lock (engine.Document)
{
res = engine.ScriptExecutor.Evaluate("text/javascript",
@"Run('" + fixture + "', '" + testName + "');");
}
if (res != null)
{
Assert.Fail(res.ToString());
}
}
public async Task Engine_With_Simple_Compiler_And_Block_Mode_Should_Match_Pattern()
{
var loggerProvider = new XunitLoggerProvider(_testOutputHelper);
var engineBuilder = new EngineBuilder();
engineBuilder.WithLogger(loggerProvider.CreateLogger("Hyperscan"));
engineBuilder.WithDatabase(() => new Database());
engineBuilder.WithCompiler(() => new SimpleCompiler(new Expression("foo(?i)bar(?-i)baz", ExpressionFlag.HsFlagUtf8), CompilerMode.HsModeBlock));
await using var engine = engineBuilder.Build();
var onMatch = engine.OnMatch.FirstAsync().ToTask();
await engine.ScanAsync("foofoobarbazbazbaz", CancellationToken.None);
var match = await onMatch;
match.Should().NotBeNull();
match.Expression.Flag.Should().Be(ExpressionFlag.HsFlagUtf8);
match.Expression.Id.Should().Be(0);
match.Expression.TryGetInfo(out var info).Should().BeTrue();
info.CompilationErrorMessage.Should().BeEmpty();
match.Input.Read().Should().Be("foofoobarbazbazbaz");
match.Expression.Pattern.Should().Be("foo(?i)bar(?-i)baz");
}