public void TestJavascriptFiles()
        {
            // Arrange
            SmartDictionary deviceState = new SmartDictionary();

            var files = new List <string>
            {
                "chiller-01-state.js",
                "chiller-02-state.js",
                "elevator-01-state.js",
                "elevator-02-state.js",
                "engine-01-state.js",
                "engine-02-state.js",
                "prototype-01-state.js",
                "prototype-02-state.js",
                "truck-01-state.js",
                "truck-02-state.js"
            };
            var context = new Dictionary <string, object>
            {
                ["currentTime"] = DateTimeOffset.UtcNow.ToString("yyyy-MM-dd'T'HH:mm:sszzz"),
                ["deviceId"]    = "device-123",
                ["deviceModel"] = "room"
            };

            // Act - Assert (no exception should occur)
            foreach (var file in files)
            {
                this.target.Invoke(file, context, deviceState, this.properties.Object);
                Assert.NotNull(deviceState.GetAll());
            }
        }
        private ISmartDictionary GetTestProperties()
        {
            SmartDictionary properties = new SmartDictionary();

            properties.Set(KEY1, VALUE1);
            properties.Set(KEY2, VALUE2);

            return(properties);
        }
Exemplo n.º 3
0
        public ScmDataCache(IScmData innerScmData)
        {
            this.innerScmData = innerScmData;

            logs  = new FixedSizeDictionary <string, ILog>(1, x => innerScmData.Log(x));
            diffs = new FixedSizeDictionary <string, SmartDictionary <string, IDiff> >(1, x =>
                                                                                       new SmartDictionary <string, IDiff>(y => innerScmData.Diff(x, y))
                                                                                       );
            blames = new FixedSizeDictionary <string, IBlame>(100);
        }
Exemplo n.º 4
0
        public ScmDataCache(IScmData innerScmData)
        {
            this.innerScmData = innerScmData;

            logs = new FixedSizeDictionary<string,ILog>(1, x => innerScmData.Log(x));
            diffs = new FixedSizeDictionary<string,SmartDictionary<string,IDiff>>(1, x =>
                new SmartDictionary<string,IDiff>(y => innerScmData.Diff(x, y))
            );
            blames = new FixedSizeDictionary<string,IBlame>(100);
        }
Exemplo n.º 5
0
        public override void Init(IRepository repository)
        {
            authorByRevision = repository.SelectionDSL()
                               .Commits().TillRevision(model.PredictionRelease)
                               .ToDictionary(x => x.Revision, x => x.Author);

            defectLineProbabilityOfAuthor = new SmartDictionary <string, double>(a =>
                                                                                 repository.SelectionDSL()
                                                                                 .Commits().AuthorIs(a).BeforeRevision(model.PredictionRelease)
                                                                                 .Modifications().InCommits()
                                                                                 .CodeBlocks().InModifications().CalculateDefectCodeDensity(model.PredictionRelease)
                                                                                 );
        }
Exemplo n.º 6
0
        private IDictionary <string, IEnumerable <int> > LinesByRevisionTheyWereAddedIn(
            IEnumerable <int> lines,
            IBlame blame
            )
        {
            SmartDictionary <string, IEnumerable <int> > result =
                new SmartDictionary <string, IEnumerable <int> >((x) => new List <int>());

            foreach (int line in lines)
            {
                (result[blame[line]] as List <int>).Add(line);
            }
            return(result);
        }
