public void Get_by_type_should_return_tags_with_inherits()
{
var errList = new TemplateErrors();
var list = new TagsList(errList)
{
new GroupTag {
Name = "val1"
},
new GroupTag {
Name = "val2"
},
new SortTag {
Name = "val3"
},
new ProtectedTag {
Name = "val4"
},
new DescTag {
Name = "val5"
},
new ColsFitTag {
Name = "val6"
}
};
list.GetAll <SortTag>().Select(x => x.Name).Should().BeEquivalentTo("val1", "val2", "val3", "val5");
}
public override object VisitTemplateDefinition([NotNull] LGFileParser.TemplateDefinitionContext context)
{
var startLine = context.Start.Line;
var stopLine = context.Stop.Line;
var templateNameLine = context.templateNameLine().TEMPLATE_NAME_LINE().GetText();
var(templateName, parameters) = ExtractTemplateNameLine(templateNameLine);
if (this.templates.Any(u => u.Name == templateName))
{
var diagnostic = BuildTemplatesDiagnostic(TemplateErrors.DuplicatedTemplateInSameTemplate(templateName), context.templateNameLine());
this.templates.Diagnostics.Add(diagnostic);
}
else
{
var templateBody = context.templateBody().GetText();
var sourceRange = new SourceRange(context, this.templates.Id);
var template = new Template(templateName, parameters, templateBody, sourceRange);
CheckTemplateName(templateName, context.templateNameLine());
CheckTemplateParameters(parameters, context.templateNameLine());
template.TemplateBodyParseTree = CheckTemplateBody(templateName, templateBody, context.templateBody(), startLine);
this.templates.Add(template);
}
return(null);
}
public void TestErrorTemplateName()
{
var diagnostics = GetDiagnostics("ErrorTemplateName.lg");
Assert.Equal(7, diagnostics.Count);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[0].Severity);
Assert.Contains(TemplateErrors.InvalidParameter("param1; param2"), diagnostics[0].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[1].Severity);
Assert.Contains(TemplateErrors.InvalidParameter("param1 param2"), diagnostics[1].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[2].Severity);
Assert.Contains(TemplateErrors.InvalidTemplateName("template3(errorparams"), diagnostics[2].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[3].Severity);
Assert.Contains(TemplateErrors.InvalidParameter("a)test(param1"), diagnostics[3].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[4].Severity);
Assert.Contains(TemplateErrors.InvalidParameter("$%^"), diagnostics[4].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[5].Severity);
Assert.Contains(TemplateErrors.InvalidTemplateName("the-name-of-template"), diagnostics[5].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[6].Severity);
Assert.Contains(TemplateErrors.InvalidTemplateName("t1.1"), diagnostics[6].Message);
}
public void TestEmptyTemplate()
{
var diagnostics = GetDiagnostics("EmptyTemplate.lg");
Assert.AreEqual(1, diagnostics.Count);
Assert.AreEqual(DiagnosticSeverity.Warning, diagnostics[0].Severity);
Assert.IsTrue(diagnostics[0].Message.Contains(TemplateErrors.NoTemplateBody("template")));
}
public override object VisitErrorDefinition([NotNull] LGFileParser.ErrorDefinitionContext context)
{
var lineContent = context.INVALID_LINE().GetText();
if (!string.IsNullOrWhiteSpace(lineContent))
{
this.templates.Diagnostics.Add(BuildTemplatesDiagnostic(TemplateErrors.SyntaxError($"Unexpected content: '{lineContent}'"), context));
}
return(null);
}
private void CheckTemplateParameters(List <string> parameters, LGFileParser.TemplateNameLineContext context)
{
foreach (var parameter in parameters)
{
if (!IdentifierRegex.IsMatch(parameter))
{
var diagnostic = BuildTemplatesDiagnostic(TemplateErrors.InvalidParameter(parameter), context);
this.templates.Diagnostics.Add(diagnostic);
}
}
}
public bool Check(IModel model)
{
ILogger log = XbimLogging.CreateLogger <IfcValidator>();
// check for parser exceptions
var v = new Validator
{
ValidateLevel = ValidationFlags.All,
CreateEntityHierarchy = true
};
SchemaErrors = v.Validate(model.Instances).ToList();
TemplateErrors = CheckPropertyTemplateTypesAndUnits(model).ToList();
PropertyErrors = CheckPropertyUnits(model).ToList();
foreach (var err in
SchemaErrors
.Concat(TemplateErrors)
.Concat(PropertyErrors))
{
var identity = err.Item.GetType().Name;
if (err.Item is IPersistEntity entity)
{
identity = $"#{entity.EntityLabel}={entity.ExpressType.ExpressName}";
}
var msg = new StringBuilder();
msg.AppendLine($"{identity} is invalid.");
var details = new Stack <ValidationResult>(err.Details);
while (details.Any())
{
var detail = details.Pop();
foreach (var d in detail.Details)
{
details.Push(d);
}
var report = detail.Message;
if (string.IsNullOrWhiteSpace(report))
{
report = detail.Report();
}
msg.AppendLine(" " + report);
if (detail.IssueType == ValidationFlags.EntityWhereClauses || detail.IssueType == ValidationFlags.TypeWhereClauses)
{
var source = detail.IssueSource.Split('.')[0].ToLower();
msg.AppendLine($"http://www.buildingsmart-tech.org/ifc/IFC4/Add2/html/link/{source}.htm");
}
}
log.LogError(msg.ToString());
}
return(!SchemaErrors.Any() && !TemplateErrors.Any() && !PropertyErrors.Any());
}
private void CheckTemplateName(string templateName, ParserRuleContext context)
{
var functionNameSplitDot = templateName.Split('.');
foreach (var id in functionNameSplitDot)
{
if (!TemplateNamePartRegex.IsMatch(id))
{
var diagnostic = BuildTemplatesDiagnostic(TemplateErrors.InvalidTemplateName(templateName), context);
this.templates.Diagnostics.Add(diagnostic);
break;
}
}
}
public void TestErrorLine()
{
var diagnostics = GetDiagnostics("ErrorLine.lg");
Assert.Equal(4, diagnostics.Count);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[0].Severity);
Assert.Contains(TemplateErrors.SyntaxError("mismatched input '-' expecting <EOF>"), diagnostics[0].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[1].Severity);
Assert.Contains(TemplateErrors.InvalidStrucName("]"), diagnostics[1].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[2].Severity);
Assert.Contains(TemplateErrors.MissingStrucEnd, diagnostics[2].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[3].Severity);
Assert.Contains(TemplateErrors.InvalidStrucBody("- hi"), diagnostics[3].Message);
}
public void Add_with_same_priority_should_increase_count()
{
var errList = new TemplateErrors();
var list = new TagsList(errList)
{
new GroupTag {
Name = "val1"
},
new GroupTag {
Name = "val2"
}
};
list.Count.Should().Be(2);
}
private LGTemplateParser.BodyContext CheckTemplateBody(string templateName, string templateBody, LGFileParser.TemplateBodyContext context, int startLine)
{
if (string.IsNullOrWhiteSpace(templateBody))
{
var diagnostic = BuildTemplatesDiagnostic(TemplateErrors.NoTemplateBody(templateName), context, DiagnosticSeverity.Warning);
this.templates.Diagnostics.Add(diagnostic);
}
else
{
try
{
return(AntlrParseTemplate(templateBody, startLine));
}
catch (TemplateException e)
{
e.Diagnostics.ToList().ForEach(u => this.templates.Diagnostics.Add(u));
}
}
return(null);
}
public void TestErrorStructuredTemplate()
{
var diagnostics = GetDiagnostics("ErrorStructuredTemplate.lg");
Assert.Equal(8, diagnostics.Count);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[0].Severity);
Assert.Contains(TemplateErrors.InvalidStrucBody("abc"), diagnostics[0].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[1].Severity);
Assert.Contains(TemplateErrors.EmptyStrucContent, diagnostics[1].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[2].Severity);
Assert.Contains("Error occurred when parsing expression 'NOTemplate()'. NOTemplate does not have an evaluator", diagnostics[2].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[3].Severity);
Assert.Contains("Error occurred when parsing expression 'NOTemplate()'. NOTemplate does not have an evaluator", diagnostics[3].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[4].Severity);
Assert.Contains(TemplateErrors.InvalidStrucName("Activity%"), diagnostics[4].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[5].Severity);
Assert.Contains(TemplateErrors.InvalidStrucName("Activity]"), diagnostics[5].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[6].Severity);
Assert.Contains(TemplateErrors.MissingStrucEnd, diagnostics[6].Message);
Assert.Equal(DiagnosticSeverity.Error, diagnostics[7].Severity);
Assert.Contains(TemplateErrors.InvalidStrucBody("- hi"), diagnostics[7].Message);
}
public void Items_should_be_sorted_by_priority()
{
var errList = new TemplateErrors();
var list = new TagsList(errList)
{
new GroupTag {
Name = "val1"
},
new GroupTag {
Name = "val2"
},
new OnlyValuesTag {
Name = "val3"
},
new ProtectedTag {
Name = "val4"
}
};
list.Count.Should().Be(4);
list.Select(x => x.Name).Should().BeEquivalentTo("val3", "val1", "val2", "val4");
}
public void TestDuplicatedTemplates()
{
var diagnostics = GetDiagnostics("DuplicatedTemplates.lg");
Assert.AreEqual(2, diagnostics.Count);
Assert.AreEqual(DiagnosticSeverity.Error, diagnostics[0].Severity);
Assert.IsTrue(diagnostics[0].Message.Contains(TemplateErrors.DuplicatedTemplateInSameTemplate("template1")));
Assert.AreEqual(DiagnosticSeverity.Error, diagnostics[1].Severity);
Assert.IsTrue(diagnostics[1].Message.Contains(TemplateErrors.DuplicatedTemplateInSameTemplate("template1")));
var lgFile = GetTemplates("DuplicatedTemplates.lg");
var allDiagnostics = lgFile.AllDiagnostics;
Assert.AreEqual(4, allDiagnostics.Count);
Assert.AreEqual(DiagnosticSeverity.Error, allDiagnostics[0].Severity);
Assert.IsTrue(allDiagnostics[0].Message.Contains(TemplateErrors.DuplicatedTemplateInSameTemplate("template1")));
Assert.AreEqual(DiagnosticSeverity.Error, allDiagnostics[1].Severity);
Assert.IsTrue(allDiagnostics[1].Message.Contains(TemplateErrors.DuplicatedTemplateInSameTemplate("template1")));
Assert.AreEqual(DiagnosticSeverity.Error, allDiagnostics[2].Severity);
Assert.IsTrue(allDiagnostics[2].Message.Contains("Duplicated definitions found for template: 'basicTemplate'"));
Assert.AreEqual(DiagnosticSeverity.Error, allDiagnostics[3].Severity);
Assert.IsTrue(allDiagnostics[3].Message.Contains("Duplicated definitions found for template: 'basicTemplate2'"));
}
public override object VisitTemplateDefinition([NotNull] LGFileParser.TemplateDefinitionContext context)
{
var startLine = context.Start.Line;
var stopLine = context.Stop.Line;
var templateNameLine = context.templateNameLine().TEMPLATE_NAME_LINE().GetText();
var(templateName, parameters) = ExtractTemplateNameLine(templateNameLine);
if (this.templates.Any(u => u.Name == templateName))
{
var diagnostic = BuildTemplatesDiagnostic(TemplateErrors.DuplicatedTemplateInSameTemplate(templateName), context.templateNameLine());
this.templates.Diagnostics.Add(diagnostic);
}
else
{
var templateBody = context.templateBody().GetText();
var file = context.Parent.Parent as LGFileParser.FileContext;
var isLastTemplate = file.paragraph().Select(u => u.templateDefinition()).Where(u => u != null).Last() == context;
if (!isLastTemplate)
{
templateBody = RemoveTrailingNewline(templateBody);
}
var sourceRange = new SourceRange(context, this.templates.Id);
var template = new Template(templateName, parameters, templateBody, sourceRange);
CheckTemplateName(templateName, context.templateNameLine());
CheckTemplateParameters(parameters, context.templateNameLine());
template.TemplateBodyParseTree = CheckTemplateBody(templateName, templateBody, context.templateBody(), startLine);
this.templates.Add(template);
}
return(null);
}
public void LogErrors(CompilerErrorCollection errors)
{
TemplateErrors.AddRange(errors);
}
public TagsList(TemplateErrors errors) : base(new OptionTagComparer())
{
_errors = errors;
}
