LCOV - code coverage report
Current view: top level - src/libs/tools/tests - testtool_mergeresult.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 76 76 100.0 %
Date: 2019-09-12 12:28:41 Functions: 16 30 53.3 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for the Mergeresult class
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #include <gtest/gtest.h>
      11             : #include <iostream>
      12             : #include <kdb.hpp>
      13             : #include <merging/mergeresult.hpp>
      14             : #include <string>
      15             : 
      16             : 
      17             : using namespace std;
      18             : using namespace kdb;
      19             : using namespace kdb::tools::merging;
      20             : 
      21          20 : TEST (MergeResult, ResolveConflictDeletesConflictMeta)
      22             : {
      23           4 :         MergeResult result;
      24             :         Key conflictKey = Key ("user/test/config/key1", KEY_VALUE, "testvalue", KEY_META, "conflict/operation/our", "delete", KEY_META,
      25           4 :                                "conflict/operation/their", "modify", KEY_META, "conflict/test", "testvalue", KEY_END);
      26             : 
      27           4 :         Key test = Key ("", KEY_END);
      28             : 
      29           2 :         result.resolveConflict (conflictKey);
      30             : 
      31          18 :         EXPECT_FALSE (conflictKey.getMeta<const Key> ("conflict/operation/our"));
      32          18 :         EXPECT_FALSE (conflictKey.getMeta<const Key> ("conflict/operation/their"));
      33          18 :         EXPECT_FALSE (conflictKey.getMeta<const Key> ("conflict/test"));
      34           2 : }
      35             : 
      36          20 : TEST (MergeResult, ResolveConflictIgnoresOtherMeta)
      37             : {
      38           4 :         MergeResult result;
      39             :         Key conflictKey = Key ("user/test/config/key1", KEY_VALUE, "testvalue", KEY_META, "order", "10", KEY_META, "noconflict/data",
      40           4 :                                "testvalue", KEY_END);
      41             : 
      42           2 :         result.resolveConflict (conflictKey);
      43             : 
      44          14 :         EXPECT_EQ ("10", conflictKey.getMeta<string> ("order"));
      45          14 :         EXPECT_EQ ("testvalue", conflictKey.getMeta<string> ("noconflict/data"));
      46           2 : }
      47             : 
      48          20 : TEST (MergeResult, ResolveConflictRemovesKeyFromConflicts)
      49             : {
      50           4 :         Key conflictKey = Key ("user/test/config/key1", KEY_VALUE, "testvalue", KEY_END);
      51           4 :         KeySet conflicts;
      52           2 :         conflicts.append (conflictKey);
      53           4 :         KeySet merged;
      54           4 :         MergeResult result (conflicts, merged);
      55             : 
      56           2 :         result.resolveConflict (conflictKey);
      57             : 
      58          10 :         EXPECT_EQ (0, result.getConflictSet ().size ());
      59           2 : }
      60             : 
      61          20 : TEST (MergeResult, HasConflictsWorks)
      62             : {
      63           4 :         Key conflictKey = Key ("user/test/config/key1", KEY_END);
      64           4 :         KeySet conflicts;
      65           2 :         conflicts.append (conflictKey);
      66           4 :         KeySet merged;
      67           4 :         MergeResult result (conflicts, merged);
      68           6 :         EXPECT_TRUE (result.hasConflicts ());
      69           6 :         conflicts = KeySet ();
      70           6 :         result = MergeResult (merged, conflicts);
      71           6 :         EXPECT_FALSE (result.hasConflicts ());
      72           2 : }
      73             : 
      74          20 : TEST (MergeResult, IsConflictWorks)
      75             : {
      76           4 :         Key conflictKey = Key ("user/test/config/key1", KEY_END);
      77           4 :         KeySet conflicts;
      78           2 :         conflicts.append (conflictKey);
      79           4 :         KeySet merged;
      80           4 :         MergeResult result (conflicts, merged);
      81           6 :         EXPECT_TRUE (result.isConflict (conflictKey));
      82           8 :         EXPECT_FALSE (result.isConflict (Key ("user/test/config/key2", KEY_END)));
      83           2 : }
      84             : 
      85          20 : TEST (MergeResult, CountsResolvedKeysCorrectly)
      86             : {
      87           4 :         Key conflictKey1 = Key ("user/test/config/key1", KEY_END);
      88           4 :         Key conflictKey2 = Key ("user/test/config/key2", KEY_END);
      89           4 :         KeySet conflicts;
      90           2 :         conflicts.append (conflictKey1);
      91           2 :         conflicts.append (conflictKey2);
      92           4 :         KeySet merged;
      93           4 :         MergeResult result (conflicts, merged);
      94           6 :         EXPECT_EQ (0, result.getNumberOfResolvedKeys ());
      95           2 :         result.resolveConflict (conflictKey1);
      96           2 :         result.resolveConflict (conflictKey2);
      97           6 :         EXPECT_EQ (2, result.getNumberOfResolvedKeys ());
      98           2 : }
      99             : 
     100          20 : TEST (MergeResult, CountsEqualKeysCorrectly)
     101             : {
     102           4 :         Key mergedKey1 = Key ("user/test/config/key1", KEY_END);
     103           4 :         Key mergedKey2 = Key ("user/test/config/key2", KEY_END);
     104           4 :         Key mergedKey3 = Key ("user/test/config/key3", KEY_END);
     105           4 :         Key conflictKey1 = Key ("user/test/config/key4", KEY_END);
     106           4 :         KeySet conflicts;
     107           2 :         conflicts.append (conflictKey1);
     108           4 :         KeySet merged;
     109           2 :         merged.append (mergedKey1);
     110           2 :         merged.append (mergedKey2);
     111           4 :         MergeResult result (conflicts, merged);
     112           6 :         EXPECT_EQ (2, result.getNumberOfEqualKeys ()) << "Initially merged keys not counted";
     113           2 :         result.resolveConflict (conflictKey1);
     114           2 :         result.addMergeKey (conflictKey1);
     115           6 :         EXPECT_EQ (2, result.getNumberOfEqualKeys ()) << "Resolved key is counted as equal key";
     116           2 :         result.addMergeKey (mergedKey3);
     117           6 :         EXPECT_EQ (3, result.getNumberOfEqualKeys ()) << "Merged key is not counted as equal key";
     118           8 : }

Generated by: LCOV version 1.13