Exemplo n.º 7
0
        public override void Init(IRepository repository, IEnumerable <string> releases)
        {
            base.Init(repository, releases);

            ReleaseDate = repository.Queryable <Commit>()
                          .Single(x => x.Revision == PredictionRelease)
                          .Date;

            RemainCodeSizeFromRevision = new SmartDictionary <string, double>(r =>
                                                                              repository.SelectionDSL()
                                                                              .Commits().RevisionIs(r)
                                                                              .Modifications().InCommits()
                                                                              .CodeBlocks().InModifications().Added().CalculateRemainingCodeSize(PredictionRelease).Sum(x => x.Value)
                                                                              );
            AddedCodeSizeFromRevision = new SmartDictionary <string, double>(r =>
                                                                             repository.SelectionDSL()
                                                                             .Commits().RevisionIs(r)
                                                                             .Modifications().InCommits()
                                                                             .CodeBlocks().InModifications().Added().CalculateLOC()
                                                                             );
            DefectCodeSizeFromRevision = new SmartDictionary <string, double>(r =>
                                                                              repository.SelectionDSL()
                                                                              .Commits().RevisionIs(r)
                                                                              .Modifications().InCommits()
                                                                              .CodeBlocks().InModifications().CalculateDefectCodeSize(PredictionRelease)
                                                                              );

            AddedCodeSizeResolver = (revision, pathid) =>
                                    repository.SelectionDSL()
                                    .Commits().RevisionIs(revision)
                                    .Files().IdIs(pathid)
                                    .Modifications().InCommits().InFiles()
                                    .CodeBlocks().InModifications().Added().CalculateLOC();
            DefectCodeSizeResolver = (revision, pathid) =>
                                     repository.SelectionDSL()
                                     .Commits().RevisionIs(revision)
                                     .Files().IdIs(pathid)
                                     .Modifications().InCommits().InFiles()
                                     .CodeBlocks().InModifications().CalculateDefectCodeSize(PredictionRelease);
            RemainCodeSizeFromRevisionResolver = (revision) =>
                                                 RemainCodeSizeFromRevision[revision];
            AddedCodeSizeFromRevisionResolver = (revision) =>
                                                AddedCodeSizeFromRevision[revision];
            DefectCodeSizeFromRevisionResolver = (revision) =>
                                                 DefectCodeSizeFromRevision[revision];

            OnInit(repository);
        }
Exemplo n.º 8
0
        public void Blame(string path, string revision)
        {
            var blame = scmDataWithoutCache.Blame(revision, path);

            SmartDictionary <string, IEnumerable <int> > output =
                new SmartDictionary <string, IEnumerable <int> >((x) => new List <int>());

            for (int i = 1; i <= blame.Count; i++)
            {
                (output[blame[i]] as List <int>).Add(i);
            }
            foreach (var rev in output.OrderBy(x => x.Key))
            {
                Console.WriteLine("{0} {1}", rev.Key, rev.Value.Count());
            }
        }
        /// <summary>
        /// Initializes device properties from the device model.
        /// </summary>
        private ISmartDictionary GetInitialProperties(DeviceModel model)
        {
            var properties = new SmartDictionary();

            // Add telemetry property
            properties.Set(TELEMETRY_KEY, JToken.FromObject(this.deviceModel.GetTelemetryReportedProperty(this.log)));

            // Add SupportedMethods property with methods listed in device model
            properties.Set(SUPPORTED_METHODS_KEY, string.Join(",", this.deviceModel.CloudToDeviceMethods.Keys));

            // Add properties listed in device model
            foreach (var property in model.Properties)
            {
                properties.Set(property.Key, JToken.FromObject(property.Value));
            }

            return(properties);
        }
        private void SetupPropertiesActorProperties()
        {
            var properties = new Dictionary <string, object>
            {
                { "testKey1", "testValue1" },
                { "testKey2", "testValue2" }
            };

            this.devicePropertiesActor
            .Setup(x => x.DeviceProperties.GetAll())
            .Returns(properties);

            var smartDictionary = new SmartDictionary(properties);

            this.devicePropertiesActor
            .Setup(x => x.DeviceProperties)
            .Returns(smartDictionary);
        }
        /// <summary>
        /// Initializes device state from the device model.
        /// </summary>
        private ISmartDictionary GetInitialState(DeviceModel model)
        {
            var initialState = CloneObject(model.Simulation.InitialState);

            var state = new SmartDictionary(initialState);

            // Ensure the state contains the "online" key
            if (!state.Has("online"))
            {
                state.Set("online", true, false);
            }

            // TODO: This is used to control whether telemetry is calculated in UpdateDeviceState.
            //       methods can turn telemetry off/on; e.g. setting temp high- turnoff, set low, turn on
            //       it would be better to do this at the telemetry item level - we should add this in the future
            //       https://github.com/Azure/device-simulation-dotnet/issues/174
            state.Set(CALC_TELEMETRY, true, false);

            return(state);
        }
