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