TimeSizeCompare.cpp: Fix a problem that unique files are invisible when comparing...

diff --git a/Src/CompareEngines/TimeSizeCompare.cpp b/Src/CompareEngines/TimeSizeCompare.cpp
index 00b950e..ef55c3d 100644 (file)
--- a/Src/CompareEngines/TimeSizeCompare.cpp
+++ b/Src/CompareEngines/TimeSizeCompare.cpp
@@ -49,39 +49,31 @@ int TimeSizeCompare::CompareFiles(int compMethod, int nfiles, const DIFFITEM &di
        {
                // Compare by modified date
                // Check that we have both filetimes
-               if (di.diffFileInfo[0].mtime != 0 && di.diffFileInfo[1].mtime != 0 &&
-                   (nfiles < 3 || di.diffFileInfo[1].mtime != 0 && di.diffFileInfo[2].mtime != 0))
+               nTimeDiff   = di.diffFileInfo[0].mtime - di.diffFileInfo[1].mtime;
+               if (nTimeDiff   < 0) nTimeDiff   *= -1;
+               if (nfiles > 2)
                {
-                       nTimeDiff   = di.diffFileInfo[0].mtime - di.diffFileInfo[1].mtime;
-                       if (nTimeDiff   < 0) nTimeDiff   *= -1;
-                       if (nfiles > 2)
-                       {
-                               nTimeDiff12 = di.diffFileInfo[1].mtime - di.diffFileInfo[2].mtime;
-                               nTimeDiff02 = di.diffFileInfo[0].mtime - di.diffFileInfo[2].mtime;
-                               if (nTimeDiff12 < 0) nTimeDiff12 *= -1;
-                               if (nTimeDiff02 < 0) nTimeDiff02 *= -1;
-                       }
-                       if (m_ignoreSmallDiff)
-                       {
-                               // If option to ignore small timediffs (couple of seconds)
-                               // is set, decrease absolute difference by allowed diff
-                               nTimeDiff   -= SmallTimeDiff * Timestamp::resolution();
-                               nTimeDiff12 -= SmallTimeDiff * Timestamp::resolution();
-                               nTimeDiff02 -= SmallTimeDiff * Timestamp::resolution();
-                       }
-                       if (nTimeDiff <= 0 && nTimeDiff12 <= 0)
-                               code = DIFFCODE::SAME;
-                       else
-                               code = DIFFCODE::DIFF;
+                       nTimeDiff12 = di.diffFileInfo[1].mtime - di.diffFileInfo[2].mtime;
+                       nTimeDiff02 = di.diffFileInfo[0].mtime - di.diffFileInfo[2].mtime;
+                       if (nTimeDiff12 < 0) nTimeDiff12 *= -1;
+                       if (nTimeDiff02 < 0) nTimeDiff02 *= -1;
                }
+               if (m_ignoreSmallDiff)
+               {
+                       // If option to ignore small timediffs (couple of seconds)
+                       // is set, decrease absolute difference by allowed diff
+                       nTimeDiff   -= SmallTimeDiff * Timestamp::resolution();
+                       nTimeDiff12 -= SmallTimeDiff * Timestamp::resolution();
+                       nTimeDiff02 -= SmallTimeDiff * Timestamp::resolution();
+               }
+               if (nTimeDiff <= 0 && nTimeDiff12 <= 0)
+                       code = DIFFCODE::SAME;
                else
+                       code = DIFFCODE::DIFF;
+
+               for (int i = 0; i < nfiles; ++i)
                {
-                       // Filetimes for item(s) could not be read. So we have to
-                       // set error status, unless we have DATE_SIZE -compare
-                       // when we have still hope for size compare..
-                       if (compMethod == CMP_DATE_SIZE)
-                               code = DIFFCODE::SAME;
-                       else
+                       if (di.diffFileInfo[i].mtime == 0 && di.diffcode.exists(i))
                                code = DIFFCODE::CMPERR;
                }
        }
@@ -94,6 +86,12 @@ int TimeSizeCompare::CompareFiles(int compMethod, int nfiles, const DIFFITEM &di
                {
                        code = DIFFCODE::DIFF;
                }
+
+               for (int i = 0; i < nfiles; ++i)
+               {
+                       if (di.diffFileInfo[i].size == DirItem::FILE_SIZE_NONE && di.diffcode.exists(i))
+                               code = DIFFCODE::CMPERR;
+               }
        }
        if (nfiles > 2 && (code & DIFFCODE::COMPAREFLAGS) == DIFFCODE::DIFF)
        {

diff --git a/Testing/GoogleTest/TimeSizeCompare/TimeSizeCompare_test.cpp b/Testing/GoogleTest/TimeSizeCompare/TimeSizeCompare_test.cpp
index 97cb62f..1d45d44 100644 (file)
--- a/Testing/GoogleTest/TimeSizeCompare/TimeSizeCompare_test.cpp
+++ b/Testing/GoogleTest/TimeSizeCompare/TimeSizeCompare_test.cpp
@@ -45,6 +45,9 @@ namespace
                CompareEngines::TimeSizeCompare tsc;
                DIFFITEM di;
 
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + 10000000;
                di.diffFileInfo[2].mtime = di.diffFileInfo[0].mtime + 20000000;
@@ -52,11 +55,14 @@ namespace
                di.diffFileInfo[0].size = 0;
                di.diffFileInfo[1].size = 0;
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_SIZE, 2, di));
-       
+
                di.diffFileInfo[0].size = 1;
                di.diffFileInfo[1].size = 1;
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_SIZE, 2, di));
-       
+
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
                di.diffFileInfo[0].size = 0;
                di.diffFileInfo[1].size = 0;
                di.diffFileInfo[2].size = 0;
