public void DotNetCoreAlias_AddNugetSource_Success() { var feedUrl1 = "testUrl"; var feedUrl2 = "blahUrl"; var feedName2 = "blah"; var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); Assert.IsFalse(SingletonFactory.ExistsInCache(typeof(HelperSettings))); context.AddDotNetCoreHelperNugetSource(feedUrl1); var helperSetting = SingletonFactory.GetHelperSettings(); Assert.IsNotNull(helperSetting); var nugetSources = helperSetting.DotNetCoreSettings.NugetSettings.NugetSources.ToArray(); Assert.AreEqual(2, nugetSources.Length); Assert.IsTrue(nugetSources.Any(t => t.FeedSource == feedUrl1 && string.IsNullOrWhiteSpace(t.FeedName))); context.AddDotNetCoreHelperNugetSource(feedUrl2, config => { config.FeedName = feedName2; }); nugetSources = helperSetting.DotNetCoreSettings.NugetSettings.NugetSources.ToArray(); Assert.AreEqual(3, nugetSources.Length); Assert.IsTrue(nugetSources.Any(t => t.FeedSource == feedUrl1 && string.IsNullOrWhiteSpace(t.FeedName))); Assert.IsTrue(nugetSources.Any(t => t.FeedSource == feedUrl2 && t.FeedName == feedName2)); }
public void TaskHelper_AddTaskDependency_DependentTaskExists() { var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); SingletonFactory.Context = context; var settings = SingletonFactory.GetHelperSettings(); settings.TaskTargetFunc = taskName => { return(new CakeTaskBuilder <ActionTask>(new ActionTask(taskName))); }; var taskHelper = SingletonFactory.GetTaskHelper(); Assert.IsNotNull(taskHelper); var firstTask = taskHelper.AddTask("test"); var nextTask = taskHelper.AddTask("test2"); Assert.AreEqual(0, firstTask.Task.Dependencies.Count); Assert.AreEqual(0, nextTask.Task.Dependencies.Count); taskHelper.AddTaskDependency(firstTask, nextTask); Assert.AreEqual(1, firstTask.Task.Dependencies.Count); Assert.IsTrue(firstTask.Task.Dependencies.Contains("test2")); Assert.AreEqual(0, nextTask.Task.Dependencies.Count); taskHelper.AddTaskDependency(firstTask, nextTask); Assert.AreEqual(1, firstTask.Task.Dependencies.Count); Assert.IsTrue(firstTask.Task.Dependencies.Contains("test2")); Assert.AreEqual(0, nextTask.Task.Dependencies.Count); }
public void Damage(Item?itemUsed, Player player) { if (itemUsed != null && itemUsed == recommendedTool) { curHp -= maxHp; } else { curHp--; } audioSource.Play(); if (curHp <= 0) { if (player != null) { player.AddResource(givenResource, resourceQuantity); SingletonFactory.GetInstance <ParserUtil>().PrintResponse("Added " + resourceQuantity + " " + givenResource + " to inventory"); player.GetAudioSource().clip = SingletonFactory.GetInstance <PrefabUtil>().pickupClip; player.GetAudioSource().Play(); } HideObject(); Invoke("DestroySelf", 1.0f); } else { damageSprite.GetComponent <SpriteRenderer>().sprite = SingletonFactory.GetInstance <PrefabUtil>().damageSprite[maxHp - curHp - 1]; } }
public void GetHelperSettings_Success() { var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); SingletonFactory.Context = context; var settings = SingletonFactory.GetHelperSettings(); Assert.IsNotNull(settings); Assert.IsNotNull(settings.Context); Assert.IsFalse(settings.RunAllDependencies); Assert.IsNotNull(settings.DotNetCoreSettings); Assert.IsNotNull(settings.DotNetCoreSettings.NugetSettings); Assert.IsNotNull(settings.DotNetCoreSettings.NugetSettings.Context); Assert.AreEqual(1, settings.DotNetCoreSettings.NugetSettings.NugetSources.Count()); Assert.IsNotNull(settings.DotNetCoreSettings.BuildSettings); Assert.AreEqual("./BuildTemp", settings.DotNetCoreSettings.BuildSettings.BuildTempFolder); Assert.IsNotNull(settings.DotNetCoreSettings.TestSettings); Assert.AreEqual("./TestTemp", settings.DotNetCoreSettings.TestSettings.TestTempFolder); var newSettings = SingletonFactory.GetHelperSettings(); Assert.AreEqual(settings, newSettings); }
private void GetNextAction() { Vector3 ray = SingletonFactory.GetInstance <Player>().transform.position - transform.position; Direction direction = GetDirectionFromVector(ray); RaycastHit2D hit = GetBlockingObject(direction); if (hit.collider != null) { Obstacle obstacle = hit.collider.GetComponent <Obstacle>(); if (obstacle != null) { verbStack.Add(Verb.USE); directionStack.Add(direction); } else { Player player = hit.collider.GetComponent <Player>(); if (player != null) { verbStack.Add(Verb.USE); directionStack.Add(direction); } } } else { verbStack.Add(Verb.MOVE); directionStack.Add(direction); } }
private void GenerateMap() { for (int x = -maxMapBound; x < maxMapBound + 1; x++) { for (int y = -maxMapBound; y < maxMapBound + 1; y++) { if ((x != 0 || y != 0) && Random.value < 0.1f) { float resourceType = Random.value * 3.0f; GameObject resource; PrefabUtil prefabUtil = SingletonFactory.GetInstance <PrefabUtil>(); if (resourceType < 1.0f) { resource = prefabUtil.treePre; } else if (resourceType < 2.0f) { resource = prefabUtil.stonePre; } else { resource = prefabUtil.ironPre; } Instantiate(resource, new Vector3(x, y, 0), Quaternion.identity); } } } }
public virtual void Damage(Item?equippedItem, Player player) { if (equippedItem != null && equippedItem == recommendedTool) { curHp -= maxHp; } else { curHp--; } audioSource.Play(); if (curHp <= 0) { if (player != null && Random.Range(0.0f, 1.0f) < dropRate) { player.AddItem(givenItem); SingletonFactory.GetInstance <ParserUtil>().PrintResponse("Added " + givenItem + " to inventory"); player.GetAudioSource().clip = SingletonFactory.GetInstance <PrefabUtil>().pickupClip; player.GetAudioSource().Play(); } HideObject(); Invoke("DestroySelf", 1.0f); } }
private bool LoadGame(string fileName) { SingletonFactory <GameController> .Instance.CreateNewGame(); UserInfo info; if (!string.IsNullOrEmpty(fileName)) { fileName = m_DefaultFileName; } if (string.IsNullOrEmpty(fileName)) { fileName = "autosave"; } info = FileUtil.LoadData <UserInfo>(string.Format(".\\{0}.txt", fileName)); if (info != null) { SingletonFactory <UserInfo> .ResetInstance(info); m_DefaultFileName = fileName; return(true); } return(false); }
void Run() { try { do { Token.ThrowIfCancellationRequested(); Instance.Run(); var Factory = SingletonFactory.GetInstance <ThreadFactory>(); Factory.Dispatch(d => d.Run(Instance)); }while (Instance.Loop || Running); } catch (TaskCanceledException) { } catch (OperationCanceledException) { } catch (Exception ex) { LoggerFactory.GetLogger().LogFatal(ex); } finally { Instance.End(); var Factory = SingletonFactory.GetInstance <ThreadFactory>(); Factory.Dispatch(d => d.End(Instance)); } }
public void Craft(Item item, int quantity) { ParserUtil parserUtil = SingletonFactory.GetInstance <ParserUtil>(); ItemUtil itemUtil = SingletonFactory.GetInstance <ItemUtil>(); Dictionary <Resource, int> requiredResources = itemUtil.GetRequiredResources(item); int numCrafted = 0; for (int i = 0; i < quantity; i++) { if (HasRequiredResources(requiredResources)) { foreach (KeyValuePair <Resource, int> requiredResource in requiredResources) { resourceInventory[requiredResource.Key] -= requiredResource.Value; } AddItem(item); numCrafted++; } else { parserUtil.PrintResponse("Not enough resources to craft '" + item.ToString() + "'"); break; } } if (numCrafted > 0) { parserUtil.PrintResponse("Crafted " + numCrafted + " '" + item.ToString() + (numCrafted > 1 ? "s" : "") + "'"); } }
public void DotNetCoreAlias_AddProject_Default_NoTestFilters() { var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); var defaultSln = SolutionFixture.GetDefaultSolution(context.FileSystem); context.AddDotNetCoreProject(defaultSln.SlnFile.Path.FullPath); var helperSetting = SingletonFactory.GetHelperSettings(); Assert.IsNotNull(helperSetting); helperSetting.DotNetCoreSettings.TestSettings.TestProjectNameFilters.Clear(); var projects = helperSetting.DotNetCoreSettings.Projects.ToArray(); Assert.AreEqual(1, projects.Length); Assert.IsTrue(projects.Any(t => t.ProjectAlias == "CakeHelpers")); var slnProj = projects.FirstOrDefault(); Assert.IsNotNull(slnProj); Assert.AreEqual("CakeHelpers", slnProj.ProjectAlias); slnProj.ProjectAlias = "Test"; Assert.AreEqual("Test", slnProj.ProjectAlias); Assert.IsTrue(string.IsNullOrWhiteSpace(slnProj.Configuration)); Assert.IsTrue(string.IsNullOrWhiteSpace(slnProj.Framework)); Assert.IsTrue(string.IsNullOrWhiteSpace(slnProj.Platform)); Assert.AreEqual(2, slnProj.AllProjects.Count()); Assert.AreEqual(2, slnProj.SrcProjects.Count()); Assert.AreEqual(0, slnProj.TestProjects.Count()); }
public void HelperTask_Category_TaskType_Success() { var taskName = "Blah"; var category = "UnitTest"; var taskType = "UnitTest"; var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); var settings = this.GetSettings(context); var task = context.HelperTask(taskName, true, category, taskType); Assert.IsNotNull(task); var taskHelper = SingletonFactory.GetTaskHelper(); Assert.IsNotNull(task); Assert.AreEqual(taskName, task.Task.Name); var helperTask = taskHelper.Tasks.FirstOrDefault(t => t.Task == task.Task); Assert.IsNotNull(helperTask); Assert.AreEqual(taskName, helperTask.TaskName); Assert.AreEqual(true, helperTask.IsTarget); Assert.AreEqual(category, helperTask.Category); Assert.AreEqual(taskType, helperTask.TaskType); }
public void TaskHelper_RunTarget_Task_Success() { var target = "Test Target"; var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); SingletonFactory.Context = context; var settings = SingletonFactory.GetHelperSettings(); var targetRanSuccess = false; settings.TaskTargetFunc = taskName => { return(new CakeTaskBuilder <ActionTask>(new ActionTask(taskName))); }; settings.RunTargetFunc = targ => { targetRanSuccess = targ == target; return(new CakeReport()); }; var targetTaskBuilder = context.HelperTask(target); var taskHelper = SingletonFactory.GetTaskHelper(); Assert.IsNotNull(taskHelper); var helperTask = taskHelper.Tasks.FirstOrDefault(t => t.Task == targetTaskBuilder.Task); Assert.IsNotNull(helperTask); var report = taskHelper.RunTarget(helperTask); Assert.IsNotNull(report); Assert.IsTrue(targetRanSuccess); }
public void TaskHelper_RunTarget_String_Success() { var target = "Test Target"; var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); SingletonFactory.Context = context; var settings = SingletonFactory.GetHelperSettings(); var targetRanSuccess = false; settings.RunTargetFunc = targ => { targetRanSuccess = targ == target; return(new CakeReport()); }; var taskHelper = SingletonFactory.GetTaskHelper(); Assert.IsNotNull(taskHelper); var report = taskHelper.RunTarget(target); Assert.IsNotNull(report); Assert.IsTrue(targetRanSuccess); }
public void TaskHelper_AddTask_ExistsInCache() { var target = "Test Target"; var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); SingletonFactory.Context = context; var settings = SingletonFactory.GetHelperSettings(); var targetRanSuccess = false; settings.TaskTargetFunc = taskName => { return(new CakeTaskBuilder <ActionTask>(new ActionTask(taskName))); }; settings.RunTargetFunc = targ => { targetRanSuccess = targ == target; return(new CakeReport()); }; var taskHelper = SingletonFactory.GetTaskHelper(); Assert.IsNotNull(taskHelper); var firstTask = taskHelper.AddTask(target); Assert.IsNotNull(firstTask); var nextTask = taskHelper.AddTask(target); Assert.IsNotNull(nextTask); Assert.AreEqual(firstTask, nextTask); }
static void Main(string[] args) { ReplacableSingleton replacableSingleton = SingletonFactory.Get(); Client client = new Client(replacableSingleton); client.SetSingleton(replacableSingleton); }
public void HelperSettings_Setup_Success() { var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>()); SingletonFactory.Context = context; var dotNetCoreHelper = SingletonFactory.GetDotNetCoreHelper(); Assert.IsNotNull(dotNetCoreHelper); var coreHelperType = dotNetCoreHelper.GetType(); Assert.IsTrue(SingletonFactory.ExistsInCache(coreHelperType)); SingletonFactory.ClearFactory(); SingletonFactory.Context = context; Assert.IsFalse(SingletonFactory.ExistsInCache(coreHelperType)); var helperSetting = new HelperSettings(); ((DotNetCoreHelperSettings)helperSetting.DotNetCoreSettings).IsActive = true; helperSetting.SetupSetting(); Assert.IsTrue(SingletonFactory.ExistsInCache(coreHelperType)); var newDotNetCoreHelper = SingletonFactory.GetDotNetCoreHelper(); Assert.IsNotNull(newDotNetCoreHelper); Assert.AreNotEqual(dotNetCoreHelper, newDotNetCoreHelper); }
public System.Type GetValueType(string value) { if (SingletonFactory.GetInstance <NumberUtil>().IsNumber(value)) { return(typeof(Number)); } else if (IsValueOfType <Verb>(value)) { return(typeof(Verb)); } else if (IsValueOfType <Item>(value)) { return(typeof(Item)); } else if (IsValueOfType <Resource>(value)) { return(typeof(Resource)); } else if (IsValueOfType <Direction>(value)) { return(typeof(Direction)); } return(typeof(Undefined)); }
// Use this for initialization void Start() { for (int i = 0; i < 20; i++) { Instantiate(SingletonFactory.GetInstance <PrefabUtil>().zombiePre, new Vector3(105, 0, 0), Quaternion.identity); } }
public void DisplayInventory() { ParserUtil parserUtil = SingletonFactory.GetInstance <ParserUtil>(); string inventory = ResourceInventoryToString() + "\n\n" + ItemInventoryToString(); parserUtil.PrintResponse(inventory); }
public void DotNetCoreAlias_BuildHelperSettings_NoContext() { ICakeContext context = null; Assert.IsFalse(SingletonFactory.ExistsInCache(typeof(HelperSettings))); Assert.ThrowsException <ArgumentNullException>(() => context.DotNetCoreBuildHelperSettings()); }
public void SetupSetting() { var coreHelper = SingletonFactory.GetDotNetCoreHelper(); foreach (var projectConfig in this.Projects) { coreHelper.AddProjectConfiguration(projectConfig); } }
/*============================================================================*/ /* Public Functions */ /*============================================================================*/ public void Extend(IContext context) { _injector = context.injector; _singletonFactory = new SingletonFactory(_injector); context.BeforeInitializing(BeforeInitializing); context.BeforeDestroying(BeforeDestroying); }
public void Stop() { Source.Cancel(); Running = false; var Factory = SingletonFactory.GetInstance <ThreadFactory>(); Factory.Dispatch(d => d.Stop(Instance)); }
public static IDotNetCoreTestHelperSettings DotNetCoreTestHelperSettings(this ICakeContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } SingletonFactory.Context = context; return(SingletonFactory.GetHelperSettings().DotNetCoreSettings.TestSettings); }
public void Build_returns_instance_that_has_default_constructor() { var builder = new SingletonFactory(); var container = Mock.Of <IContainer>(); var instance = builder.BuildUpService(typeof(Calculator), container); Assert.NotNull(instance); Assert.IsAssignableFrom <ICalculator>(instance); }
public void Build_returns_instance_that_has_primative_parameters_only() { var builder = new SingletonFactory(); var container = Mock.Of <IContainer>(); var instance = builder.BuildUpService(typeof(ConcreteClass), container); Assert.NotNull(instance); Assert.IsAssignableFrom <BaseClass>(instance); }
public static ITaskHelper TaskHelper(this ICakeContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } SingletonFactory.Context = context; return(SingletonFactory.GetTaskHelper()); }
public void ItshouldReturnSameInstance() { constructorResolver.Setup(r => r.GetConstructor(It.IsAny <Type>())).Returns(ParameterlessClass.GetParameterlessConstructor()).Verifiable(); dependencyResolver.Setup(r => r.Resolve(It.IsAny <ConstructorInfo>())).Returns(new object[] { }); var factory = new SingletonFactory(typeof(ParameterlessClass), constructorResolver.Object, dependencyResolver.Object); var object1 = factory.Build(); var object2 = factory.Build(); Assert.Same(object1, object2); }
public void Equip(Item item) { if (HasSpecifiedItem(item)) { equippedItem = item; SingletonFactory.GetInstance <ParserUtil>().PrintResponse("Equipped '" + item.ToString() + "'"); } else { SingletonFactory.GetInstance <ParserUtil>().PrintResponse("No '" + item.ToString() + "' in inventory"); } }
public void SingletonFactoryShouldCreateTheSameInstanceOnce() { var factory = new SingletonFactory<ISerializable>(createInstance); var container = new ServiceContainer(); var request = new FactoryRequest() { ServiceName = null, Arguments = new object[0], Container = container, ServiceType = typeof(ISerializable) }; ISerializable first = factory.CreateInstance(request); ISerializable second = factory.CreateInstance(request); // Both instances must be the same Assert.AreSame(first, second); Assert.IsNotNull(first); Assert.IsNotNull(second); }