private void VisitForStatement_Init(IForInitializer init, IKaVEList <IStatement> forInit, IList <IStatement> body) { if (init == null) { return; } // case 1: single declaration var isDeclaration = init.Declaration != null; if (isDeclaration) { var decl = init.Declaration.Declarators[0]; decl.Accept(this, forInit); } // case 2: multiple statements var hasStatements = init.Expressions.Count > 0; if (hasStatements) { foreach (var expr in init.ExpressionsEnumerable) { expr.Accept(this, forInit); } } }
public void Setup() { _actualProcessedZips = Sets.NewHashSet <string>(); _actualGroupedIds = null; _actualGroups = Lists.NewList <IKaVESet <string> >(); _actualCleanedZips = Lists.NewList <string>(); _io = Mock.Of <IPreprocessingIo>(); Mock.Get(_io).Setup(io => io.FindRelativeZipPaths()).Returns(GetExpectedZips()); Mock.Get(_io) .Setup(io => io.GetFullPath_In(It.IsAny <string>())) .Returns <string>(relZip => "<dirIn>\\" + relZip); Mock.Get(_io) .Setup(io => io.GetFullPath_Merged(It.IsAny <string>())) .Returns <string>(relZip => "<dirMerged>\\" + relZip); Mock.Get(_io) .Setup(io => io.GetFullPath_Out(It.IsAny <string>())) .Returns <string>(relZip => "<dirOut>\\" + relZip); _log = Mock.Of <IMultiThreadedPreprocessingLogger>(); Mock.Get(_log) .Setup(l => l.Error(It.IsAny <int>(), It.IsAny <Exception>())) .Callback <int, Exception>((taskId, ex) => _lastLoggedException = ex); _sut = new MultiThreadedPreprocessing( _io, _log, NumWorker, IdReaderFactory, CreateGrouper(), GroupMergerFactory, CleanerFactory); }
public void Run() { _upes = Lists.NewList <IUserProfileEvent>(); var users = Sets.NewHashSet <string>(); _keys = Sets.NewHashSet <string>(); _assignableSubmissions = Sets.NewHashSet <string>(); var zips = _io.FindCcZips().ToList(); var cur = 1; var total = zips.Count; foreach (var zipName in zips) { _printer.StartZip(zipName, cur++, total); var userKey = GetUserKey(zipName); users.Add(userKey); _printer.FoundUserKey(userKey); var zipKeys = GetKeysFrom(zipName); _printer.FoundKeysInZip(zipKeys); foreach (var key in zipKeys) { var combKey = string.Format("{0}\t{1}", key, userKey); _keys.Add(combKey); } } _printer.FoundUsers(users); _printer.FoundKeys(_keys); _printer.FoundUpes(_upes); _printer.FoundAssignableZips(_assignableSubmissions); }
public void Visit(IKaVEList <IStatement> stmts, TContext context) { foreach (var stmt in stmts) { stmt.Accept(this, context); } }
protected void AssertBody(IKaVEList <IStatement> body) { Assert.AreEqual(1, ResultSST.Methods.Count); var m = ResultSST.Methods.First(); AssertBody(m, body); }
public void Export(string rootDir) { var exports = _io.FindExports(); _profiles = Lists.NewList <UserProfileEvent>(); _days = new HashSet <string>(); _helper.LogFoundExports(exports.Count); var fileCounter = 0; foreach (var exportZip in exports) { _helper.LogOpenExport(exportZip); var hasUserProfile = false; foreach (var up in _io.ReadEvents(exportZip)) { RegisterKey(fileCounter, up); var userProfileEvent = up as UserProfileEvent; if (userProfileEvent != null) { hasUserProfile = true; _profiles.Add(userProfileEvent); } } _helper.LogResult(hasUserProfile); fileCounter++; } _helper.LogNumberDays(fileCounter, _days.Count); _helper.LogUserProfiles(_profiles); }
private static void AddCommaIfNotLast <T>(T node, IKaVEList <T> list, SSTPrintingContext c) where T : ISSTNode { if (!ReferenceEquals(node, list.Last())) { c.Text(", "); } }
public virtual void LogUserProfiles(IKaVEList <UserProfileEvent> profiles) { foreach (var profile in profiles) { Console.WriteLine(@"----------------------------"); Console.WriteLine(profile.ToFormattedJson()); } }
private void Fire(IKaVEList <IVersionControlAction> content, ISolutionName solutionName) { var gitEvent = Create <VersionControlEvent>(); gitEvent.Solution = solutionName; gitEvent.Actions = content; FireNow(gitEvent); }
public TestGitEventGenerator([NotNull] IRSEnv env, [NotNull] IMessageBus messageBus, [NotNull] IDateUtils dateUtils, [NotNull] IThreading threading) : base(env, messageBus, dateUtils, threading) { Content = Lists.NewList <string>(); }
public GitEventGenerator([NotNull] IRSEnv env, [NotNull] IMessageBus messageBus, [NotNull] IDateUtils dateUtils, [NotNull] IThreading threading) : base(env, messageBus, dateUtils, threading) { _oldActions = Lists.NewList <VersionControlAction>(); }
protected void AssertStrings <T>(IKaVEList <string> parameters, IList <T> parameterNames) where T : IName { Assert.AreEqual(parameters.Count, parameterNames.Count); for (var i = 0; i < parameters.Count; i++) { Assert.AreEqual(parameters[i], parameterNames[i].Identifier); } }
private void WriteEvents(IKaVEList <Event> events) { var streamFileName = Path.Combine(_dirEvents, "eventstream.txt"); var streamFile = new StreamWriter(streamFileName, false); var setFileName = Path.Combine(_dirEvents, "eventMapping.txt"); var setFile = new StreamWriter(setFileName, false); Console.WriteLine("stream contains {0} events", events.Count); var uniqueEvents = new HashSet <Event>(); var eventList = new List <Event>(); var isFirstMethod = true; var time = 0.000; foreach (var e in events) { if (!uniqueEvents.Contains(e)) { uniqueEvents.Add(e); eventList.Add(e); } var idx = eventList.IndexOf(e); if (e.Kind == EventKind.MethodDeclaration && !isFirstMethod) { time += EventStreamTimeout; } isFirstMethod = false; streamFile.Write("{0},{1:0.000}\n", idx, time); time += EventStreamDelta; } streamFile.Close(); setFile.WriteLine('['); var isFirst = true; foreach (var e in eventList) { if (!isFirst) { setFile.WriteLine(','); } setFile.Write(e.ToCompactJson()); isFirst = false; } setFile.WriteLine(); setFile.WriteLine(']'); // -> write eventList setFile.Close(); Console.WriteLine("finished"); }
public void Setup() { _foundIds = Lists.NewList <IEnumerable <string> >(); _log = Mock.Of <IIdReaderLogger>(); Mock.Get(_log) .Setup(l => l.FoundIds(It.IsAny <IEnumerable <string> >())) .Callback <IEnumerable <string> >(s => _foundIds.Add(s)); _sut = new IdReader(_log); }
private int Visit(IKaVEList <IStatement> body, int context) { int size = 0; foreach (var stmt in body) { size += stmt.Accept(this, 0); } return(size); }
public void FoundUpes(IKaVEList <IUserProfileEvent> upes) { var total = upes.Count; var i = 1; Console.WriteLine(@"#### upes:"); foreach (var key in upes) { Console.WriteLine(@"{0}/{1}: {2}", i++, total, key); } Console.WriteLine(); }
protected void AssertBody(IMethodDeclaration method, IKaVEList <IStatement> body) { if (!body.Equals(method.Body)) { Console.WriteLine("AssertBody failed!"); Console.WriteLine("\n-- expected body --\n"); Console.WriteLine(body.ToString()); Console.WriteLine("\n-- actual body --\n"); Console.WriteLine(method.Body.ToString()); Assert.Fail(); } }
private static Query Find(Tuple <CoReMethodName, CoReTypeName> key, IKaVEList <Query> usages) { foreach (var usage in usages) { var isMethod = usage.methodCtx.Equals(key.Item1); var isType = usage.type.Equals(key.Item2); if (isMethod && isType) { return(usage); } } return(null); }
private void AppendPropertyAccessor(SSTPrintingContext c, IKaVEList <IStatement> body, string keyword) { if (body.Any()) { c.Indentation().Text(keyword); c.StatementBlock(body, this); } else { c.Indentation().Text(keyword).Text(";"); } c.NewLine(); }
public override void VisitSwitchStatement(ISwitchStatement block, IList <IStatement> body) { AddIf(block, CompletionCase.EmptyCompletionBefore, body); var switchBlock = new SwitchBlock { Reference = _exprVisitor.ToVariableRef(block.Condition, body) }; foreach (var section in block.Sections) { IKaVEList <IStatement> currentSection = null; foreach (var label in section.CaseLabels) { currentSection = new KaVEList <IStatement>(); if (label.IsDefault) { switchBlock.DefaultSection = currentSection; } else { switchBlock.Sections.Add( new CaseBlock { Label = _exprVisitor.ToSimpleExpression(label.ValueExpression, body), Body = currentSection }); } AddIf(label, CompletionCase.InBody, currentSection); } AddIf(section, CompletionCase.InBody, currentSection); foreach (var statement in section.Statements) { statement.Accept(this, currentSection); } switch (1) { case 1 * 2: case 0: break; } } body.Add(switchBlock); AddIf(block, CompletionCase.EmptyCompletionAfter, body); }
private static TypeHierarchy CreateTypeHierarchy(ITypeElement type, ISubstitution substitution, IKaVEList <ITypeName> seenTypes, bool shouldIgnoreRootTypes) { if (shouldIgnoreRootTypes && (type == null || IsRootType(type))) { // ignore implicite extensions in type hierarchy return(null); } var typeName = type.GetName <ITypeName>(substitution); seenTypes.Add(typeName); var enclosingClassHierarchy = new TypeHierarchy(typeName.Identifier); foreach (var superType in type.GetSuperTypes()) { var resolveResult = superType.Resolve(); var declElem = resolveResult.DeclaredElement; var isUnresolvedAlias = declElem is IUsingAliasDirective; // TODO NameUpdate: "isUnknownOrUnResolvedUntested" required by one analyzed solution, still untested var isUnknownOrUnResolvedUntested = superType.IsUnknown || !superType.IsResolved; if (!resolveResult.IsValid() || declElem == null || isUnresolvedAlias || isUnknownOrUnResolvedUntested) { enclosingClassHierarchy.Implements.Add(new TypeHierarchy()); continue; } var superName = declElem.GetName <ITypeName>(substitution); if (seenTypes.Contains(superName)) { continue; } var superTypeElement = superType.GetTypeElement(); var superTypeSubstitution = superType.GetSubstitution(); var superHierarchy = CreateTypeHierarchy(superTypeElement, superTypeSubstitution, seenTypes, true); if (declElem is IClass || declElem is IStruct) { enclosingClassHierarchy.Extends = superHierarchy; } else if (declElem is IInterface) { enclosingClassHierarchy.Implements.Add(superHierarchy); } } return(enclosingClassHierarchy); }
public void Setup() { _reportedCounts = new List <IDictionary <string, int> >(); _registeredFilters = Lists.NewList <string>(); _registeredFixers = Lists.NewList <string>(); _log = Mock.Of <ICleanerLogger>(); Mock.Get(_log) .Setup(l => l.FinishedWriting(It.IsAny <IDictionary <string, int> >())) .Callback <IDictionary <string, int> >(d => _reportedCounts.Add(d)); Mock.Get(_log) .Setup(l => l.RegisteredConfig(It.IsAny <IEnumerable <string> >(), It.IsAny <IEnumerable <string> >())) .Callback <IEnumerable <string>, IEnumerable <string> >( (filters, fixers) => { _registeredFilters.AddAll(filters); _registeredFixers.AddAll(fixers); }); _sut = new Cleaner(Io, _log); }
private void ExtractEvents(IKaVEList <Event> events) { var logs = FindSSTLogs(_dirCtxs); var generator = new EventStreamGenerator(); foreach (var log in logs) { Console.WriteLine("##################################################"); Console.WriteLine("reading {0}...", Path.GetFileName(log)); using (var ra = new ReadingArchive(log)) { var ctxs = ra.GetAll <Context>(); Console.WriteLine("\tFound {0} contexts", ctxs.Count); Console.Write("\tExtracting events... "); foreach (var ctx in ctxs) { ctx.SST.Accept(generator, events); Console.Write('.'); } Console.WriteLine(" done"); } } }
/// <summary> /// Appends a statement block to the context with correct indentation. /// </summary> /// <param name="block">The block to append.</param> /// <param name="visitor">The visitor to use for printing each statement.</param> /// <param name="withBrackets">If false, opening and closing brackets will be omitted.</param> public SSTPrintingContext StatementBlock(IKaVEList <IStatement> block, ISSTNodeVisitor <SSTPrintingContext> visitor, bool withBrackets = true) { if (!block.Any()) { if (withBrackets) { Text(" { }"); } return(this); } if (withBrackets) { NewLine().Indentation().Text("{"); } IndentationLevel++; foreach (var statement in block) { NewLine(); statement.Accept(visitor, this); } IndentationLevel--; if (withBrackets) { NewLine().Indentation().Text("}"); } return(this); }
public TestClassResult() { TestMethods = Lists.NewList <TestMethodResult>(); }
public CatchBlock() { Parameter = Names.UnknownParameter; Body = Lists.NewList <IStatement>(); }
public CaseBlock() { Label = new UnknownExpression(); Body = Lists.NewList <IStatement>(); }
public TestRunInterval() { TestClasses = Lists.NewList <TestClassResult>(); }
private static ISet <Tuple <CoReMethodName, CoReTypeName> > GetLocationIndices(IKaVEList <Query> aqs, IKaVEList <Query> bqs) { var keys = new HashSet <Tuple <CoReMethodName, CoReTypeName> >(); foreach (var qs in new[] { aqs, bqs }) { foreach (var q in qs) { keys.Add(Tuple.Create(q.methodCtx, q.type)); } } return(keys); }
public IndexAccessExpression() { Reference = new VariableReference(); Indices = new KaVEList <ISimpleExpression>(); }