Exemplo n.º 12
0
        public void ReturnedStateIsIntact()
        {
            // Arrange
            SmartDictionary deviceState = new SmartDictionary();

            var script = new Script
            {
                Path = "chiller-01-state.js"
            };
            var context = new Dictionary <string, object>
            {
                ["currentTime"] = DateTimeOffset.UtcNow.ToString("yyyy-MM-dd'T'HH:mm:sszzz"),
                ["deviceId"]    = "device-123",
                ["deviceModel"] = "room"
            };
            var state = new Dictionary <string, object>
            {
                ["temperature"]      = 50.5,
                ["temperature_unit"] = "device-123",
                ["humidity"]         = 70.2,
                ["humidity_unit"]    = "%",
                ["lights_on"]        = false,
                ["pressure"]         = 150.0,
                ["pressure_unit"]    = "psig"
            };

            deviceState.SetAll(state);

            // Act
            this.target.Invoke(script, context, deviceState, this.properties.Object);

            // Assert
            Assert.Equal(state.Count, deviceState.GetAll().Count);
            Assert.IsType <Double>(deviceState.Get("temperature"));
            Assert.IsType <string>(deviceState.Get("temperature_unit"));
            Assert.IsType <Double>(deviceState.Get("humidity"));
            Assert.IsType <string>(deviceState.Get("humidity_unit"));
            Assert.IsType <bool>(deviceState.Get("lights_on"));
            Assert.IsType <Double>(deviceState.Get("pressure"));
            Assert.IsType <string>(deviceState.Get("pressure_unit"));
        }
