public void Checks_syntax_errors(string[] sourceCode, int syntaxErrorCount)
{
CodeModelFactory factory = new CodeModelFactory();
var project = factory.CreateProject(sourceCode);
project.SyntaxErrors.Count.ShouldBe(syntaxErrorCount);
}
public SmellDetectorService()
{
_codeModelFactory = new CodeModelFactory();
_detectors = new List <IDetector>
{
new ClassMetricRuleEngine()
};
}
public void Ignores_partial_classes()
{
CodeModelFactory factory = new CodeModelFactory();
var classes = factory.CreateProject(_testDataFactory.GetTwoPartialClassesWithSameFullName()).Classes;
classes.Count.ShouldBe(0);
}
public void Evaluates_solution_submission(string[] submissionAttempt, List <ChallengeHint> expectedHints)
{
var project = new CodeModelFactory().CreateProject(submissionAttempt);
var challengeEvaluation = _basicMetricChecker.EvaluateSubmission(project.Classes);
var actualHints = challengeEvaluation.GetHints();
actualHints.Count.ShouldBe(expectedHints.Count);
actualHints.All(expectedHints.Contains).ShouldBeTrue();
}
public void Calculates_number_of_return_statements_in_class()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetCodeBlocksClass()).Classes;
var firstClass = classes.First();
firstClass.Metrics[CaDETMetric.CNOR].ShouldBe(3);
}
public void Calculates_number_of_protected_fields_in_class()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetCodeBlocksClass()).Classes;
var firstClass = classes.First();
firstClass.Metrics[CaDETMetric.NOPF].ShouldBe(2);
}
private CaDETProject BuildCaDETModel(string[] sourceCode)
{
var solutionAttempt = new CodeModelFactory().CreateProject(sourceCode);
if (solutionAttempt.Classes == null || solutionAttempt.Classes.Count == 0)
{
throw new InvalidOperationException("Invalid submission.");
}
return(solutionAttempt);
}
public void Calculates_max_nested_blocks_in_class()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetCodeBlocksClass()).Classes;
var firstClass = classes.First();
firstClass.Metrics[CaDETMetric.CMNB].ShouldBe(4);
}
public void Calculates_weighted_methods_per_class()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetGitAdapterClassText()).Classes;
var gitClass = classes.First();
gitClass.Metrics[CaDETMetric.WMC].ShouldBe(17);
}
public void Calculates_number_of_lambda_expressions()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetCodeBlocksClass()).Classes;
var firstClass = classes.First();
firstClass.FindMember("CSharpCodeParserInit").Metrics[CaDETMetric.NOLE].ShouldBe(0);
firstClass.FindMember("CreateClassMemberBuilders2").Metrics[CaDETMetric.NOLE].ShouldBe(2);
}
public void Calculates_number_of_local_variables()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetGitAdapterClassText()).Classes;
var gitClass = classes.First();
gitClass.FindMember("CheckForNewCommits").Metrics[CaDETMetric.NOLV].ShouldBe(2);
gitClass.FindMember("GetActiveCommit").Metrics[CaDETMetric.NOLV].ShouldBe(0);
}
public void Calculates_member_effective_lines_of_code()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetEffectiveLinesOfCodeTest()).Classes;
var doctor = classes.First();
doctor.FindMember("Doctor").Metrics[CaDETMetric.MELOC].ShouldBe(1);
doctor.FindMember("IsAvailable").Metrics[CaDETMetric.MELOC].ShouldBe(2);
}
public void Calculates_method_cyclomatic_complexity()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetGitAdapterClassText()).Classes;
var gitClass = classes.First();
gitClass.FindMember("CheckoutCommit").Metrics[CaDETMetric.CYCLO].ShouldBe(2);
gitClass.FindMember("ParseDocuments").Metrics[CaDETMetric.CYCLO].ShouldBe(4);
}
public void Calculates_number_of_unique_words()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetCodeBlocksClass()).Classes;
var gitClass = classes.First();
gitClass.FindMember("CSharpCodeParserInit").Metrics[CaDETMetric.NOUW].ShouldBe(5);
gitClass.FindMember("CreateClassMemberBuilders1").Metrics[CaDETMetric.NOUW].ShouldBe(22);
gitClass.FindMember("CreateClassMemberBuilders2").Metrics[CaDETMetric.NOUW].ShouldBe(33);
}
public void Calculates_invoked_methods_in_a_class()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetMultipleClassTexts()).Classes;
var dateRange = classes.Find(c => c.Name.Equals("DateRange"));
var service = classes.Find(c => c.Name.Equals("DoctorService"));
dateRange.Metrics[CaDETMetric.RFC].ShouldBe(0);
service.Metrics[CaDETMetric.RFC].ShouldBe(4);
}
public void Calculates_lack_of_cohesion()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetCohesionClasses()).Classes;
var dateRange = classes.Find(c => c.Name.Equals("DateRange"));
var doctor = classes.Find(c => c.Name.Equals("Doctor"));
dateRange.Metrics[CaDETMetric.LCOM].ShouldBe(0);
doctor.Metrics[CaDETMetric.LCOM].ShouldBe(0.75);
}
public void Calculates_lines_of_code_for_CSharp_class_elements()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetDoctorClassText()).Classes;
var doctorClass = classes.First();
doctorClass.Metrics[CaDETMetric.CLOC].ShouldBe(22);
doctorClass.FindMember("Email").Metrics[CaDETMetric.MLOC].ShouldBe(1);
doctorClass.FindMember("IsAvailable").Metrics[CaDETMetric.MLOC].ShouldBe(8);
}
public void Create_code_model_with_links(string folderLocation)
{
CodeModelFactory factory = new CodeModelFactory();
var project = factory.CreateProjectWithCodeFileLinks(folderLocation);
var classes = project.Classes.Select(c => c.FullName);
var members = project.Classes.SelectMany(c => c.Members).Select(m => m.Signature());
var keys = project.CodeLinks.Keys.ToList();
var difference = classes.Union(members).Except(keys);
difference.ShouldBeEmpty();
}
public void Calculates_max_nested_blocks()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetCodeBlocksClass()).Classes;
var firstClass = classes.First();
firstClass.FindMember("CSharpCodeParserInit").Metrics[CaDETMetric.MMNB].ShouldBe(0);
firstClass.FindMember("CreateClassMemberBuilders1").Metrics[CaDETMetric.MMNB].ShouldBe(2);
firstClass.FindMember("CreateClassMemberBuilders2").Metrics[CaDETMetric.MMNB].ShouldBe(4);
firstClass.FindMember("CreateClassMemberBuilders3").Metrics[CaDETMetric.MMNB].ShouldBe(4);
}
public void Calculates_number_of_parameters()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetGitAdapterClassText()).Classes;
var gitClass = classes.First();
gitClass.FindMember("CheckForNewCommits").Metrics[CaDETMetric.NOP].ShouldBe(0);
gitClass.FindMember("PullChanges").Metrics[CaDETMetric.NOP].ShouldBe(0);
gitClass.FindMember("GetCommits").Metrics[CaDETMetric.NOP].ShouldBe(1);
gitClass.FindMember("CheckoutCommit").Metrics[CaDETMetric.NOP].ShouldBe(1);
}
public void Calculates_array_element_accessed_accessor()
{
//CURRENTLY NOT SUPPORTED - ergo tests fail.
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetMultipleClassTexts()).Classes;
var doctor = classes.Find(c => c.Name.Equals("Doctor"));
var service = classes.Find(c => c.Name.Equals("DoctorService"));
var holidayDates = doctor.FindMember("HolidayDates");
var logChecked = service.FindMember("LogChecked");
logChecked.AccessedAccessors.ShouldContain(holidayDates);
}
public void Calculates_tight_class_cohesion()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetTCCMultipleClassTexts()).Classes;
var class6 = classes.Find(c => c.Name.Equals("Class6"));
var class7 = classes.Find(c => c.Name.Equals("Class7"));
var class8 = classes.Find(c => c.Name.Equals("Class8"));
class6.Metrics[CaDETMetric.TCC].ShouldBe(0.67);
class7.Metrics[CaDETMetric.TCC].ShouldBe(0.5);
class8.Metrics[CaDETMetric.TCC].ShouldBe(0.5);
}
public void Calculates_number_of_dependencies_in_class()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetMultipleClassTexts()).Classes;
var dataRange = classes.Find(c => c.Name.Equals("DateRange"));
var doctor = classes.Find(c => c.Name.Equals("Doctor"));
var doctorService = classes.Find(c => c.Name.Equals("DoctorService"));
dataRange.Metrics[CaDETMetric.CBO].ShouldBe(2);
doctor.Metrics[CaDETMetric.CBO].ShouldBe(2);
doctorService.Metrics[CaDETMetric.CBO].ShouldBe(2);
}
public void Determines_if_is_data_class()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetMultipleClassTexts()).Classes;
var doctor = classes.Find(c => c.Name.Equals("Doctor"));
var service = classes.Find(c => c.Name.Equals("DoctorService"));
var dateRange = classes.Find(c => c.Name.Equals("DateRange"));
dateRange.IsDataClass().ShouldBeFalse();
doctor.IsDataClass().ShouldBeFalse();
service.IsDataClass().ShouldBeFalse();
}
public void Build_code_model_from_repository()
{
CodeModelFactory factory = new CodeModelFactory();
var project = factory.CreateProject("C:/repo");
project.Classes.ShouldNotBeEmpty();
CaDETClass conflict = project.Classes.Find(c => c.FullName.Equals("LibGit2Sharp.Conflict"));
conflict.ShouldNotBeNull();
conflict.Fields.ShouldContain(f => f.Name.Equals("ancestor"));
conflict.Fields.ShouldContain(f => f.Name.Equals("ours"));
conflict.Fields.ShouldContain(f => f.Name.Equals("theirs"));
conflict.Members.ShouldContain(m =>
m.Name.Equals("Conflict") && m.Type.Equals(CaDETMemberType.Constructor) && m.AccessedFields.Count == 3);
conflict.Members.ShouldContain(m =>
m.Name.Equals("Equals") && m.Type.Equals(CaDETMemberType.Method) && m.AccessedFields.Count == 1);
conflict.Metrics[CaDETMetric.CLOC].ShouldBe(108);
conflict.Metrics[CaDETMetric.LCOM].ShouldBe(0.833);
conflict.Metrics[CaDETMetric.NAD].ShouldBe(4);
conflict.Metrics[CaDETMetric.NMD].ShouldBe(3);
conflict.Metrics[CaDETMetric.WMC].ShouldBe(8);
CaDETClass certificate = project.Classes.Find(c => c.FullName.Equals("LibGit2Sharp.Certificate"));
certificate.ShouldNotBeNull();
certificate.Members.ShouldBeEmpty();
certificate.Fields.ShouldBeEmpty();
certificate.Metrics[CaDETMetric.LCOM].ShouldBe(-1);
certificate.Metrics[CaDETMetric.CLOC].ShouldBe(3);
certificate.Metrics[CaDETMetric.NAD].ShouldBe(0);
certificate.Metrics[CaDETMetric.NMD].ShouldBe(0);
certificate.Metrics[CaDETMetric.WMC].ShouldBe(0);
CaDETClass handles =
project.Classes.Find(c => c.FullName.Equals("LibGit2Sharp.Core.Handles.Libgit2Object"));
handles.ShouldNotBeNull();
handles.Fields.ShouldContain(f => f.Name.Equals("ptr"));
handles.Members.ShouldContain(m => m.Name.Equals("Handle") && m.Type.Equals(CaDETMemberType.Property));
handles.Members.ShouldContain(m => m.Name.Equals("Dispose") && m.Type.Equals(CaDETMemberType.Method) &&
m.InvokedMethods.Count == 1 &&
m.AccessedFields.Count == 0 &&
m.AccessedAccessors.Count == 0);
handles.Metrics[CaDETMetric.LCOM].ShouldBe(0.667);
handles.Metrics[CaDETMetric.CLOC].ShouldBe(100);
handles.Metrics[CaDETMetric.NAD].ShouldBe(3);
handles.Metrics[CaDETMetric.NMD].ShouldBe(4);
handles.Metrics[CaDETMetric.WMC].ShouldBe(10);
}
public void Establishes_correct_class_hierarchy()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetClassesWithHierarchy()).Classes;
var doctor = classes.Find(c => c.Name.Equals("Doctor"));
var employee = classes.Find(c => c.Name.Equals("Employee"));
var entity = classes.Find(c => c.Name.Equals("Entity"));
doctor.Parent.ShouldBe(employee);
employee.Parent.ShouldBe(entity);
entity.Parent.ShouldBeNull();
doctor.FindMember("Doctor").AccessedAccessors.ShouldContain(employee.FindMember("Email"));
employee.FindMember("Employee").AccessedAccessors.ShouldContain(entity.FindMember("Id"));
}
public void Checks_method_signature()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetMultipleClassTexts()).Classes;
var doctor = classes.Find(c => c.Name.Equals("Doctor"));
var dateRange = classes.Find(c => c.Name.Equals("DateRange"));
var service = classes.Find(c => c.Name.Equals("DoctorService"));
var holidayDates = doctor.FindMember("HolidayDates");
var overlapsWith = dateRange.FindMember("OverlapsWith");
var findDoctors = service.FindMember("FindAvailableDoctor");
holidayDates.Signature().Equals("HolidayDates");
overlapsWith.Signature().Equals("OverlapsWith(DoctorApp.Model.Data.DateR.DateRange)");
findDoctors.Signature().Equals("FindAvailableDoctor(DoctorApp.Model.Data.DateR.DateRange)");
}
public void Create_code_model_with_links_on_large_repo()
{
CodeModelFactory factory = new CodeModelFactory();
var project = factory.CreateProjectWithCodeFileLinks("C:/repo");
var projectClassesAndMembersCount = project.Classes.Count + project.Classes.Sum(c => c.Members.Count);
project.CodeLinks.Count.ShouldBe(projectClassesAndMembersCount);
project.CodeLinks.TryGetValue("LibGit2Sharp.ObjectDatabase", out var locationLink);
locationLink.StartLoC.ShouldBe(17);
locationLink.EndLoC.ShouldBe(1091);
project.CodeLinks.TryGetValue("LibGit2Sharp.ObjectDatabase.RevertCommit(LibGit2Sharp.Commit, LibGit2Sharp.Commit, int, LibGit2Sharp.MergeTreeOptions)", out locationLink);
locationLink.StartLoC.ShouldBe(1026);
locationLink.EndLoC.ShouldBe(1090);
project.CodeLinks.TryGetValue("LibGit2Sharp.MergeTreeOptions.MergeTreeOptions()", out locationLink);
locationLink.StartLoC.ShouldBe(15);
locationLink.EndLoC.ShouldBe(16);
}
public void Checks_method_linked_return_types()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetMultipleClassTexts()).Classes;
List <CaDETClass> otherClasses = factory.CreateProject(_testDataFactory.GetClassesFromDifferentNamespace()).Classes;
var dateRange = classes.Find(c => c.Name.Equals("DateRange"));
var doctor = classes.Find(c => c.Name.Equals("Doctor"));
var doctorService = classes.Find(c => c.Name.Equals("DoctorService"));
var otherDoctor = otherClasses.Find(c => c.Name.Equals("Doctor"));
var otherDateRange = otherClasses.Find(c => c.Name.Equals("DateRange"));
doctor.FindMember("TestFunction").GetLinkedReturnTypes().ShouldContain(dateRange);
doctor.FindMember("TestFunction").GetLinkedReturnTypes().ShouldNotContain(otherDateRange);
doctorService.FindMember("FindAvailableDoctor").GetLinkedReturnTypes().ShouldContain(doctor);
doctorService.FindMember("FindAvailableDoctor").GetLinkedReturnTypes().ShouldNotContain(otherDoctor);
}
public void Calculates_access_to_foreign_data()
{
CodeModelFactory factory = new CodeModelFactory();
List <CaDETClass> classes = factory.CreateProject(_testDataFactory.GetATFDMultipleClassTexts()).Classes;
var class1 = classes.Find(c => c.Name.Equals("Class1"));
var class3 = classes.Find(c => c.Name.Equals("Class3"));
var class5 = classes.Find(c => c.Name.Equals("Class5"));
var class7 = classes.Find(c => c.Name.Equals("Class7"));
var class9 = classes.Find(c => c.Name.Equals("Class9"));
class1.Metrics[CaDETMetric.ATFD].ShouldBe(2);
class3.Metrics[CaDETMetric.ATFD].ShouldBe(1);
class5.Metrics[CaDETMetric.ATFD].ShouldBe(1);
class7.Metrics[CaDETMetric.ATFD].ShouldBe(3);
class9.Metrics[CaDETMetric.ATFD].ShouldBe(2);
}