@@ -73,48 +79,231 @@ namespace
                CompareEngines::TimeSizeCompare tsc;
                DIFFITEM di;
 
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + 10000000;
                di.diffFileInfo[2].mtime = di.diffFileInfo[0].mtime + 20000000;
 
-               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
-               di.diffFileInfo[1].size = 0;
-               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 2, di));
-       
-               di.diffFileInfo[0].size = 0;
-               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
-               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 2, di));
-       
                di.diffFileInfo[0].size = 1;
                di.diffFileInfo[1].size = 2;
                EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 2, di));
-       
+
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
                di.diffFileInfo[0].size = 1;
                di.diffFileInfo[1].size = 1;
                di.diffFileInfo[2].size = 0;
                EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF3RDONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
-       
+
                di.diffFileInfo[0].size = 1;
                di.diffFileInfo[1].size = 0;
                di.diffFileInfo[2].size = 1;
                EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF2NDONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
-       
+
                di.diffFileInfo[0].size = 0;
                di.diffFileInfo[1].size = 1;
                di.diffFileInfo[2].size = 1;
                EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
-       
+
                di.diffFileInfo[0].size = 0;
                di.diffFileInfo[1].size = 1;
                di.diffFileInfo[2].size = 2;
                EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 3, di));
        }
 
+       TEST_F(TimeSizeCompareTest, SizeCompare_UniqueFile)
+       {
+               CompareEngines::TimeSizeCompare tsc;
+               DIFFITEM di;
+
+               di.diffFileInfo[0].mtime = Poco::Timestamp();
+               di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + 10000000;
+               di.diffFileInfo[2].mtime = di.diffFileInfo[0].mtime + 20000000;
+
+               di.diffcode.setSideNone();
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_SIZE, 2, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 2, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 2, di));
+
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
+               di.diffcode.setSideNone();
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF2NDONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF3RDONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = 2;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = 2;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = 2;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF2NDONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF3RDONLY, tsc.CompareFiles(CMP_SIZE, 3, di));
+       }
+
+       TEST_F(TimeSizeCompareTest, SizeCompare_TimeError)
+       {
+               CompareEngines::TimeSizeCompare tsc;
+               DIFFITEM di;
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_SIZE, 2, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_SIZE, 2, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_SIZE, 2, di));
+
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = 1;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = 1;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_SIZE, 3, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_SIZE, 3, di));
+       }
+
        TEST_F(TimeSizeCompareTest, TimeCompare_SameTime)
        {
                CompareEngines::TimeSizeCompare tsc;
                DIFFITEM di;
 
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
                di.diffFileInfo[0].size = 0;
                di.diffFileInfo[1].size = 1;
                di.diffFileInfo[2].size = 2;
@@ -123,17 +312,20 @@ namespace
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime;
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE, 2, di));
-       
+
                tsc.SetAdditionalOptions(true);
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff - 1);
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE, 2, di));
-       
+
                tsc.SetAdditionalOptions(true);
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime - (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff - 1);
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE, 2, di));
-       
+
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
                tsc.SetAdditionalOptions(false);
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime;
@@ -145,19 +337,19 @@ namespace
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime;
                di.diffFileInfo[2].mtime = di.diffFileInfo[0].mtime + (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff - 1);
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE, 3, di));
-       
+
                tsc.SetAdditionalOptions(true);
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff - 1);
                di.diffFileInfo[2].mtime = di.diffFileInfo[0].mtime;
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE, 3, di));
-       
+
                tsc.SetAdditionalOptions(true);
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime;
                di.diffFileInfo[2].mtime = di.diffFileInfo[0].mtime - (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff - 1);
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE, 3, di));
-       
+
                tsc.SetAdditionalOptions(true);
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime - (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff - 1);
@@ -170,43 +362,49 @@ namespace
                CompareEngines::TimeSizeCompare tsc;
                DIFFITEM di;
 