Exemplo n.º 13
0
        private bool CheckLinesContent(IRepository repository, IScmData scmData, string testRevision, ProjectFile file, bool resultOnly)
        {
            IBlame fileBlame = null;
            try
            {
                fileBlame = scmData.Blame(testRevision, file.Path);
            }
            catch
            {
            }
            if (fileBlame == null)
            {
                if (! resultOnly)
                {
                    Console.WriteLine("File {0} does not exist.", file.Path);
                }
                return false;
            }

            double currentLOC = repository.SelectionDSL()
                    .Commits().TillRevision(testRevision)
                    .Files().IdIs(file.ID)
                    .Modifications().InCommits().InFiles()
                    .CodeBlocks().InModifications()
                    .CalculateLOC();

            bool correct = currentLOC == fileBlame.Count;

            if (! correct)
            {
                if (! resultOnly)
                {
                    Console.WriteLine("Incorrect number of lines in file {0}. {1} should be {2}",
                        file.Path, currentLOC, fileBlame.Count
                    );
                }
                else
                {
                    return false;
                }
            }

            SmartDictionary<string, int> linesByRevision = new SmartDictionary<string, int>(x => 0);
            foreach (var line in fileBlame)
            {
                linesByRevision[line.Value]++;
            }

            var codeBySourceRevision =
            (
                from f in repository.Queryable<ProjectFile>()
                join m in repository.Queryable<Modification>() on f.ID equals m.FileID
                join cb in repository.Queryable<CodeBlock>() on m.ID equals cb.ModificationID
                join c in repository.Queryable<Commit>() on m.CommitID equals c.ID
                let addedCodeBlock = repository.Queryable<CodeBlock>()
                    .Single(x => x.ID == (cb.Size < 0 ? cb.TargetCodeBlockID : cb.ID))
                let codeAddedInitiallyInRevision = repository.Queryable<Commit>()
                    .Single(x => x.ID == addedCodeBlock.AddedInitiallyInCommitID)
                    .Revision
                let testRevisionNumber = repository.Queryable<Commit>()
                    .Single(x => x.Revision == testRevision)
                    .OrderedNumber
                where
                    f.ID == file.ID
                    &&
                    c.OrderedNumber <= testRevisionNumber
                group cb.Size by codeAddedInitiallyInRevision into g
                select new
                {
                    FromRevision = g.Key,
                    CodeSize = g.Sum()
                }
            ).Where(x => x.CodeSize != 0).ToList();

            var errorCode =
                (
                    from codeFromRevision in codeBySourceRevision
                    where
                        codeFromRevision.CodeSize != linesByRevision[codeFromRevision.FromRevision]
                    select new
                    {
                        SourceRevision = codeFromRevision.FromRevision,
                        CodeSize = codeFromRevision.CodeSize,
                        RealCodeSize = linesByRevision[codeFromRevision.FromRevision]
                    }
                ).ToList();

            correct =
                correct
                &&
                codeBySourceRevision.Count() == linesByRevision.Count
                &&
                errorCode.Count == 0;

            if (! resultOnly)
            {
                if (codeBySourceRevision.Count() != linesByRevision.Count)
                {
                    Console.WriteLine("Number of revisions file {0} contains code from is incorrect. {1} should be {2}",
                        file.Path, codeBySourceRevision.Count(), linesByRevision.Count
                    );
                }
                foreach (var error in errorCode)
                {
                    Console.WriteLine("Incorrect number of lines in file {0} from revision {1}. {2} should be {3}",
                        file.Path,
                        error.SourceRevision,
                        error.CodeSize,
                        error.RealCodeSize
                    );
                }
                if ((! correct) && (errorCode.Count > 0))
                {
                    string latestCodeRevision = repository.LastRevision(errorCode.Select(x => x.SourceRevision));

                    var commitsFileTouchedIn = repository.SelectionDSL()
                        .Files().IdIs(file.ID)
                        .Commits().FromRevision(latestCodeRevision).TouchFiles()
                        .OrderBy(c => c.OrderedNumber);

                    foreach (var commit in commitsFileTouchedIn)
                    {
                        if (!CheckLinesContent(repository, scmData, commit.Revision, file, true))
                        {
                            Console.WriteLine("{0} - incorrectly mapped commit.", commit.Revision);
                            if ((automaticallyFixDiffErrors) && (errorCode.Sum(x => x.CodeSize - x.RealCodeSize) == 0))
                            {
                                var incorrectDeleteCodeBlocks =
                                    from cb in repository.SelectionDSL()
                                        .Commits().RevisionIs(commit.Revision)
                                        .Files().PathIs(file.Path)
                                        .Modifications().InCommits().InFiles()
                                        .CodeBlocks().InModifications().Deleted()
                                    join tcb in repository.Queryable<CodeBlock>() on cb.TargetCodeBlockID equals tcb.ID
                                    join m in repository.Queryable<Modification>() on tcb.ModificationID equals m.ID
                                    join c in repository.Queryable<Commit>() on m.CommitID equals c.ID
                                    where
                                        errorCode.Select(x => x.SourceRevision).Contains(c.Revision)
                                    select new
                                    {
                                        Code = cb,
                                        TargetRevision = c.Revision
                                    };

                                foreach (var error in errorCode)
                                {
                                    var incorrectDeleteCodeBlock = incorrectDeleteCodeBlocks.SingleOrDefault(x => x.TargetRevision == error.SourceRevision);
                                    var codeBlock = incorrectDeleteCodeBlock == null ? null : incorrectDeleteCodeBlock.Code;
                                    double difference = error.CodeSize - error.RealCodeSize;
                                    if (codeBlock == null)
                                    {
                                        codeBlock = new CodeBlock()
                                        {
                                            Size = 0,
                                            Modification = repository.SelectionDSL()
                                                .Commits().RevisionIs(commit.Revision)
                                                .Files().PathIs(file.Path)
                                                .Modifications().InCommits().InFiles().Single(),
                                        };
                                        repository.Add(codeBlock);
                                    }
                                    Console.WriteLine("Fix code block size for file {0} in revision {1}:", file.Path, commit.Revision);
                                    Console.Write("Was {0}", codeBlock.Size);
                                    codeBlock.Size -= difference;
                                    if (codeBlock.Size == 0)
                                    {
                                        repository.Delete(codeBlock);
                                    }
                                    else if ((codeBlock.Size > 0) && (codeBlock.AddedInitiallyInCommitID == null))
                                    {
                                        codeBlock.AddedInitiallyInCommit = commit;
                                    }
                                    else if ((codeBlock.Size < 0) && (codeBlock.TargetCodeBlockID == null))
                                    {
                                        codeBlock.TargetCodeBlock = repository.SelectionDSL()
                                            .Commits().RevisionIs(error.SourceRevision)
                                            .Files().PathIs(file.Path)
                                            .Modifications().InFiles()
                                            .CodeBlocks().InModifications().AddedInitiallyInCommits().Single();
                                    }
                                    Console.WriteLine(", now {0}", codeBlock.Size);
                                }
                            }
                            break;
                        }
                    }
                }
            }

            return correct;
        }
        public override void Init(IRepositoryResolver repositories)
        {
            authorByRevision = repositories.SelectionDSL()
                .Commits().TillRevision(model.PredictionRelease)
                .ToDictionary(x => x.Revision, x => x.Author);

            defectLineProbabilityOfAuthor = new SmartDictionary<string,double>(a =>
                repositories.SelectionDSL()
                    .Commits().AuthorIs(a).BeforeRevision(model.PredictionRelease)
                    .Modifications().InCommits()
                    .CodeBlocks().InModifications().CalculateDefectCodeDensity(model.PredictionRelease)
            );
        }
        public override void Init(IRepositoryResolver repositories, IEnumerable<string> releases)
        {
            base.Init(repositories, releases);

            ReleaseDate = repositories.Repository<Commit>()
                .Single(x => x.Revision == PredictionRelease)
                .Date;

            RemainCodeSizeFromRevision = new SmartDictionary<string,double>(r =>
                repositories.SelectionDSL()
                    .Commits().RevisionIs(r)
                    .Modifications().InCommits()
                    .CodeBlocks().InModifications().Added().CalculateRemainingCodeSize(PredictionRelease).Sum(x => x.Value)
            );
            AddedCodeSizeFromRevision = new SmartDictionary<string,double>(r =>
                repositories.SelectionDSL()
                    .Commits().RevisionIs(r)
                    .Modifications().InCommits()
                    .CodeBlocks().InModifications().Added().CalculateLOC()
            );
            DefectCodeSizeFromRevision = new SmartDictionary<string,double>(r =>
                repositories.SelectionDSL()
                    .Commits().RevisionIs(r)
                    .Modifications().InCommits()
                    .CodeBlocks().InModifications().CalculateDefectCodeSize(PredictionRelease)
            );

            AddedCodeSizeResolver = (revision,pathid) =>
                repositories.SelectionDSL()
                    .Commits().RevisionIs(revision)
                    .Files().IdIs(pathid)
                    .Modifications().InCommits().InFiles()
                    .CodeBlocks().InModifications().Added().CalculateLOC();
            DefectCodeSizeResolver = (revision,pathid) =>
                repositories.SelectionDSL()
                    .Commits().RevisionIs(revision)
                    .Files().IdIs(pathid)
                    .Modifications().InCommits().InFiles()
                    .CodeBlocks().InModifications().CalculateDefectCodeSize(PredictionRelease);
            RemainCodeSizeFromRevisionResolver = (revision) =>
                RemainCodeSizeFromRevision[revision];
            AddedCodeSizeFromRevisionResolver = (revision) =>
                AddedCodeSizeFromRevision[revision];
            DefectCodeSizeFromRevisionResolver = (revision) =>
                DefectCodeSizeFromRevision[revision];

            OnInit(repositories);
        }
