public async Task LoadRulesShouldNotLoadUnconstructableRules() { // Arrange var config = new ConfigBuilder() .WithProperty(new PropertyRuleData()) .WithPackage(new PackageReferenceRuleData()) .WithProjectReference(new ProjectReferenceRuleData()) .ToString(); using var file = new TempFile(); await File.WriteAllTextAsync(file, config); var rulesFactory = Substitute.For <IRuleFactory>(); rulesFactory.Construct(Arg.Any <PackageReferenceRuleData>()).Returns((IRule?)null); rulesFactory.Construct(Arg.Any <PropertyRuleData>()).Returns((IRule?)null); rulesFactory.Construct(Arg.Any <ProjectReferenceRuleData>()).Returns((IRule?)null); var output = Substitute.For <IOutput>(); var sut = new RulesLoader(rulesFactory, output); // Act var actual = await sut.LoadRules(file).ToListAsync(); // Assert Assert.Empty(actual); rulesFactory.Received(1).Construct(Arg.Any <PropertyRuleData>()); rulesFactory.Received(1).Construct(Arg.Any <PackageReferenceRuleData>()); rulesFactory.Received(1).Construct(Arg.Any <ProjectReferenceRuleData>()); }
public async Task LoadRulesShouldOnlyReturnPackagesWhenOnlyGivenPackages() { // Arrange var config = new ConfigBuilder() .WithPackage("package1", "1.2") .WithPackage("package2", "0.3") .ToString(); using var file = new TempFile(); await File.WriteAllTextAsync(file, config); var rulesFactory = Substitute.For <IRuleFactory>(); rulesFactory.Construct(Arg.Any <PackageReferenceRuleData>()).Returns(Substitute.For <IRule>()); var output = Substitute.For <IOutput>(); var sut = new RulesLoader(rulesFactory, output); // Act var actual = await sut.LoadRules(file).ToListAsync(); // Assert Assert.Equal(2, actual.Count); rulesFactory.Received(2).Construct(Arg.Any <PackageReferenceRuleData>()); rulesFactory.DidNotReceive().Construct(Arg.Any <PropertyRuleData>()); rulesFactory.DidNotReceive().Construct(Arg.Any <ProjectReferenceRuleData>()); }
public Unit() { name = "Nameless Unit"; attrs = RulesLoader.GetAttributesDict(); stats = RulesLoader.GetStatsDict(); //test damage = Damage(); }
public SecondaryAttribute(string n, string a, string[] c, int mv, int cv) { name = n; attr = a; calc = c; maxValue = mv; curValue = cv; minAttr = RulesLoader.GetMinAttribute(attr); //Debug.Log("Min Attr of "+name+" is "+ minAttr); }
public void Read_Active_Rules() { var rulesLoader = new RulesLoader(CFamilyHelper.CFamilyFilesDirectory); rulesLoader.ReadActiveRulesList().Should().HaveCount(255); // unexpanded list of active rules rulesMetadataCache.GetRulesConfiguration("c").ActivePartialRuleKeys.Should().HaveCount(Active_C_Rules); rulesMetadataCache.GetRulesConfiguration("cpp").ActivePartialRuleKeys.Should().HaveCount(Active_CPP_Rules); // We don't currently support ObjC rules in VS rulesMetadataCache.GetRulesConfiguration("objc").Should().BeNull(); }
private static RulesLoader CreateTestSubject() { var resourcesPath = Path.Combine( Path.GetDirectoryName(typeof(RulesLoaderTest).Assembly.Location), "CFamily", "TestResources", "RulesLoader"); Directory.Exists(resourcesPath).Should().BeTrue($"Test setup error: expected test resources directory does not exist: {resourcesPath}"); var rulesLoader = new RulesLoader(resourcesPath); return(rulesLoader); }
public async Task LoadRulesShouldBeEmptyForEmptyFile() { // Arrange using var file = new TempFile(); var rulesFactory = Substitute.For <IRuleFactory>(); var output = Substitute.For <IOutput>(); var sut = new RulesLoader(rulesFactory, output); // Act var actual = await sut.LoadRules(file).ToListAsync(); // Assert Assert.Empty(actual); }
public async Task LoadRulesShouldNotThrowWhenFileDoesNotExist() { // Arrange var rulesFactory = Substitute.For <IRuleFactory>(); var output = Substitute.For <IOutput>(); var sut = new RulesLoader(rulesFactory, output); // Act var ex = await Record.ExceptionAsync(async() => await sut.LoadRules(new FileInfo("non.existing")).ToListAsync()); // Assert Assert.Null(ex); output.ReceivedWithAnyArgs(2).Error(null !); }
private static Task <int> Main(string[] args) { var rootCommand = new RootCommand { new Option <FileInfo>("--config", "Path to a configuration that defines how validation will occur.") { IsRequired = true, AllowMultipleArgumentsPerToken = false, Argument = new Argument <FileInfo> { Arity = ArgumentArity.ExactlyOne } }.ExistingOnly(), new Option <FileInfo[]>("--project", "Path to a Visual Studio solution or project files that should be validated. Can be specified multiple times") { IsRequired = true, AllowMultipleArgumentsPerToken = true, Argument = new Argument <FileInfo[]> { Arity = ArgumentArity.OneOrMore } }.ExistingOnly(), new Option <bool>("--verbose", description: "Verbose output of progress", getDefaultValue: () => false), new Option <bool>("--silent", description: "Don't output anything on stdout", getDefaultValue: () => false) }; rootCommand.Description = "Validator for Visual Studio projects"; rootCommand.Handler = CommandHandler.Create( async(FileInfo config, FileInfo[] project, bool verbose, bool silent, IConsole console) => { var logger = new Output(console, silent, verbose); var rulesFactory = new RuleFactory(); var rulesLoader = new RulesLoader(rulesFactory, logger); var rules = await rulesLoader.LoadRules(config).ToListAsync(); var projectLoader = new ProjectLoader(logger); var validator = new Validator(rules, projectLoader, logger); return(await validator.Validate(project)); }); return(rootCommand.InvokeAsync(args)); }
// Use this for initialization public Player() { //ExpressionSolver solver = new ExpressionSolver(); //solver.SetGlobalVariable("Strength", strength); //string expr = "sqrt(Strength * 2)"; //float result = (float) solver.EvaluateExpression(expr); //Debug.Log("Damage is "+expr+" = "+result); PlayingCard[] testdeck = RulesLoader.GetPregenCards().ToArray(); deck = new CardDeck(testdeck, RulesLoader.deckSize); hand = new PlayingCard[RulesLoader.handSize]; units = new Unit[RulesLoader.unitNumber]; for (int i = 0; i < units.Length; i++) { units[i] = new Unit(); units[i].name = "Unit " + i; } }
private static async Task <bool> Validate(IDictionary <string, RuleDefinition> rules, GetRuleParser parserResolver) { var parsingTask = Task.Run(() => { try { RulesLoader.Parse(rules, parserResolver); return(true); } catch (Exception) { return(false); } }); var dependencyCheckingTask = Task.Run(() => !DependencyChecker.HasCircularDependencies(rules)); await Task.WhenAll(parsingTask, dependencyCheckingTask); return((await parsingTask) && (await dependencyCheckingTask)); }
// Use this for initialization void Awake() { if (instance == null) { instance = this; } else { Destroy(gameObject); Debug.LogError("An instance of RulesLoader already exists"); } settingsPath = Application.dataPath + "/Settings/"; //#if UNITY_STANDALONE_WIN // path = path.Replace('/', '\\'); //#endif //#if !UNITY_EDITOR //FirstRun(); //rules = Rules.Load(File.ReadAllText(settingsPath+"_rules.xml")); //#else rules = Rules.Load(Resources.Load <TextAsset>("Rules").text); //#endif }
public static async Task <ITweek> Create(IRulesDriver rulesDriver, GetRuleParser parserResolver) { var rulesLoader = await RulesLoader.Factory(rulesDriver, parserResolver); return(new TweekRunner(rulesLoader)); }