-               di.diffFileInfo[0].size = 1;
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = 0;
                di.diffFileInfo[1].size = 1;
-               di.diffFileInfo[2].size = 1;
+               di.diffFileInfo[2].size = 2;
 
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + 1;
                tsc.SetAdditionalOptions(false);
                EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE, 2, di));
-       
+
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff + 1);
                tsc.SetAdditionalOptions(true);
                EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE, 2, di));
-       
+
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime - (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff + 1);
                tsc.SetAdditionalOptions(true);
                EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE, 2, di));
-       
+
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + 1;
                di.diffFileInfo[2].mtime = di.diffFileInfo[0].mtime;
                tsc.SetAdditionalOptions(false);
                EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF2NDONLY, tsc.CompareFiles(CMP_DATE, 3, di));
-       
+
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime;
                di.diffFileInfo[2].mtime = di.diffFileInfo[0].mtime + 1;
                tsc.SetAdditionalOptions(false);
                EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF3RDONLY, tsc.CompareFiles(CMP_DATE, 3, di));
-       
+
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + 1;
                di.diffFileInfo[2].mtime = di.diffFileInfo[1].mtime;
                tsc.SetAdditionalOptions(false);
                EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_DATE, 3, di));
-       
+
                di.diffFileInfo[0].mtime = Poco::Timestamp();
                di.diffFileInfo[1].mtime = di.diffFileInfo[0].mtime + (Poco::Timestamp::resolution() * CompareEngines::TimeSizeCompare::SmallTimeDiff + 1);
                di.diffFileInfo[2].mtime = di.diffFileInfo[1].mtime;
@@ -214,44 +412,183 @@ namespace
                EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_DATE, 3, di));
        }
 
+       TEST_F(TimeSizeCompareTest, TimeCompare_UniqueFile)
+       {
+               CompareEngines::TimeSizeCompare tsc;
+               DIFFITEM di;
+
+               di.diffFileInfo[0].size = 0;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = 2;
+
+               di.diffcode.setSideNone();
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE, 2, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE, 2, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE, 2, di));
+
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
+               di.diffcode.setSideNone();
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF2NDONLY, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF3RDONLY, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 2;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 2;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 2;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF2NDONLY, tsc.CompareFiles(CMP_DATE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF3RDONLY, tsc.CompareFiles(CMP_DATE, 3, di));
+       }
+
        TEST_F(TimeSizeCompareTest, TimeCompare_TimeError)
        {
                CompareEngines::TimeSizeCompare tsc;
                DIFFITEM di;
 
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
                di.diffFileInfo[0].mtime = 0;
                di.diffFileInfo[1].mtime = 0;
                tsc.SetAdditionalOptions(true);
                EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE, 2, di));
 
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
                di.diffFileInfo[0].mtime = 1;
                di.diffFileInfo[1].mtime = 0;
                tsc.SetAdditionalOptions(true);
                EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE, 2, di));
 
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
                di.diffFileInfo[0].mtime = 0;
                di.diffFileInfo[1].mtime = 1;
                tsc.SetAdditionalOptions(true);
                EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE, 2, di));
 
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
                di.diffFileInfo[0].mtime = 0;
                di.diffFileInfo[1].mtime = 0;
                di.diffFileInfo[2].mtime = 0;
                tsc.SetAdditionalOptions(true);
                EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE, 3, di));
 
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
                di.diffFileInfo[0].mtime = 0;
                di.diffFileInfo[1].mtime = 1;
                di.diffFileInfo[2].mtime = 1;
                tsc.SetAdditionalOptions(true);
                EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE, 3, di));
 
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
                di.diffFileInfo[0].mtime = 1;
                di.diffFileInfo[1].mtime = 0;
                di.diffFileInfo[2].mtime = 1;
                tsc.SetAdditionalOptions(true);
                EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE, 3, di));
 
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
                di.diffFileInfo[0].mtime = 1;
                di.diffFileInfo[1].mtime = 1;
                di.diffFileInfo[2].mtime = 0;