Exemplo n.º 16
0
        private bool CheckLinesContent(IRepository repository, IScmData scmData, string testRevision, ProjectFile file, bool resultOnly)
        {
            IBlame fileBlame = null;

            try
            {
                fileBlame = scmData.Blame(testRevision, file.Path);
            }
            catch
            {
            }
            if (fileBlame == null)
            {
                if (!resultOnly)
                {
                    Console.WriteLine("File {0} does not exist.", file.Path);
                }
                return(false);
            }

            double currentLOC = repository.SelectionDSL()
                                .Commits().TillRevision(testRevision)
                                .Files().IdIs(file.ID)
                                .Modifications().InCommits().InFiles()
                                .CodeBlocks().InModifications()
                                .CalculateLOC();

            bool correct = currentLOC == fileBlame.Count;

            if (!correct)
            {
                if (!resultOnly)
                {
                    Console.WriteLine("Incorrect number of lines in file {0}. {1} should be {2}",
                                      file.Path, currentLOC, fileBlame.Count
                                      );
                }
                else
                {
                    return(false);
                }
            }

            SmartDictionary <string, int> linesByRevision = new SmartDictionary <string, int>(x => 0);

            foreach (var line in fileBlame)
            {
                linesByRevision[line.Value]++;
            }

            var codeBySourceRevision =
                (
                    from f in repository.Queryable <ProjectFile>()
                    join m in repository.Queryable <Modification>() on f.ID equals m.FileID
                    join cb in repository.Queryable <CodeBlock>() on m.ID equals cb.ModificationID
                    join c in repository.Queryable <Commit>() on m.CommitID equals c.ID
                    let addedCodeBlock = repository.Queryable <CodeBlock>()
                                         .Single(x => x.ID == (cb.Size < 0 ? cb.TargetCodeBlockID : cb.ID))
                                         let codeAddedInitiallyInRevision = repository.Queryable <Commit>()
                                                                            .Single(x => x.ID == addedCodeBlock.AddedInitiallyInCommitID)
                                                                            .Revision
                                                                            let testRevisionNumber = repository.Queryable <Commit>()
                                                                                                     .Single(x => x.Revision == testRevision)
                                                                                                     .OrderedNumber
                                                                                                     where
                                                                                                     f.ID == file.ID
                                                                                                     &&
                                                                                                     c.OrderedNumber <= testRevisionNumber
                                                                                                     group cb.Size by codeAddedInitiallyInRevision into g
                                                                                                     select new
            {
                FromRevision = g.Key,
                CodeSize = g.Sum()
            }
                ).Where(x => x.CodeSize != 0).ToList();

            var errorCode =
                (
                    from codeFromRevision in codeBySourceRevision
                    where
                    codeFromRevision.CodeSize != linesByRevision[codeFromRevision.FromRevision]
                    select new
            {
                SourceRevision = codeFromRevision.FromRevision,
                CodeSize = codeFromRevision.CodeSize,
                RealCodeSize = linesByRevision[codeFromRevision.FromRevision]
            }
                ).ToList();

            correct =
                correct
                &&
                codeBySourceRevision.Count() == linesByRevision.Count
                &&
                errorCode.Count == 0;

            if (!resultOnly)
            {
                if (codeBySourceRevision.Count() != linesByRevision.Count)
                {
                    Console.WriteLine("Number of revisions file {0} contains code from is incorrect. {1} should be {2}",
                                      file.Path, codeBySourceRevision.Count(), linesByRevision.Count
                                      );
                }
                foreach (var error in errorCode)
                {
                    Console.WriteLine("Incorrect number of lines in file {0} from revision {1}. {2} should be {3}",
                                      file.Path,
                                      error.SourceRevision,
                                      error.CodeSize,
                                      error.RealCodeSize
                                      );
                }
                if ((!correct) && (errorCode.Count > 0))
                {
                    string latestCodeRevision = repository.LastRevision(errorCode.Select(x => x.SourceRevision));

                    var commitsFileTouchedIn = repository.SelectionDSL()
                                               .Files().IdIs(file.ID)
                                               .Commits().FromRevision(latestCodeRevision).TouchFiles()
                                               .OrderBy(c => c.OrderedNumber);

                    foreach (var commit in commitsFileTouchedIn)
                    {
                        if (!CheckLinesContent(repository, scmData, commit.Revision, file, true))
                        {
                            Console.WriteLine("{0} - incorrectly mapped commit.", commit.Revision);
                            if ((automaticallyFixDiffErrors) && (errorCode.Sum(x => x.CodeSize - x.RealCodeSize) == 0))
                            {
                                var incorrectDeleteCodeBlocks =
                                    from cb in repository.SelectionDSL()
                                    .Commits().RevisionIs(commit.Revision)
                                    .Files().PathIs(file.Path)
                                    .Modifications().InCommits().InFiles()
                                    .CodeBlocks().InModifications().Deleted()
                                    join tcb in repository.Queryable <CodeBlock>() on cb.TargetCodeBlockID equals tcb.ID
                                    join m in repository.Queryable <Modification>() on tcb.ModificationID equals m.ID
                                    join c in repository.Queryable <Commit>() on m.CommitID equals c.ID
                                    where
                                    errorCode.Select(x => x.SourceRevision).Contains(c.Revision)
                                    select new
                                {
                                    Code           = cb,
                                    TargetRevision = c.Revision
                                };

                                foreach (var error in errorCode)
                                {
                                    var    incorrectDeleteCodeBlock = incorrectDeleteCodeBlocks.SingleOrDefault(x => x.TargetRevision == error.SourceRevision);
                                    var    codeBlock  = incorrectDeleteCodeBlock == null ? null : incorrectDeleteCodeBlock.Code;
                                    double difference = error.CodeSize - error.RealCodeSize;
                                    if (codeBlock == null)
                                    {
                                        codeBlock = new CodeBlock()
                                        {
                                            Size         = 0,
                                            Modification = repository.SelectionDSL()
                                                           .Commits().RevisionIs(commit.Revision)
                                                           .Files().PathIs(file.Path)
                                                           .Modifications().InCommits().InFiles().Single(),
                                        };
                                        repository.Add(codeBlock);
                                    }
                                    Console.WriteLine("Fix code block size for file {0} in revision {1}:", file.Path, commit.Revision);
                                    Console.Write("Was {0}", codeBlock.Size);
                                    codeBlock.Size -= difference;
                                    if (codeBlock.Size == 0)
                                    {
                                        repository.Delete(codeBlock);
                                    }
                                    else if ((codeBlock.Size > 0) && (codeBlock.AddedInitiallyInCommitID == null))
                                    {
                                        codeBlock.AddedInitiallyInCommit = commit;
                                    }
                                    else if ((codeBlock.Size < 0) && (codeBlock.TargetCodeBlockID == null))
                                    {
                                        codeBlock.TargetCodeBlock = repository.SelectionDSL()
                                                                    .Commits().RevisionIs(error.SourceRevision)
                                                                    .Files().PathIs(file.Path)
                                                                    .Modifications().InFiles()
                                                                    .CodeBlocks().InModifications().AddedInitiallyInCommits().Single();
                                    }
                                    Console.WriteLine(", now {0}", codeBlock.Size);
                                }
                            }
                            break;
                        }
                    }
                }
            }

            return(correct);
        }