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"); }