public void ConversionShouldBeCalledBetweenDifferentSignatures()
{
object theDefault = "42";
Func<string, int> convert1 = app => int.Parse(app, CultureInfo.InvariantCulture) + 1;
Func<int, string> convert2 = app => app.ToString(CultureInfo.InvariantCulture) + "2";
Func<string, string> middleware1 = app => app + "3";
Func<int, int> middleware2 = app => app + 4;
var builder = new AppBuilder();
builder.AddSignatureConversion(convert1);
builder.AddSignatureConversion(convert2);
builder.Properties["builder.DefaultApp"] = theDefault;
var theApp = builder.BuildNew<int>(x => x.Use(middleware1).Use(middleware2));
// "42" + 1: 43 // theDefault passed through convert1 for next middleware
// 43 + 4: 47 // passed through middleware2
// 47 + "2": "472" // passed through convert2 for next middleware
// "472" + "3": "4723" // passed through middleware1
// "4723" + 1: 4724 // passed through convert1 to return
theApp.ShouldBe(4724);
}
public void Build_returns_404_by_default()
{
var builder = new AppBuilder();
var app = builder.Materialize();
var callResult = AppUtils.Call(app);
Assert.That(callResult.Status, Is.EqualTo("404 Not Found"));
}
public Task Build_returns_404_by_default()
{
var builder = new AppBuilder();
var app = builder.Materialize<AppDelegate>();
var client = TestHttpClient.ForAppDelegate(app);
return client.GetAsync("http://localhost")
.Then(response => response.StatusCode.ShouldBe(HttpStatusCode.NotFound));
}
public void ConverterCombinationWillBeInvokedIfNeeded()
{
var builder = new AppBuilder();
Func<AppFunc, DifferentType> convert1 = _ => new DifferentType();
Func<DifferentType, AppFunc> convert2 = _ => call => { throw new NotImplementedException(); };
builder.AddSignatureConversion(convert1);
builder.AddSignatureConversion(convert2);
var diff = builder.Build<DifferentType>();
}
static void Main(string[] args)
{
var app = new AppBuilder().Build(Startup.Configuration);
var server = new ServerFactory().Create(app, 1337);
Console.WriteLine("Running on http://localhost:1337");
Console.ReadLine();
}
public void DelegateShouldBeCalledWithParameters()
{
string theDefault = "default";
var builder = new AppBuilder();
builder.Properties["builder.DefaultApp"] = theDefault;
builder.Use(new Func<string, int, long, string>((s, i, l) => i + l + s), 1, 2L);
var theApp = builder.Build<string>();
theApp.ShouldNotBeSameAs("12" + theDefault);
}
public void InstanceMemberNamedInvokeShouldQualifyAsMiddlewareFactory()
{
Func<int, string> theDefault = call => "Hello[" + call + "]";
var builder = new AppBuilder();
builder.Properties["builder.DefaultApp"] = theDefault;
var theApp = builder.BuildNew<Func<int, string>>(
x => x
.Use(new StringPlusValue(" world!"))
.Use(new StringPlusValue(" there,")));
theApp(42).ShouldBe("Hello[42] there, world!");
}
public GhostSettings()
{
DefaultServer = "HttpListener";
DefaultScheme = "http";
DefaultHost = "+";
DefaultPort = 8080;
DefaultOutput = Console.Error;
ServerAssemblyPrefix = "Gate.Hosts.";
Loader = new StartupLoader();
Builder = new AppBuilder();
}
static void Main(string[] args)
{
var builder = new AppBuilder();
var app = builder.Build(Startup.Configuration);
var server = new ServerFactory().Create(app, 8081);
ThreadPool.QueueUserWorkItem(_ =>
{
while (true)
{
Thread.Sleep(1000);
var sc = new ScreenCapture();
var image = sc.CaptureScreen();
using (var ms = new MemoryStream())
{
image.Save(ms, ImageFormat.Png);
var s = Convert.ToBase64String(ms.ToArray());
var connection = new FileConnectionManager<ScreenSharing>(
Startup.DependencyResolver.Resolve<IMessageBus>(),
Startup.DependencyResolver.Resolve<IJsonSerializer>(),
Startup.DependencyResolver.Resolve<ITraceManager>()
);
connection.SendFile("image/png", s);
}
Console.WriteLine("Data sent");
}
});
Console.WriteLine("Running on localhost:8081");
Console.ReadKey();
}
public void DelegateShouldBeCalledToAddMiddlewareAroundTheDefaultApp()
{
var theNext = "next";
var theMiddle = "middle";
var theDefault = "default";
Func<string, string> middleware = next =>
{
theNext = next;
return theMiddle;
};
var builder = new AppBuilder();
builder.Properties["builder.DefaultApp"] = theDefault;
var theApp = builder.BuildNew<string>(x => x.Use(middleware));
builder.Run(theApp);
theNext.ShouldBeSameAs(theDefault);
theApp.ShouldBeSameAs(theMiddle);
theApp.ShouldNotBeSameAs(theDefault);
}
public static void InitInterop() => AppBuilder.Configure <App>() .UsePlatformDetect() .LogToTrace() .UseReactiveUI() .SetupWithoutStarting();
public void UseAppWithIOwinContext()
{
var builder = new AppBuilder();
builder.Run(context =>
{
context.Response.StatusCode = 201;
return Task.FromResult<object>(null);
});
AppFunc theApp = builder.Build();
IOwinContext baseContext = new OwinContext();
theApp(baseContext.Environment).Wait();
Assert.Equal(201, baseContext.Response.StatusCode);
}
public void AppFuncConvertsToOwinMiddleware()
{
var builder = new AppBuilder();
builder.Use(new Func<object, AppFunc>(ignored =>
{
return environment =>
{
environment["owin.ResponseReasonPhrase"] = "Set In Middleware";
return Task.FromResult<object>(null);
};
}));
var theApp = builder.Build<OwinMiddleware>();
IOwinContext baseContext = new OwinContext();
theApp.Invoke(baseContext).Wait();
Assert.Equal(200, baseContext.Response.StatusCode);
Assert.Equal("Set In Middleware", baseContext.Response.ReasonPhrase);
}
public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure <App>() .AfterSetup(_ => IconProvider.Register <FontAwesomeIconProvider>()) .UsePlatformDetect() .LogToTrace() .UseReactiveUI();
public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure(() => new AvaloniaApp(() => new TesterWindow())) .UsePlatformDetect() .LogToTrace();
protected override AppBuilder CreateAppBuilder()
{
var builder = AppBuilder.Configure <TApp>();
return(CustomizeAppBuilder(builder));
}
public Task TheDefaultDefaultShouldBe404()
{
var builder = new AppBuilder();
var app = builder.Build();
var request = OwinRequest.Create();
var response = new OwinResponse(request);
return app(request.Dictionary).Then(() => response.StatusCode.ShouldBe(404));
}
public static void Main(string[] args)
{
bool firstProcess = false;
// chromely starts multiple child processes
// we only want to start the asp core on the first process
//
// ideally it would be nice if chromely allowed things to be passed to
// the child processes through args
Mutex mutex = null;
try
{
// if this succeeds we are not the first process
mutex = Mutex.OpenExisting("BlazorTestMutex");
}
catch
{
// must be first process
mutex = new Mutex(false, "BlazorTestMutex");
firstProcess = true;
}
int port = -1;
if (firstProcess)
{
// try to find first available local port to host blazor on
for (int i = StartScan; i < EndScan; i++)
{
if (IsPortAvailable(i))
{
port = i;
break;
}
}
if (port != -1)
{
// start the kestrel server in a background thread
var blazorTask = new Task(() => CreateHostBuilder(args, port).Build().Run(), TaskCreationOptions.LongRunning);
blazorTask.Start();
// wait till its up
while (IsPortAvailable(port))
{
Thread.Sleep(1);
}
}
// used to pass the port number to chromely child processes
MemoryMappedFile mmf = MemoryMappedFile.CreateNew("BlazorTestMap", 4);
MemoryMappedViewAccessor accessor = mmf.CreateViewAccessor();
accessor.Write(0, (int)port);
}
else
{
// fetch port number
MemoryMappedFile mmf = MemoryMappedFile.CreateOrOpen("BlazorTestMap", 4);
MemoryMappedViewAccessor accessor = mmf.CreateViewAccessor();
port = accessor.ReadInt32(0);
}
if (port != -1)
{
// start up chromely
var core = typeof(IChromelyConfiguration).Assembly;
var config = DefaultConfiguration.CreateForRuntimePlatform();
config.CefDownloadOptions = new CefDownloadOptions(true, true);
config.WindowOptions.Position = new WindowPosition(1, 2);
config.WindowOptions.Size = new WindowSize(1000, 600);
config.StartUrl = $"https://127.0.0.1:{port}";
config.DebuggingMode = true;
config.WindowOptions.RelativePathToIconFile = "chromely.ico";
try
{
var builder = AppBuilder.Create();
builder = builder.UseApp <TestApp>();
builder = builder.UseConfiguration <DefaultConfiguration>(config);
builder = builder.Build();
builder.Run(args);
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw;
}
}
mutex.ReleaseMutex();
}
protected virtual AppBuilder CustomizeAppBuilder(AppBuilder builder) => builder.UseAndroid();
public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure <App>() .UsePlatformDetect() .UseDataGrid() .LogToDebug();
static void Main(string[] args)
{
AppBuilder.Configure <App>()
.UsePlatformDetect()
.Start <MainWindow>();
}
/// <summary> /// This method is needed for IDE previewer infrastructure /// </summary> public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure <App>() .UsePlatformDetect() .UseSkia() .UseReactiveUI() .UseDataGrid();
public void DelegatesWithIdenticalParametersShouldConvertAutomatically()
{
var builder = new AppBuilder();
builder.Properties["builder.DefaultApp"] = new Func<string, string>(call => call);
builder.UseFunc<AppOne>(next => call => next(call) + "1");
builder.UseFunc<AppTwo>(next => call => next(call) + "2");
builder.UseFunc<Func<string, string>>(next => call => next(call) + "3");
var app = builder.Build<AppTwo>();
app("0").ShouldBe("0321");
}
private static void ConfigureAssetAssembly(AppBuilder builder)
{
AvaloniaLocator.CurrentMutable
.GetService <IAssetLoader>()
.SetDefaultAssembly(typeof(App).Assembly);
}
public void NoConversionAvailableThrowsArgumentException()
{
var builder = new AppBuilder();
Assert.Throws<ArgumentException>(() => builder.Build<DifferentType>());
}
private static AppBuilder BuildAvaloniaApp()
{
return(AppBuilder.Configure <App>().UsePlatformDetect().UseReactiveUI());
}
public void TypeofClassConstructorsWithWrongParameterCountShouldThrow()
{
Func<int, string> theDefault = call => "Hello[" + call + "]";
var builder = new AppBuilder();
builder.Properties["builder.DefaultApp"] = theDefault;
Should.Throw<MissingMethodException>(() =>
{
var theApp = builder.BuildNew<Func<int, string>>(
x => x.Use(typeof(StringPlusValue2), "arg 1", "extra arg"));
});
}
static void Main(string[] args)
{
AppBuilder.Configure <UntitledCanvasApp>()
.UsePlatformDetect()
.StartWithClassicDesktopLifetime(args);
}
public CorsAppDecorator(AppBuilder build)
: base(build)
{
}
static AppBuilder BuildAvaloniaApp()
{
return(AppBuilder.Configure <App>()
.UsePlatformDetect()
.LogToDebug(LogEventLevel.Warning));
}
public void TheDefaultDefaultShouldBe404()
{
var builder = new AppBuilder();
var app = builder.Build<OwinMiddleware>();
var context = new OwinContext();
app.Invoke(context).Wait();
context.Response.StatusCode.ShouldBe(404);
}
public async Task PostUserDescription()
{
var container = AppBuilder.CreateContainer();
using (WebApp.Start(Settings.Current.BaseURL, app => AppBuilder.BuildWithContainer(app, container, false))) {
var repository = container.GetInstance <IEventRepository>();
repository.RemoveAll();
const string referenceId = "fda94ff32921425ebb08b73df1d1d34c";
const string badReferenceId = "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz";
var statsCounter = container.GetInstance <IAppStatsClient>() as InMemoryAppStatsClient;
var descQueue = container.GetInstance <IQueue <EventUserDescription> >() as InMemoryQueue <EventUserDescription>;
Assert.NotNull(statsCounter);
EnsureSampleData(container);
var events = new List <Event> {
new Event {
Message = "Testing", ReferenceId = referenceId
}
};
var configuration = GetClient().Configuration;
var serializer = new DefaultJsonSerializer();
var client = new DefaultSubmissionClient();
var description = new UserDescription {
EmailAddress = "*****@*****.**", Description = "Some description."
};
Debug.WriteLine("Before Submit Description");
statsCounter.DisplayStats();
Assert.True(statsCounter.WaitForCounter(StatNames.EventsUserDescriptionErrors, work: () => {
var response = client.PostUserDescription(referenceId, description, configuration, serializer);
Debug.WriteLine("After Submit Description");
Assert.True(response.Success, response.Message);
Assert.Null(response.Message);
}));
statsCounter.DisplayStats();
Debug.WriteLine(descQueue.GetQueueCount());
Debug.WriteLine("Before Post Event");
Assert.True(statsCounter.WaitForCounter(StatNames.EventsProcessed, work: () => {
var response = client.PostEvents(events, configuration, serializer);
Debug.WriteLine("After Post Event");
Assert.True(response.Success, response.Message);
Assert.Null(response.Message);
}));
statsCounter.DisplayStats();
if (statsCounter.GetCount(StatNames.EventsUserDescriptionProcessed) == 0)
{
Assert.True(statsCounter.WaitForCounter(StatNames.EventsUserDescriptionProcessed));
}
container.GetInstance <IElasticClient>().Refresh();
var ev = repository.GetByReferenceId("537650f3b77efe23a47914f4", referenceId).FirstOrDefault();
Assert.NotNull(ev);
Assert.NotNull(ev.GetUserDescription());
Assert.Equal(description.ToJson(), ev.GetUserDescription().ToJson());
Assert.InRange(statsCounter.GetCount(StatNames.EventsUserDescriptionErrors), 1, 5);
Assert.True(statsCounter.WaitForCounter(StatNames.EventsUserDescriptionErrors, work: () => {
var response = client.PostUserDescription(badReferenceId, description, configuration, serializer);
Assert.True(response.Success, response.Message);
Assert.Null(response.Message);
}));
statsCounter.DisplayStats();
Assert.InRange(statsCounter.GetCount(StatNames.EventsUserDescriptionErrors), 2, 10);
}
}
public void UseHandlerWithIOwinContext()
{
var builder = new AppBuilder();
builder.Use((context, next) =>
{
context.Response.ReasonPhrase = "Set In Middleware";
return next();
});
AppFunc theApp = builder.Build();
IOwinContext baseContext = new OwinContext();
theApp(baseContext.Environment).Wait();
Assert.Equal(404, baseContext.Response.StatusCode);
Assert.Equal("Set In Middleware", baseContext.Response.ReasonPhrase);
}
// Avalonia configuration, don't remove; also used by visual designer. public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure <App>() .UsePlatformDetect() .LogToDebug() .UseReactiveUI();
public void OwinMiddlewareConvertsToAppFunc()
{
var builder = new AppBuilder();
builder.Use(new Func<object, OwinMiddleware>(ignored => { return new OwinMiddlwareApp(); }));
var theApp = builder.Build<AppFunc>();
IOwinContext baseContext = new OwinContext();
theApp.Invoke(baseContext.Environment).Wait();
Assert.Equal(200, baseContext.Response.StatusCode);
Assert.Equal("Set In Middleware", baseContext.Response.ReasonPhrase);
}
public static AppBuilder BuildAvaloniaApp() => AppBuilder .Configure <App>() .UsePlatformDetect() .UseReactiveUI() .UseHeadless();
public Task TheDefaultDefaultShouldBe404()
{
var builder = new AppBuilder();
var app = builder.Build();
var helper = new OwinHelper();
return app(helper.Env).Then(() => helper.ResponseStatusCode.ShouldBe(404));
}
// Avalonia configuration, don't remove; also used by visual designer. public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure <App>() .UsePlatformDetect() .LogToTrace();
public void DelegateShouldQualifyAsAppWithRun()
{
Func<int, string> theDefault = call => "Hello[" + call + "]";
Func<int, string> theSite = call => "Called[" + call + "]";
var builder = new AppBuilder();
builder.Properties["builder.DefaultApp"] = theDefault;
var theApp = builder.BuildNew<Func<int, string>>(x => x.Run(theSite));
theApp(42).ShouldBe("Called[42]");
}
public void Setup()
{
_builder = new AppBuilder();
_container = new Container();
GraphiteApplicationTests.RegisterRequestObjects(_container);
}
public void InstanceMemberNamedInvokeShouldQualifyAsAppWithRun()
{
var theSite = new MySite();
var builder = new AppBuilder();
var theApp = builder.BuildNew<Func<int, string>>(x => x.Run(theSite));
theApp(42).ShouldBe("Called[42]");
}
//private static IDisposable StartupWorkingTitleApp()
//{
// var server = new Server((req, resp) =>
// {
// resp.Write("Hello, again, world");
// resp.End();
// });
// server.Listen(8081, null);
// return server;
//}
private static IDisposable StartupNancyApp()
{
var builder = new AppBuilder();
var app = builder.Build(Configuration);
var server = new ServerFactory(new StdoutTrace()).Create(app, 8080);
Console.WriteLine("Running on localhost:8080");
return server;
}
public void OtherObjectShouldThrow()
{
Func<int, string> theDefault = call => "Hello[" + call + "]";
var builder = new AppBuilder();
builder.Properties["builder.DefaultApp"] = theDefault;
Should.Throw<NotSupportedException>(() =>
{
var theApp = builder.BuildNew<Func<int, string>>(
x => x.Use(new object()));
});
}
static void Main()
{
InitDllMap();
//SetProcessDPIAware();
//TODO: figure out how to set this switch in appconfig
AppContext.SetSwitch("Switch.System.Runtime.Serialization.SerializationGuard.AllowFileWrites", true);
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
string[] args = Environment.GetCommandLineArgs();
PathMod.InitExePath(args[0]);
DiagManager.InitInstance();
DiagManager.Instance.CurSettings = DiagManager.Instance.LoadSettings();
DiagManager.Instance.LoadModSettings();
DiagManager.Instance.UpgradeBinder = new UpgradeBinder();
try
{
DiagManager.Instance.LogInfo("=========================================");
DiagManager.Instance.LogInfo(String.Format("SESSION STARTED: {0}", String.Format("{0:yyyy/MM/dd HH:mm:ss}", DateTime.Now)));
DiagManager.Instance.LogInfo("Version: " + Versioning.GetVersion().ToString());
DiagManager.Instance.LogInfo(Versioning.GetDotNetInfo());
DiagManager.Instance.LogInfo("=========================================");
bool logInput = true;
bool guideBook = false;
bool guideCsv = false;
GraphicsManager.AssetType convertAssets = GraphicsManager.AssetType.None;
DataManager.DataType convertIndices = DataManager.DataType.None;
DataManager.DataType reserializeIndices = DataManager.DataType.None;
string langArgs = "";
bool dev = false;
string quest = "";
List <string> mod = new List <string>();
bool buildQuest = false;
string playInputs = null;
for (int ii = 1; ii < args.Length; ii++)
{
if (args[ii] == "-dev")
{
dev = true;
}
else if (args[ii] == "-play" && args.Length > ii + 1)
{
playInputs = args[ii + 1];
ii++;
}
else if (args[ii] == "-lang" && args.Length > ii + 1)
{
langArgs = args[ii + 1];
ii++;
}
else if (args[ii] == "-nolog")
{
logInput = false;
}
else if (args[ii] == "-guide")
{
guideBook = true;
}
else if (args[ii] == "-csv")
{
guideCsv = true;
}
else if (args[ii] == "-asset")
{
PathMod.ASSET_PATH = Path.GetFullPath(args[ii + 1]);
ii++;
}
else if (args[ii] == "-raw")
{
PathMod.DEV_PATH = Path.GetFullPath(args[ii + 1]);
ii++;
}
else if (args[ii] == "-quest")
{
quest = args[ii + 1];
ii++;
}
else if (args[ii] == "-mod")
{
int jj = 1;
while (args.Length > ii + jj)
{
if (args[ii + jj].StartsWith("-"))
{
break;
}
else
{
mod.Add(args[ii + jj]);
}
jj++;
}
ii += jj - 1;
}
else if (args[ii] == "-build")
{
buildQuest = true;
ii++;
}
else if (args[ii] == "-convert")
{
int jj = 1;
while (args.Length > ii + jj)
{
GraphicsManager.AssetType conv = GraphicsManager.AssetType.None;
foreach (GraphicsManager.AssetType type in Enum.GetValues(typeof(GraphicsManager.AssetType)))
{
if (args[ii + jj].ToLower() == type.ToString().ToLower())
{
conv = type;
break;
}
}
if (conv != GraphicsManager.AssetType.None)
{
convertAssets |= conv;
}
else
{
break;
}
jj++;
}
ii += jj - 1;
}
else if (args[ii] == "-index")
{
int jj = 1;
while (args.Length > ii + jj)
{
DataManager.DataType conv = DataManager.DataType.None;
foreach (DataManager.DataType type in Enum.GetValues(typeof(DataManager.DataType)))
{
if (args[ii + jj].ToLower() == type.ToString().ToLower())
{
conv = type;
break;
}
}
if (conv != DataManager.DataType.None)
{
convertIndices |= conv;
}
else
{
break;
}
jj++;
}
ii += jj - 1;
}
else if (args[ii] == "-reserialize")
{
int jj = 1;
while (args.Length > ii + jj)
{
DataManager.DataType conv = DataManager.DataType.None;
foreach (DataManager.DataType type in Enum.GetValues(typeof(DataManager.DataType)))
{
if (args[ii + jj].ToLower() == type.ToString().ToLower())
{
conv = type;
break;
}
}
if (conv != DataManager.DataType.None)
{
reserializeIndices |= conv;
}
else
{
break;
}
jj++;
}
ii += jj - 1;
}
}
DiagManager.Instance.SetupGamepad();
GraphicsManager.InitParams();
DiagManager.Instance.DevMode = dev;
if (quest != "")
{
ModHeader header = PathMod.GetModDetails(Path.Combine(PathMod.MODS_PATH, quest));
if (header.IsValid())
{
PathMod.Quest = header;
DiagManager.Instance.LogInfo(String.Format("Loaded quest \"{0}\".", quest));
}
else
{
DiagManager.Instance.LogInfo(String.Format("Cannot find quest \"{0}\" in {1}. Falling back to base game.", quest, PathMod.MODS_PATH));
}
}
if (mod.Count > 0)
{
List <ModHeader> workingMods = new List <ModHeader>();
for (int ii = 0; ii < mod.Count; ii++)
{
ModHeader header = PathMod.GetModDetails(Path.Combine(PathMod.MODS_PATH, mod[ii]));
if (header.IsValid())
{
workingMods.Add(header);
DiagManager.Instance.LogInfo(String.Format("Loaded mod \"{0}\".", String.Join(", ", mod[ii])));
}
else
{
DiagManager.Instance.LogInfo(String.Format("Cannot find mod \"{0}\" in {1}. It will be ignored.", mod, PathMod.MODS_PATH));
mod.RemoveAt(ii);
ii--;
}
}
PathMod.Mods = workingMods.ToArray();
}
if (playInputs != null)
{
DiagManager.Instance.LoadInputs(playInputs);
}
Text.Init();
if (langArgs != "" && DiagManager.Instance.CurSettings.Language == "")
{
if (langArgs.Length > 0)
{
DiagManager.Instance.CurSettings.Language = langArgs.ToLower();
Text.SetCultureCode(langArgs.ToLower());
}
else
{
DiagManager.Instance.CurSettings.Language = "en";
}
}
Text.SetCultureCode(DiagManager.Instance.CurSettings.Language == "" ? "" : DiagManager.Instance.CurSettings.Language.ToString());
if (buildQuest)
{
if (!PathMod.Quest.IsValid())
{
DiagManager.Instance.LogInfo("No quest specified to build.");
return;
}
RogueEssence.Dev.DevHelper.MergeQuest(quest);
return;
}
if (convertAssets != GraphicsManager.AssetType.None)
{
//run conversions
using (GameBase game = new GameBase())
{
GraphicsManager.InitSystem(game.GraphicsDevice);
GraphicsManager.RunConversions(convertAssets);
}
return;
}
if (reserializeIndices != DataManager.DataType.None)
{
DiagManager.Instance.LogInfo("Beginning Reserialization");
using (GameBase game = new GameBase())
{
GraphicsManager.InitSystem(game.GraphicsDevice);
GraphicsManager.RebuildIndices(GraphicsManager.AssetType.All);
}
//we need the datamanager for this, but only while data is hardcoded
//TODO: remove when data is no longer hardcoded
LuaEngine.InitInstance();
DataManager.InitInstance();
DataManager.InitDataDirs(PathMod.ModPath(""));
RogueEssence.Dev.DevHelper.ReserializeBase();
DiagManager.Instance.LogInfo("Reserializing main data");
RogueEssence.Dev.DevHelper.Reserialize(reserializeIndices);
DiagManager.Instance.LogInfo("Reserializing map data");
if ((reserializeIndices & DataManager.DataType.Zone) != DataManager.DataType.None)
{
RogueEssence.Dev.DevHelper.ReserializeData <Map>(DataManager.DATA_PATH + "Map/", DataManager.MAP_EXT);
RogueEssence.Dev.DevHelper.ReserializeData <GroundMap>(DataManager.DATA_PATH + "Ground/", DataManager.GROUND_EXT);
}
DiagManager.Instance.LogInfo("Reserializing indices");
RogueEssence.Dev.DevHelper.RunIndexing(reserializeIndices);
DataManager.Instance.UniversalData = (TypeDict <BaseData>)RogueEssence.Dev.DevHelper.LoadWithLegacySupport(PathMod.ModPath(DataManager.MISC_PATH + "Index.bin"), typeof(TypeDict <BaseData>));
RogueEssence.Dev.DevHelper.RunExtraIndexing(reserializeIndices);
return;
}
if (convertIndices != DataManager.DataType.None)
{
//we need the datamanager for this, but only while data is hardcoded
//TODO: remove when data is no longer hardcoded
LuaEngine.InitInstance();
DataManager.InitInstance();
DiagManager.Instance.LogInfo("Reserializing indices");
DataManager.InitDataDirs(PathMod.ModPath(""));
RogueEssence.Dev.DevHelper.RunIndexing(convertIndices);
DataManager.Instance.UniversalData = (TypeDict <BaseData>)RogueEssence.Dev.DevHelper.LoadWithLegacySupport(PathMod.ModPath(DataManager.MISC_PATH + "Index.bin"), typeof(TypeDict <BaseData>));
RogueEssence.Dev.DevHelper.RunExtraIndexing(convertIndices);
return;
}
if (guideBook || guideCsv)
{
//print the guidebook in the chosen language
//we need the datamanager for this
LuaEngine.InitInstance();
DataManager.InitInstance();
DataManager.Instance.InitData();
//just print a guidebook and exit
StrategyGuide.PrintMoveGuide(guideCsv);
StrategyGuide.PrintItemGuide(guideCsv);
StrategyGuide.PrintAbilityGuide(guideCsv);
StrategyGuide.PrintEncounterGuide(guideCsv);
return;
}
//Dev.ImportManager.PrintMoveUsers(PathMod.DEV_PATH+"moves.txt");
//Dev.ImportManager.PrintAbilityUsers(PathMod.DEV_PATH+"abilities.txt");
logInput = false; //this feature is disabled for now...
if (DiagManager.Instance.ActiveDebugReplay == null && logInput)
{
DiagManager.Instance.BeginInput();
}
if (DiagManager.Instance.DevMode)
{
InitDataEditor();
AppBuilder builder = RogueEssence.Dev.Program.BuildAvaloniaApp();
builder.StartWithClassicDesktopLifetime(args);
}
else
{
DiagManager.Instance.DevEditor = new EmptyEditor();
using (GameBase game = new GameBase())
game.Run();
}
}
catch (Exception ex)
{
DiagManager.Instance.LogError(ex);
throw;
}
}
public void TypeofClassConstructorsShouldQualifyAsMiddlewareFactory()
{
Func<int, string> theDefault = call => "Hello[" + call + "]";
var builder = new AppBuilder();
builder.Properties["builder.DefaultApp"] = theDefault;
var theApp = builder.BuildNew<Func<int, string>>(
x => x
.Use(typeof(StringPlusValue2), " world!")
.Use(typeof(StringPlusValue2), " there,"));
theApp(42).ShouldBe("Hello[42] there, world!");
}
protected virtual AppBuilder CustomizeAppBuilder(AppBuilder builder) => builder;
public static AppBuilder BuildAvaloniaApp()
=> AppBuilder.Configure <App>()
.With(new AvaloniaNativePlatformOptions()
{
})
.UsePlatformDetect();
//private static IDisposable StartupWorkingTitleApp()
//{
// var server = new Server((req, resp) =>
// {
// resp.Write("Hello, again, world");
// resp.End();
// });
// server.Listen(8081, null);
// return server;
//}
private static IDisposable StartupNancyApp()
{
var builder = new AppBuilder();
builder
.Use(SetResponseHeader, "X-Server", "Dragonfly")
.Use(ShowCalls)
.UseWebSockets("/socketserver", OnConnection)
.UseChunked()
.RunNancy();
var app = builder.Materialize<AppDelegate>();
var server = new ServerFactory(new StdoutTrace()).Create(app, 8080);
Console.WriteLine("Running on localhost:8080");
return server;
}
public void Use_middleware_between_calls_to_map_only_apply_to_requests_that_reach_later_maps()
{
var builder = new AppBuilder();
builder
.Use(AddStatus, " Outer")
.Map("/here1", map => map
.Use(AddStatus, " Mapped1")
.Run(TwoHundredFoo))
.Use(AddStatus, " Between")
.Map("/here2", map => map
.Use(AddStatus, " Mapped2")
.Run(TwoHundredFoo))
.Use(AddStatus, " Inner")
.Run(TwoHundredFoo);
var app = builder.Materialize();
var resultThere = AppUtils.Call(app, "/there");
var resultHere1 = AppUtils.Call(app, "/here1");
var resultHere2 = AppUtils.Call(app, "/here2");
Assert.That(resultThere.Status, Is.EqualTo("200 Foo Inner Between Outer"));
Assert.That(resultHere1.Status, Is.EqualTo("200 Foo Mapped1 Outer"));
Assert.That(resultHere2.Status, Is.EqualTo("200 Foo Mapped2 Between Outer"));
}
// Avalonia configuration, don't remove; also used by visual designer. private static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure <App>() .UsePlatformDetect() .LogToTrace() .UseReactiveUI();
private static void ConfigureAssetAssembly(AppBuilder builder)
{
AvaloniaLocator.CurrentMutable
.GetService<IAssetLoader>()
.SetDefaultAssembly(typeof(App).Assembly);
}
private static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure <App>().UsePlatformDetect();
public void Method_that_returns_app_action_may_also_be_called()
{
var loader = new StartupLoader();
var configuration = loader.Load("Gate.Builder.Tests.Loader.DefaultConfigurationLoaderTests.Alpha");
var builder = new AppBuilder();
configuration(builder);
var app = builder.Materialize<AppDelegate>();
_alphaCalls = 0;
app(new Dictionary<string, object>(), null, null);
Assert.That(_alphaCalls, Is.EqualTo(1));
}
private static AppBuilder BuildAvaloniaApp()
{
return(AppBuilder.Configure <App>()
.UsePlatformDetect()
.LogToTrace());
}
