public async Task SynchronizeAndCheck(
            int?unchangedA, int?addedA, int?changedA, int?deletedA,
            int?unchangedB, int?addedB, int?changedB, int?deletedB,
            int?createA, int?updateA, int?deleteA,
            int?createB, int?updateB, int?deleteB,
            int?ordinalOfReportToCheck  = null,
            int?maximumOpenItemsPerType = null)
        {
            TestComponentContainer.SetMaximumOpenItemsPerType(maximumOpenItemsPerType);
            try
            {
                var report = await SynchronizeAndAssertNoErrors();

                var aDelta = ParseDelta(ExtractLoggerInfo(report.ADelta, ordinalOfReportToCheck));
                AssertEqual(aDelta.Unchanged, unchangedA);
                AssertEqual(aDelta.Added, addedA);
                AssertEqual(aDelta.Deleted, deletedA);
                AssertEqual(aDelta.Changed, changedA);

                var bDelta = ParseDelta(ExtractLoggerInfo(report.BDelta, ordinalOfReportToCheck));
                AssertEqual(bDelta.Unchanged, unchangedB);
                AssertEqual(bDelta.Added, addedB);
                AssertEqual(bDelta.Deleted, deletedB);
                AssertEqual(bDelta.Changed, changedB);

                var aJobs = ParseJobInfo(ExtractLoggerInfo(report.AJobsInfo, ordinalOfReportToCheck));
                AssertEqual(aJobs.Create, createA);
                AssertEqual(aJobs.Update, updateA);
                AssertEqual(aJobs.Delete, deleteA);

                var bJobs = ParseJobInfo(ExtractLoggerInfo(report.BJobsInfo, ordinalOfReportToCheck));
                AssertEqual(bJobs.Create, createB);
                AssertEqual(bJobs.Update, updateB);
                AssertEqual(bJobs.Delete, deleteB);
            }
            finally
            {
                TestComponentContainer.SetMaximumOpenItemsPerType(null);
            }
        }
        public async Task SynchronizeAndCheck(
            int unchangedA, int addedA, int changedA, int deletedA,
            int unchangedB, int addedB, int changedB, int deletedB,
            int createA, int updateA, int deleteA,
            int createB, int updateB, int deleteB,
            int?ordinalOfReportToCheck  = null,
            int?maximumOpenItemsPerType = null)
        {
            TestComponentContainer.SetMaximumOpenItemsPerType(maximumOpenItemsPerType);
            try
            {
                var report = await SynchronizeAndAssertNoErrors();

                Assert.That(ExtractLoggerInfo(report.ADelta, ordinalOfReportToCheck), Is.EqualTo($"Unchanged: {unchangedA} , Added: {addedA} , Deleted {deletedA} ,  Changed {changedA}"));
                Assert.That(ExtractLoggerInfo(report.BDelta, ordinalOfReportToCheck), Is.EqualTo($"Unchanged: {unchangedB} , Added: {addedB} , Deleted {deletedB} ,  Changed {changedB}"));
                Assert.That(ExtractLoggerInfo(report.AJobsInfo, ordinalOfReportToCheck), Is.EqualTo($"Create {createA} , Update {updateA} , Delete {deleteA}"));
                Assert.That(ExtractLoggerInfo(report.BJobsInfo, ordinalOfReportToCheck), Is.EqualTo($"Create {createB} , Update {updateB} , Delete {deleteB}"));
            }
            finally
            {
                TestComponentContainer.SetMaximumOpenItemsPerType(null);
            }
        }