@@ -264,6 +601,9 @@ namespace
                CompareEngines::TimeSizeCompare tsc;
                DIFFITEM di;
 
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
                di.diffFileInfo[0].size = 1;
                di.diffFileInfo[1].size = 1;
                di.diffFileInfo[0].mtime = Poco::Timestamp();
@@ -271,6 +611,9 @@ namespace
                tsc.SetAdditionalOptions(false);
                EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE_SIZE, 2, di));
        
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
                di.diffFileInfo[0].size = 1;
                di.diffFileInfo[1].size = 1;
                di.diffFileInfo[2].size = 1;
@@ -286,6 +629,10 @@ namespace
                CompareEngines::TimeSizeCompare tsc;
                DIFFITEM di;
 
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+
                di.diffFileInfo[0].size = 1;
                di.diffFileInfo[1].size = 1;
                di.diffFileInfo[0].mtime = Poco::Timestamp();
@@ -300,6 +647,9 @@ namespace
                tsc.SetAdditionalOptions(false);
                EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE_SIZE, 2, di));
        
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
                di.diffFileInfo[0].size = 1;
                di.diffFileInfo[1].size = 1;
                di.diffFileInfo[2].size = 1;
@@ -355,4 +705,238 @@ namespace
                EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
        }
 
+       TEST_F(TimeSizeCompareTest, TimeSizeCompare_UniqueFile)
+       {
+               CompareEngines::TimeSizeCompare tsc;
+               DIFFITEM di;
+
+               di.diffcode.setSideNone();
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE_SIZE, 2, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE_SIZE, 2, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE_SIZE, 2, di));
+
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
+               di.diffcode.setSideNone();
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::SAME, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = 1;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = 1;
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF2NDONLY, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF3RDONLY, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = 1;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 2;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = 1;
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 2;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 2;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(0);
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 0;
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF1STONLY, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF2NDONLY, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideNone();
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = 1;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 1;
+               tsc.SetAdditionalOptions(false);
+               EXPECT_EQ(DIFFCODE::DIFF | DIFFCODE::DIFF3RDONLY, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+       }
+
+       TEST_F(TimeSizeCompareTest, TimeSizeCompare_TimeError)
+       {
+               CompareEngines::TimeSizeCompare tsc;
+               DIFFITEM di;
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 0;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE_SIZE, 2, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 0;
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE_SIZE, 2, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffFileInfo[0].size = 0;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE_SIZE, 2, di));
+
+               di.diffcode.setSideFlag(2);
+               di.diffcode.diffcode |= DIFFCODE::THREEWAY;
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = 1;
+               di.diffFileInfo[0].mtime = 0;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 1;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[2].size = 1;
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 0;
+               di.diffFileInfo[2].mtime = 1;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+
+               di.diffcode.setSideFlag(0);
+               di.diffcode.setSideFlag(1);
+               di.diffcode.setSideFlag(2);
+               di.diffFileInfo[0].size = 1;
+               di.diffFileInfo[1].size = 1;
+               di.diffFileInfo[2].size = DirItem::FILE_SIZE_NONE;
+               di.diffFileInfo[0].mtime = 1;
+               di.diffFileInfo[1].mtime = 1;
+               di.diffFileInfo[2].mtime = 0;
+               tsc.SetAdditionalOptions(true);
+               EXPECT_EQ(DIFFCODE::CMPERR, tsc.CompareFiles(CMP_DATE_SIZE, 3, di));
+       }
+
 }  // namespace