init

test/Intdifftest.cpp

@@ -0,0 +1,144 @@
+#include "dtl_test_common.hpp"
+
+class Intdifftest : public ::testing::Test
+{
+protected :
+    dtl_test_typedefs(int, vector< int >)
+    typedef struct case_t {
+        sequence   A;
+        sequence   B;
+        size_t     editdis;
+        elemVec    lcs_v;
+        sequence   lcs_s;
+        sesElemVec ses_seq;
+        uniHunkVec hunk_v;
+        size_t     editdis_ses;
+        size_t     editdis_uni;
+        string     path_rses;
+        string     path_rhunks;
+    } case_t;
+    typedef vector< case_t > caseVec;
+    caseVec cases;
+    
+    case_t createCase (const sequence a, const sequence b, string test_name) {
+        case_t c;
+        string diff_name("intdiff");
+        Diff< elem > diff(a, b);
+        diff.compose();
+        diff.composeUnifiedHunks();
+        
+        if (test_name != "") {
+            string path_lses   = create_path(test_name, diff_name, TYPE_DIFF_SES);
+            string path_rses   = create_path(test_name, diff_name, TYPE_DIFF_SES, true);
+            string path_lhunks = create_path(test_name, diff_name, TYPE_DIFF_UNI);
+            string path_rhunks = create_path(test_name, diff_name, TYPE_DIFF_UNI, true);
+
+            create_file< elem, sequence, Compare< elem > >(path_rses,   diff, TYPE_DIFF_SES);
+            create_file< elem, sequence, Compare< elem > >(path_rhunks, diff, TYPE_DIFF_UNI);
+            c.editdis_ses = cal_diff_uni(path_lses,   path_rses);
+            c.editdis_uni = cal_diff_uni(path_lhunks, path_rhunks);
+            c.path_rses   = path_rses;
+            c.path_rhunks = path_rhunks;
+        }
+
+
+        c.A = a;
+        c.B = b;
+        c.editdis = diff.getEditDistance();
+        c.lcs_v   = diff.getLcsVec();
+        c.ses_seq = diff.getSes().getSequence();
+        return c;
+    }
+    
+    void SetUp() {
+        cases.push_back(createCase(sequence(0), sequence(0), "diff_test0"));
+        sequence B1;
+        B1.push_back(1);
+        cases.push_back(createCase(sequence(0), B1, "diff_test1"));
+        sequence A2;
+        A2.push_back(1);
+        cases.push_back(createCase(A2, sequence(0), "diff_test2"));
+        int a4[]   = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int b4[]   = {3, 5, 1, 4, 5, 1, 7, 9, 6, 10};
+        int a4siz  = sizeof(a4) / sizeof(int);
+        int b4siz  = sizeof(b4) / sizeof(int);
+        sequence A4(&a4[0], &a4[a4siz]);
+        sequence B4(&b4[0], &b4[b4siz]);
+        cases.push_back(createCase(A4, B4, "diff_test3"));
+        int a5[]   = {1, 2, 3, 4, 5};
+        int b5[]   = {3, 5, 1, 4, 5};
+        int a5siz  = sizeof(a5) / sizeof(int);
+        int b5siz  = sizeof(b5) / sizeof(int);
+        sequence A5(&a5[0], &a5[a5siz]);
+        sequence B5(&b5[0], &b5[b5siz]);
+        cases.push_back(createCase(A5, B5, "diff_test4"));
+    }
+    
+    void TearDown () {
+        for_each(cases.begin(), cases.end(), Remover< case_t >());
+    }
+    
+};
+
+/**
+ * Intdifftest
+ * check list is following
+ * - editdistance
+ * - LCS
+ * - SES
+ */
+TEST_F (Intdifftest, diff_test0) {
+    EXPECT_EQ(0, cases[0].editdis);
+    
+    EXPECT_TRUE(cases[0].lcs_v.empty());
+    
+    ASSERT_EQ(0, cases[0].editdis_ses);
+
+    ASSERT_EQ(0, cases[0].editdis_uni);
+}
+
+TEST_F (Intdifftest, diff_test1) {
+    EXPECT_EQ(1, cases[1].editdis);
+    
+    EXPECT_TRUE(cases[1].lcs_v.empty());
+    
+    ASSERT_EQ(0, cases[1].editdis_ses);
+
+    ASSERT_EQ(0, cases[1].editdis_uni);
+}
+
+TEST_F (Intdifftest, diff_test2) {
+    EXPECT_EQ(1, cases[2].editdis);
+    
+    EXPECT_TRUE(cases[2].lcs_v.empty());
+    
+    ASSERT_EQ(0, cases[2].editdis_ses);
+
+    ASSERT_EQ(0, cases[2].editdis_uni);
+}
+
+TEST_F (Intdifftest, diff_test3) {
+    EXPECT_EQ(8, cases[3].editdis);
+    
+    EXPECT_EQ(3, cases[3].lcs_v[0]);
+    EXPECT_EQ(4, cases[3].lcs_v[1]);
+    EXPECT_EQ(5, cases[3].lcs_v[2]);
+    EXPECT_EQ(7, cases[3].lcs_v[3]);
+    EXPECT_EQ(9, cases[3].lcs_v[4]);
+    
+    ASSERT_EQ(0, cases[3].editdis_ses);
+
+    ASSERT_EQ(0, cases[3].editdis_uni);
+}
+
+TEST_F (Intdifftest, diff_test4) {
+    EXPECT_EQ(4, cases[4].editdis);
+    
+    EXPECT_EQ(3, cases[4].lcs_v[0]);
+    EXPECT_EQ(4, cases[4].lcs_v[1]);
+    EXPECT_EQ(5, cases[4].lcs_v[2]);
+    
+    ASSERT_EQ(0, cases[4].editdis_ses);
+
+    ASSERT_EQ(0, cases[4].editdis_uni);
+}

test/Objdifftest.cpp

@@ -0,0 +1,116 @@
+#include "dtl_test_common.hpp"
+#include "comparators.hpp"
+
+class Objdifftest : public ::testing::Test
+{
+protected :
+    dtl_test_typedefs(string, vector<elem>)
+    typedef struct case_t {
+        sequence   A;
+        sequence   B;
+        sesElemVec expected;
+        sesElemVec ses_seq;
+    } case_t;
+    typedef vector< case_t > caseVec;
+    
+    caseVec obj_diff_cases;
+    
+    template < typename comparator >
+    case_t createCase (const sequence a, const sequence b, sesElemVec ses, string test_name) {
+        case_t  c;
+        elemVec lcs_v;
+        string  diff_name("objdiff");
+
+        Diff< elem, sequence, comparator > diff(a, b, true);
+
+        diff.compose();
+        
+        c.A         = a;
+        c.B         = b;
+        c.ses_seq   = diff.getSes().getSequence();
+        c.expected  = ses;
+        
+        return c;
+    }
+    
+    void SetUp(void) {
+        {
+            string array1[] = {"the", "quick", "brown"};
+            string array2[] = {"The", "Quick", "Fox"};
+            
+            sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0])));
+            sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0])));
+            
+            dtl::Ses< elem > ses;
+            ses.addSequence("the", 1, 1, dtl::SES_COMMON);
+            ses.addSequence("quick", 2, 2, dtl::SES_COMMON);
+            ses.addSequence("brown", 3, 0, dtl::SES_DELETE);
+            ses.addSequence("Fox", 0, 3, dtl::SES_ADD);
+            
+            obj_diff_cases.push_back(createCase< StringCaseInsensitive >(A, B, ses.getSequence(), "objdiff_test0_pattern"));
+        }
+        
+        {
+            string array1[] = {"b", "c", "e", "g"};
+            string array2[] = {"a", "d", "e", "f", "h"};
+            
+            sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0])));
+            sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0])));
+            
+            dtl::Ses< elem > ses;
+            ses.addSequence("b", 1, 0, dtl::SES_DELETE);
+            ses.addSequence("c", 2, 0, dtl::SES_DELETE);
+            ses.addSequence("a", 0, 1, dtl::SES_ADD);
+            ses.addSequence("d", 0, 2, dtl::SES_ADD);
+            ses.addSequence("e", 3, 3, dtl::SES_COMMON);
+            ses.addSequence("g", 4, 0, dtl::SES_DELETE);
+            ses.addSequence("f", 0, 4, dtl::SES_ADD);
+            ses.addSequence("h", 0, 5, dtl::SES_ADD);
+            
+            obj_diff_cases.push_back(createCase< StringCaseInsensitive >(A, B, ses.getSequence(), "objdiff_test1_unswapped"));
+        }
+        {
+            string array1[] = {"a", "d", "e", "f", "h"};
+            string array2[] = {"b", "c", "e", "g"};
+            
+            sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0])));
+            sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0])));
+            
+            dtl::Ses< elem > ses;
+            ses.addSequence("a", 1, 0, dtl::SES_DELETE);
+            ses.addSequence("d", 2, 0, dtl::SES_DELETE);
+            ses.addSequence("b", 0, 1, dtl::SES_ADD);
+            ses.addSequence("c", 0, 2, dtl::SES_ADD);
+            ses.addSequence("e", 3, 3, dtl::SES_COMMON);
+            ses.addSequence("f", 4, 0, dtl::SES_DELETE);
+            ses.addSequence("h", 5, 0, dtl::SES_DELETE);
+            ses.addSequence("g", 0, 4, dtl::SES_ADD);
+            
+            obj_diff_cases.push_back(createCase< StringCaseInsensitive >(A, B, ses.getSequence(), "objdiff_test2_swapped"));
+        }
+    }
+    
+    void TearDown () {
+        //for_each(obj_diff_cases.begin(), obj_diff_cases.end(), Remover< case_t >());
+    }
+};
+
+
+/**
+ * Objdifftest
+ * check list:
+ * - SES pattern "SES_COMMON, SES_DELETE, SES_ADD"
+ * - Indepence of results from swapping 
+ */
+
+TEST_F (Objdifftest, objdiff_test0_pattern) {
+    EXPECT_EQ(obj_diff_cases[0].expected, obj_diff_cases[0].ses_seq);
+}
+
+TEST_F (Objdifftest, objdiff_test1_unswapped) {
+    EXPECT_EQ(obj_diff_cases[1].expected, obj_diff_cases[1].ses_seq);
+}
+
+TEST_F (Objdifftest, objdiff_test2_swapped) {
+    EXPECT_EQ(obj_diff_cases[2].expected, obj_diff_cases[2].ses_seq);
+}

test/Patchtest.cpp

@@ -0,0 +1,98 @@
+#include "dtl_test_common.hpp"
+
+class Patchtest : public ::testing::Test
+{
+protected :
+    dtl_test_typedefs(char, string)
+    typedef struct case_t {
+        sequence A;
+        sequence B;
+        Diff< elem, sequence > diff;
+    } case_t;
+    typedef vector< case_t > caseVec;
+    
+    caseVec cases;
+    
+    case_t createCase (sequence a, sequence b) {
+        case_t c;
+        c.A = a;
+        c.B = b;
+        c.diff = Diff< elem, sequence >(a, b);
+        c.diff.compose();
+        c.diff.composeUnifiedHunks();
+        return c;
+    }
+    
+    void SetUp() {
+        cases.push_back(createCase("abc",           "abd"));           // 0
+        cases.push_back(createCase("acbdeacbed",    "acebdabbabed"));  // 1
+        cases.push_back(createCase("abcdef",        "dacfea"));        // 2
+        cases.push_back(createCase("abcbda",        "bdcaba"));        // 3
+        cases.push_back(createCase("bokko",         "bokkko"));        // 4
+        cases.push_back(createCase("",              ""));              // 5
+        cases.push_back(createCase("a",             ""));              // 6
+        cases.push_back(createCase("",              "b"));             // 7
+        cases.push_back(createCase("abcdefq3wefarhgorequgho4euhfteowauhfwehogfewrquhoi23hroewhoahfotrhguoiewahrgqqabcdef",
+                                   "3abcdef4976fd86ouofita67t85r876e5e746578tgliuhopoqqabcdef")); // 8
+        cases.push_back(createCase("abcqqqeqqqccc", "abdqqqeqqqddd")); // 9
+    }
+    
+    void TearDown () {}
+    
+};
+
+/**
+ * Patchtest
+ * check list is following
+ * - patch function
+ * - uniPatch function
+ */
+TEST_F (Patchtest, patch_test0) {
+    ASSERT_EQ(cases[0].B, cases[0].diff.patch(cases[0].A));
+    ASSERT_EQ(cases[0].B, cases[0].diff.uniPatch(cases[0].A));
+}
+
+TEST_F (Patchtest, patch_test1) {
+    ASSERT_EQ(cases[1].B, cases[1].diff.patch(cases[1].A));
+    ASSERT_EQ(cases[1].B, cases[1].diff.uniPatch(cases[1].A));
+}
+
+TEST_F (Patchtest, patch_test2) {
+    ASSERT_EQ(cases[2].B, cases[2].diff.patch(cases[2].A));
+    ASSERT_EQ(cases[2].B, cases[2].diff.uniPatch(cases[2].A));
+}
+
+TEST_F (Patchtest, patch_test3) {
+    ASSERT_EQ(cases[3].B, cases[3].diff.patch(cases[3].A));
+    ASSERT_EQ(cases[3].B, cases[3].diff.uniPatch(cases[3].A));
+}
+
+TEST_F (Patchtest, patch_test4) {
+    ASSERT_EQ(cases[4].B, cases[4].diff.patch(cases[4].A));
+    ASSERT_EQ(cases[4].B, cases[4].diff.uniPatch(cases[4].A));
+}
+
+TEST_F (Patchtest, patch_test5) {
+    ASSERT_EQ(cases[5].B, cases[5].diff.patch(cases[5].A));
+    ASSERT_EQ(cases[5].B, cases[5].diff.uniPatch(cases[5].A));
+}
+
+TEST_F (Patchtest, patch_test6) {
+    ASSERT_EQ(cases[6].B, cases[6].diff.patch(cases[6].A));
+    ASSERT_EQ(cases[6].B, cases[6].diff.uniPatch(cases[6].A));
+}
+
+TEST_F (Patchtest, patch_test7) {
+    ASSERT_EQ(cases[7].B, cases[7].diff.patch(cases[7].A));
+    ASSERT_EQ(cases[7].B, cases[7].diff.uniPatch(cases[7].A));
+}
+
+TEST_F (Patchtest, patch_test8) {
+    ASSERT_EQ(cases[8].B, cases[8].diff.patch(cases[8].A));
+    ASSERT_EQ(cases[8].B, cases[8].diff.uniPatch(cases[8].A));
+}
+
+TEST_F (Patchtest, patch_test9) {
+    ASSERT_EQ(cases[9].B, cases[9].diff.patch(cases[9].A));
+    ASSERT_EQ(cases[9].B, cases[9].diff.uniPatch(cases[9].A));
+}

test/SConstruct

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+# SConstrunct for dtl test
+
+import os
+
+def path_chomp(path):
+    if path[-1] == '/':
+        return path[:-1]
+    return path
+
+if not 'GTEST_ROOT' in os.environ:
+    print "set environment variable 'GTEST_ROOT'"
+    Exit(1)
+
+gtest_root = path_chomp(os.environ['GTEST_ROOT'])
+if gtest_root[-1] == '/':
+    gtest_root     = gtest_root[:-1]
+
+gtest_includes = gtest_root + '/include'
+gtest_libs     = gtest_root + '/lib/.libs'
+
+flags    = ['-Wall', '-O2']
+libs     = ['stdc++', 'pthread']
+includes = ['..', gtest_includes]
+target   = 'dtl_test'
+
+env  = Environment(CPPFLAGS=flags,
+                   CPPPATH=includes,
+                   LIBPATH=[gtest_libs],
+                   )
+
+conf = Configure(env);
+
+if not conf.CheckCXX():
+    print "c++ compiler is not installed!"
+    Exit(1)
+
+for lib in libs:
+    if not conf.CheckLib(lib):
+        print "library " + lib + " not installed!"
+        Exit(1)
+
+conf.Finish()
+
+test = env.Program(target,
+                   [Glob('*.cpp'), gtest_libs + '/libgtest.a']
+                   )
+
+test_alias = env.Alias('check',
+                       test,
+                       test[0].abspath)
+
+env.AlwaysBuild(test_alias)

test/Strdiff3test.cpp

@@ -0,0 +1,208 @@
+#include "dtl_test_common.hpp"
+#include "comparators.hpp"
+
+class Strdiff3test : public ::testing::Test
+{
+protected :
+    dtl_test_typedefs(char, string)
+    typedef struct case_t {
+        sequence S;
+        bool     is_merge_success;
+        sequence merged_seq;
+    } case_t;
+    typedef vector< case_t > caseVec;
+    
+    caseVec merge_cases;
+    caseVec detect_cases;
+    caseVec custom_cases;
+    
+    template < typename comparator >
+    case_t createCase (sequence a, sequence b, sequence c, sequence s) {
+        Diff3< elem, sequence, comparator > diff3(a, b, c);
+        case_t ct;
+
+        diff3.compose();
+
+        ct.S                = s;
+        ct.is_merge_success = diff3.merge();
+        ct.merged_seq       = diff3.getMergedSequence();
+        return ct;
+    }
+    
+    void SetUp() {
+        // merge test
+        merge_cases.push_back(createCase< Compare < elem > >("ab",            "b",             "bc",           "abc"));              // 0
+        merge_cases.push_back(createCase< Compare < elem > >("bc",            "b",             "ab",           "abc"));              // 1
+        merge_cases.push_back(createCase< Compare < elem > >("qqqabc",        "abc",           "abcdef",       "qqqabcdef"));        // 2
+        merge_cases.push_back(createCase< Compare < elem > >("abcdef",        "abc",           "qqqabc",       "qqqabcdef"));        // 3
+        merge_cases.push_back(createCase< Compare < elem > >("aaacccbbb",     "aaabbb",        "aaabbbqqq",    "aaacccbbbqqq"));     // 4
+        merge_cases.push_back(createCase< Compare < elem > >("aaabbbqqq",     "aaabbb",        "aaacccbbb",    "aaacccbbbqqq"));     // 5
+        merge_cases.push_back(createCase< Compare < elem > >("aeaacccbbb",    "aaabbb",        "aaabbbqqq",    "aeaacccbbbqqq"));    // 6
+        merge_cases.push_back(createCase< Compare < elem > >("aaabbbqqq",     "aaabbb",        "aeaacccbbb",   "aeaacccbbbqqq"));    // 7
+        merge_cases.push_back(createCase< Compare < elem > >("aeaacccbbb",    "aaabbb",        "aaabebbqqq",   "aeaacccbebbqqq"));   // 8
+        merge_cases.push_back(createCase< Compare < elem > >("aaabebbqqq",    "aaabbb",        "aeaacccbbb",   "aeaacccbebbqqq"));   // 9
+        merge_cases.push_back(createCase< Compare < elem > >("aaacccbbb",     "aaabbb",        "aeaabbbqqq",   "aeaacccbbbqqq"));    // 10
+        merge_cases.push_back(createCase< Compare < elem > >("aeaabbbqqq",    "aaabbb",        "aaacccbbb",    "aeaacccbbbqqq"));    // 11
+        merge_cases.push_back(createCase< Compare < elem > >("aaacccbbb",     "aaabbb",        "aaabeebbeeqqq","aaacccbeebbeeqqq")); // 12
+        merge_cases.push_back(createCase< Compare < elem > >("aaabeebbeeqqq", "aaabbb",        "aaacccbbb",    "aaacccbeebbeeqqq")); // 13
+        merge_cases.push_back(createCase< Compare < elem > >("aiueo",         "aeo",           "aeKokaki",     "aiueKokaki"));       // 14
+        merge_cases.push_back(createCase< Compare < elem > >("aeKokaki",      "aeo",           "aiueo",        "aiueKokaki"));       // 15
+        merge_cases.push_back(createCase< Compare < elem > >("1234567390",    "1234567890",    "1239567890",   "1239567390"));       // 16
+        merge_cases.push_back(createCase< Compare < elem > >("1239567890",    "1234567890",    "1234567390",   "1239567390"));       // 17
+        merge_cases.push_back(createCase< Compare < elem > >("qabcdef",       "abcdef",        "ab",           "qab"));              // 18
+        merge_cases.push_back(createCase< Compare < elem > >("ab",            "abcdef",        "qabcdef",      "qab"));              // 19
+        merge_cases.push_back(createCase< Compare < elem > >("abcdf",         "abcdef",        "acdef",        "acdf"));             // 20
+        merge_cases.push_back(createCase< Compare < elem > >("acdef",         "abcdef",        "abcdf",        "acdf"));             // 21
+        merge_cases.push_back(createCase< Compare < elem > >("acdef",         "abcdef",        "abcdfaa",      "acdfaa"));           // 22
+        merge_cases.push_back(createCase< Compare < elem > >("abcdfaa",       "abcdef",        "acdef",        "acdfaa"));           // 23
+        
+        // detect confliction test
+        detect_cases.push_back(createCase< Compare < elem > >("adc",           "abc",          "aec",          ""));                 // 0
+        detect_cases.push_back(createCase< Compare < elem > >("abqdcf",        "abcdef",       "abqqef",       ""));                 // 1
+        
+        // use custom comparator
+        custom_cases.push_back(createCase< CaseInsensitive >("abc", "abc", "abC", "abc"));
+    }
+    
+    void TearDown () {}
+    
+};
+
+/**
+ * Strdiff3test
+ * check list is following
+ * - merge function
+ * - detect confliction
+ */
+TEST_F (Strdiff3test, merge_test0) {
+    ASSERT_TRUE(merge_cases[0].is_merge_success);
+    ASSERT_EQ(merge_cases[0].S, merge_cases[0].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test1) {
+    ASSERT_TRUE(merge_cases[1].is_merge_success);
+    ASSERT_EQ(merge_cases[1].S, merge_cases[1].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test2) {
+    ASSERT_TRUE(merge_cases[2].is_merge_success);
+    ASSERT_EQ(merge_cases[2].S, merge_cases[2].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test3) {
+    ASSERT_TRUE(merge_cases[3].is_merge_success);
+    ASSERT_EQ(merge_cases[3].S, merge_cases[3].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test4) {
+    ASSERT_TRUE(merge_cases[4].is_merge_success);
+    ASSERT_EQ(merge_cases[4].S, merge_cases[4].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test5) {
+    ASSERT_TRUE(merge_cases[5].is_merge_success);
+    ASSERT_EQ(merge_cases[5].S, merge_cases[5].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test6) {
+    ASSERT_TRUE(merge_cases[6].is_merge_success);
+    ASSERT_EQ(merge_cases[6].S, merge_cases[6].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test7) {
+    ASSERT_TRUE(merge_cases[7].is_merge_success);
+    ASSERT_EQ(merge_cases[7].S, merge_cases[7].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test8) {
+    ASSERT_TRUE(merge_cases[8].is_merge_success);
+    ASSERT_EQ(merge_cases[8].S, merge_cases[8].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test9) {
+    ASSERT_TRUE(merge_cases[9].is_merge_success);
+    ASSERT_EQ(merge_cases[9].S, merge_cases[9].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test10) {
+    ASSERT_TRUE(merge_cases[10].is_merge_success);
+    ASSERT_EQ(merge_cases[10].S, merge_cases[10].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test11) {
+    ASSERT_TRUE(merge_cases[11].is_merge_success);
+    ASSERT_EQ(merge_cases[11].S, merge_cases[11].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test12) {
+    ASSERT_TRUE(merge_cases[12].is_merge_success);
+    ASSERT_EQ(merge_cases[12].S, merge_cases[12].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test13) {
+    ASSERT_TRUE(merge_cases[13].is_merge_success);
+    ASSERT_EQ(merge_cases[13].S, merge_cases[13].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test14) {
+    ASSERT_TRUE(merge_cases[14].is_merge_success);
+    ASSERT_EQ(merge_cases[14].S, merge_cases[14].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test15) {
+    ASSERT_TRUE(merge_cases[15].is_merge_success);
+    ASSERT_EQ(merge_cases[15].S, merge_cases[15].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test16) {
+    ASSERT_TRUE(merge_cases[16].is_merge_success);
+    ASSERT_EQ(merge_cases[16].S, merge_cases[16].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test17) {
+    ASSERT_TRUE(merge_cases[17].is_merge_success);
+    ASSERT_EQ(merge_cases[17].S, merge_cases[17].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test18) {
+    ASSERT_TRUE(merge_cases[18].is_merge_success);
+    ASSERT_EQ(merge_cases[18].S, merge_cases[18].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test19) {
+    ASSERT_TRUE(merge_cases[19].is_merge_success);
+    ASSERT_EQ(merge_cases[19].S, merge_cases[19].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test20) {
+    ASSERT_TRUE(merge_cases[20].is_merge_success);
+    ASSERT_EQ(merge_cases[20].S, merge_cases[20].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test21) {
+    ASSERT_TRUE(merge_cases[21].is_merge_success);
+    ASSERT_EQ( merge_cases[21].S, merge_cases[21].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test22) {
+    ASSERT_TRUE(merge_cases[22].is_merge_success);
+    ASSERT_EQ( merge_cases[22].S, merge_cases[22].merged_seq);
+}
+
+TEST_F (Strdiff3test, merge_test23) {
+    ASSERT_TRUE(merge_cases[23].is_merge_success);
+    ASSERT_EQ(merge_cases[23].S, merge_cases[23].merged_seq);
+}
+
+TEST_F (Strdiff3test, detect_confliction_test0) {
+    ASSERT_FALSE(detect_cases[0].is_merge_success);
+}
+
+TEST_F (Strdiff3test, detect_confliction_test1) {
+    ASSERT_FALSE(detect_cases[1].is_merge_success);
+}
+
+TEST_F (Strdiff3test, custom_comparator_test0) {
+    ASSERT_TRUE(custom_cases[0].is_merge_success);
+    ASSERT_EQ(custom_cases[0].S, custom_cases[0].merged_seq);
+}

test/Strdifftest.cpp

@@ -0,0 +1,299 @@
+#include "dtl_test_common.hpp"
+#include "comparators.hpp"
+
+class Strdifftest : public ::testing::Test
+{
+protected :
+    dtl_test_typedefs(char, string)
+    typedef struct case_t {
+        sequence   A;
+        sequence   B;
+        size_t     editdis;
+        elemVec    lcs_v;
+        sequence   lcs_s;
+        sesElemVec ses_seq;
+        uniHunkVec hunk_v;
+        size_t     editdis_ses;
+        size_t     editdis_uni;
+        string     path_rses;
+        string     path_rhunks;
+    } case_t;
+    typedef vector< case_t > caseVec;
+    
+    caseVec diff_cases;
+    caseVec only_editdis_cases;
+    caseVec custom_cases;
+    
+    template < typename comparator >
+    case_t createCase (const sequence a, const sequence b, string test_name, bool onlyEditdis = false) {
+        case_t  c;
+        elemVec lcs_v;
+        string  diff_name("strdiff");
+
+        Diff< elem, sequence, comparator > diff(a, b);
+        if (onlyEditdis) {
+            diff.onOnlyEditDistance();
+        }
+
+        diff.compose();
+        diff.composeUnifiedHunks();
+        lcs_v = diff.getLcsVec();
+        
+        if (test_name != "") {
+            string path_lses   = create_path(test_name, diff_name, TYPE_DIFF_SES);
+            string path_rses   = create_path(test_name, diff_name, TYPE_DIFF_SES, true);
+            string path_lhunks = create_path(test_name, diff_name, TYPE_DIFF_UNI);
+            string path_rhunks = create_path(test_name, diff_name, TYPE_DIFF_UNI, true);
+            diff_resultset_exist_check(path_lses);
+            diff_resultset_exist_check(path_lhunks);
+            
+            create_file< elem, sequence, comparator >(path_rses,   diff, TYPE_DIFF_SES);
+            create_file< elem, sequence, comparator >(path_rhunks, diff, TYPE_DIFF_UNI);
+            
+            c.editdis_ses = cal_diff_uni(path_lses,   path_rses);
+            c.editdis_uni = cal_diff_uni(path_lhunks, path_rhunks);
+            c.path_rses   = path_rses;
+            c.path_rhunks = path_rhunks;
+        }
+
+        c.A       = a;
+        c.B       = b;
+        c.editdis = diff.getEditDistance();
+        c.lcs_s   = sequence(lcs_v.begin(), lcs_v.end());
+        c.ses_seq = diff.getSes().getSequence();
+        c.hunk_v  = diff.getUniHunks();
+        
+        return c;
+    }
+    
+    void SetUp(void) {
+        diff_cases.push_back(createCase< Compare< elem > >("abc",               "abd",                 "diff_test0"));
+        diff_cases.push_back(createCase< Compare< elem > >("acbdeacbed",        "acebdabbabed",        "diff_test1"));
+        diff_cases.push_back(createCase< Compare< elem > >("abcdef",            "dacfea",              "diff_test2"));
+        diff_cases.push_back(createCase< Compare< elem > >("abcbda",            "bdcaba",              "diff_test3"));
+        diff_cases.push_back(createCase< Compare< elem > >("bokko",             "bokkko",              "diff_test4"));
+        diff_cases.push_back(createCase< Compare< elem > >("",                  "",                    "diff_test5"));
+        diff_cases.push_back(createCase< Compare< elem > >("a",                 "",                    "diff_test6"));
+        diff_cases.push_back(createCase< Compare< elem > >("",                  "b",                   "diff_test7"));
+        diff_cases.push_back(createCase< Compare< elem > >("acbdeaqqqqqqqcbed", "acebdabbqqqqqqqabed", "diff_test8"));
+        
+        only_editdis_cases.push_back(createCase< Compare< elem > >("abc",               "abd",                 "", true));
+        only_editdis_cases.push_back(createCase< Compare< elem > >("acbdeacbed",        "acebdabbabed",        "", true));
+        only_editdis_cases.push_back(createCase< Compare< elem > >("abcdef",            "dacfea",              "", true));
+        only_editdis_cases.push_back(createCase< Compare< elem > >("abcbda",            "bdcaba",              "", true));
+        only_editdis_cases.push_back(createCase< Compare< elem > >("bokko",             "bokkko",              "", true));
+        only_editdis_cases.push_back(createCase< Compare< elem > >("",                  "",                    "", true));
+        only_editdis_cases.push_back(createCase< Compare< elem > >("a",                 "",                    "", true));
+        only_editdis_cases.push_back(createCase< Compare< elem > >("",                  "b",                   "", true));
+        only_editdis_cases.push_back(createCase< Compare< elem > >("acbdeaqqqqqqqcbed", "acebdabbqqqqqqqabed", "", true));
+        
+        custom_cases.push_back(createCase< CaseInsensitive >("abc", "Abc", "custom_test0"));
+    }
+    
+    void TearDown () {
+        for_each(diff_cases.begin(), diff_cases.end(), Remover< case_t >());
+        for_each(custom_cases.begin(), custom_cases.end(), Remover< case_t >());
+    }
+};
+
+
+/**
+ * Strdifftest
+ * check list is following
+ * - editdistance
+ * - LCS
+ * - SES
+ * - Unified Format Difference
+ * - onOnlyEditDistance
+ */
+
+TEST_F (Strdifftest, diff_test0) {
+    
+    EXPECT_EQ(2,    diff_cases[0].editdis);
+    
+    EXPECT_EQ("ab", diff_cases[0].lcs_s);
+    
+    ASSERT_EQ(0,    diff_cases[0].editdis_ses);
+
+    ASSERT_EQ(0,    diff_cases[0].editdis_uni);
+}
+
+TEST_F (Strdifftest, diff_test1) {
+    EXPECT_EQ(6,          diff_cases[1].editdis);
+    
+    EXPECT_EQ("acbdabed", diff_cases[1].lcs_s);
+    
+    ASSERT_EQ(0,          diff_cases[1].editdis_ses);
+    
+    ASSERT_EQ(0,          diff_cases[1].editdis_uni);
+}
+
+TEST_F (Strdifftest, diff_test2) {
+    EXPECT_EQ(6,     diff_cases[2].editdis);
+    
+    EXPECT_EQ("acf", diff_cases[2].lcs_s);
+    
+    ASSERT_EQ(0,     diff_cases[2].editdis_ses);
+    
+    ASSERT_EQ(0,     diff_cases[2].editdis_uni);
+}
+
+TEST_F (Strdifftest, diff_test3) {
+    EXPECT_EQ(4,      diff_cases[3].editdis);
+    
+    EXPECT_EQ("bcba", diff_cases[3].lcs_s);
+    
+    ASSERT_EQ(0,      diff_cases[3].editdis_ses);
+    
+    ASSERT_EQ(0,      diff_cases[3].editdis_uni);
+}
+
+TEST_F (Strdifftest, diff_test4) {
+    EXPECT_EQ(1,       diff_cases[4].editdis);
+    
+    EXPECT_EQ("bokko", diff_cases[4].lcs_s);
+    
+    ASSERT_EQ(0,       diff_cases[4].editdis_ses);
+    
+    ASSERT_EQ(0,       diff_cases[4].editdis_uni);
+}
+
+TEST_F (Strdifftest, diff_test5) {
+    EXPECT_EQ(0,  diff_cases[5].editdis);
+    
+    EXPECT_EQ("", diff_cases[5].lcs_s);
+    
+    ASSERT_EQ(0,  diff_cases[5].editdis_ses);
+    
+    ASSERT_EQ(0,  diff_cases[5].editdis_uni);
+}
+
+TEST_F (Strdifftest, diff_test6) {
+    EXPECT_EQ(1,  diff_cases[6].editdis);
+    
+    EXPECT_EQ("", diff_cases[6].lcs_s);
+    
+    ASSERT_EQ(0,  diff_cases[6].editdis_ses);
+    
+    ASSERT_EQ(0,  diff_cases[6].editdis_uni);
+}
+
+TEST_F (Strdifftest, diff_test7) {
+    EXPECT_EQ(1,  diff_cases[7].editdis);
+    
+    EXPECT_EQ("", diff_cases[7].lcs_s);
+    
+    ASSERT_EQ(0,  diff_cases[7].editdis_ses);
+    
+    ASSERT_EQ(0,  diff_cases[7].editdis_uni);
+}
+
+TEST_F (Strdifftest, diff_test8) {
+    EXPECT_EQ(6,                 diff_cases[8].editdis);
+    
+    EXPECT_EQ("acbdaqqqqqqqbed", diff_cases[8].lcs_s);
+    
+    ASSERT_EQ(0,                 diff_cases[8].editdis_ses);
+
+    ASSERT_EQ(0,                 diff_cases[8].editdis_uni);
+}
+
+TEST_F (Strdifftest, only_editdis_test0) {
+    EXPECT_EQ(2,  only_editdis_cases[0].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[0].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[0].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[0].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, only_editdis_test1) {
+    EXPECT_EQ(6,  only_editdis_cases[1].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[1].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[1].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[1].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, only_editdis_test2) {
+    EXPECT_EQ(6,  only_editdis_cases[2].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[2].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[2].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[2].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, only_editdis_test3) {
+    EXPECT_EQ(4,  only_editdis_cases[3].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[3].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[3].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[3].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, only_editdis_test4) {
+    EXPECT_EQ(1,  only_editdis_cases[4].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[4].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[4].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[4].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, only_editdis_test5) {
+    EXPECT_EQ(0,  only_editdis_cases[5].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[5].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[5].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[5].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, only_editdis_test6) {
+    EXPECT_EQ(1,  only_editdis_cases[6].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[6].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[6].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[6].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, only_editdis_test7) {
+    EXPECT_EQ(1,  only_editdis_cases[7].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[7].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[7].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[7].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, only_editdis_test8) {
+    EXPECT_EQ(6,  only_editdis_cases[8].editdis);
+    
+    EXPECT_EQ("", only_editdis_cases[8].lcs_s);
+    
+    ASSERT_TRUE(only_editdis_cases[8].ses_seq.empty());
+    
+    ASSERT_TRUE(only_editdis_cases[8].hunk_v.empty());
+}
+
+TEST_F (Strdifftest, custom_comparator_test0) {
+    EXPECT_EQ(0,     custom_cases[0].editdis);
+    
+    EXPECT_EQ("abc", custom_cases[0].lcs_s);
+
+    ASSERT_EQ(0,     custom_cases[0].editdis_ses);
+    
+    ASSERT_TRUE(custom_cases[0].hunk_v.empty());
+}

test/comparators.hpp

@@ -0,0 +1,24 @@
+#ifndef DTL_COMPARATORS
+#define DTL_COMPARATORS
+
+class CaseInsensitive: public dtl::Compare<char> {
+public:
+    virtual bool impl(const char& a, const char& b) const {
+        return tolower(a) == tolower(b);
+    }
+};
+
+class StringCaseInsensitive: public dtl::Compare<string> {
+public:
+    virtual bool impl(const string& a, const string& b) const {
+        if (a.length() == b.length()) {
+            bool equal = (strncasecmp(a.c_str(), b.c_str(), a.length()) == 0);
+            return equal;
+        }
+        else {
+            return false;
+        }
+    }
+};
+
+#endif // DTL_COMPARATORS

test/dtl_test.cpp

@@ -0,0 +1,10 @@
+/**
+ * It is necessary to use googletest to run tests.
+ */
+
+#include <gtest/gtest.h>
+
+int main (int argc, char *argv[]) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

test/dtl_test_common.cpp

@@ -0,0 +1,56 @@
+
+#include "dtl_test_common.hpp"
+
+string create_path (const string& test_name, string diff_name, enum type_diff t, bool is_use_suffix) {
+    string ret;
+    switch (t) {
+    case TYPE_DIFF_SES:
+        ret = (getcwd(NULL, 0) + string("/") + string("ses")   + string("/") + diff_name + string("/") + test_name);
+        break;
+    case TYPE_DIFF_UNI:
+        ret = (getcwd(NULL, 0) + string("/") + string("hunks") + string("/") + diff_name + string("/") + test_name);
+        break;
+    }
+    ret += is_use_suffix ? "_" : "";
+    return ret;
+}
+
+size_t cal_diff_uni (const string& path_l, const string& path_r) {
+    string   buf;
+    ifstream lifs(path_l.c_str());
+    ifstream rifs(path_r.c_str());
+
+    vector< string > llines;
+    vector< string > rlines;
+
+    while (getline(lifs, buf)) {
+        llines.push_back(buf);
+    }
+    
+    while (getline(rifs, buf)) {
+        rlines.push_back(buf);
+    }
+
+    Diff< string, vector< string > > diff_uni(llines, rlines);
+    diff_uni.compose();
+    return diff_uni.getEditDistance();
+}
+
+bool is_file_exist (string& fs) {
+    FILE *fp;
+    if ((fp = fopen(fs.c_str(), "r")) == NULL) {
+        return false;
+    }
+    fclose(fp);
+    return true;
+}
+
+void diff_resultset_exist_check (string &fs) {
+    if (!is_file_exist(fs)) {
+        cerr << "======================================================Error!!!======================================================" << endl;
+        cerr << "diff result set:" << fs << " is not found." << endl;
+        cerr << "======================================================Error!!!======================================================" << endl;
+        cerr << "excute dtl_test in dtl/test!" << endl;
+        exit(EXIT_FAILURE);
+    }
+}

test/dtl_test_common.hpp

@@ -0,0 +1,70 @@
+
+#ifndef DTL_TEST_COMMON
+#define DTL_TEST_COMMON
+
+#include <gtest/gtest.h>
+#include <cstdio>
+#include <string>
+#include <vector>
+#include <utility>
+#include <iostream>
+#include <fstream>
+#include <dtl/dtl.hpp>
+
+using std::cerr;
+using std::endl;
+using std::string;
+using std::vector;
+using std::pair;
+using std::ifstream;
+using std::ofstream;
+
+using dtl::Diff;
+using dtl::Diff3;
+using dtl::Compare;
+using dtl::SES_COMMON;
+using dtl::SES_ADD;
+using dtl::SES_DELETE;
+using dtl::elemInfo;
+using dtl::uniHunk;
+
+#define dtl_test_typedefs(e_type, seq_type)                         \
+    typedef e_type                       elem;                      \
+    typedef seq_type                     sequence;                  \
+    typedef pair< elem, elemInfo >       sesElem;                   \
+    typedef vector< elem >               elemVec;                   \
+    typedef vector< sesElem >            sesElemVec;                \
+    typedef vector< uniHunk< sesElem > > uniHunkVec;
+
+enum type_diff { TYPE_DIFF_SES, TYPE_DIFF_UNI };
+
+string create_path (const string& test_name, string diff_name, enum type_diff t, bool is_use_suffix = false);
+size_t cal_diff_uni (const string& path_l, const string& path_r);
+bool is_file_exist (string& fs);
+void diff_resultset_exist_check (string &fs);
+
+template <typename T>
+class Remover {
+public :
+    void operator()(const T& v){
+        remove(v.path_rses.c_str());
+        remove(v.path_rhunks.c_str());
+    }
+};
+
+template < typename elem, typename sequence,  typename comparator >
+void create_file (const string& path, Diff< elem, sequence, comparator >& diff, enum type_diff t) {
+    ofstream ofs;
+    ofs.open(path.c_str());
+    switch (t) {
+    case TYPE_DIFF_SES:
+        diff.printSES(ofs);
+        break;
+    case TYPE_DIFF_UNI:
+        diff.printUnifiedFormat(ofs);
+        break;
+    }
+    ofs.close();
+}
+
+#endif // DTL_TEST_COMMON

test/hunks/intdiff/diff_test1

@@ -0,0 +1,2 @@
+@@ -1,0 +1,1 @@
++1

test/hunks/intdiff/diff_test2

@@ -0,0 +1,2 @@
+@@ -1,1 +1,0 @@
+-1

test/hunks/intdiff/diff_test3

@@ -0,0 +1,15 @@
+@@ -1,10 +1,10 @@
+-1
+-2
+ 3
++5
++1
+ 4
+ 5
+-6
++1
+ 7
+-8
+ 9
++6
+ 10

test/hunks/intdiff/diff_test4

@@ -0,0 +1,8 @@
+@@ -1,5 +1,5 @@
+-1
+-2
+ 3
++5
++1
+ 4
+ 5

test/hunks/strdiff/diff_test0

@@ -0,0 +1,5 @@
+@@ -1,3 +1,3 @@
+ a
+ b
+-c
++d

test/hunks/strdiff/diff_test1

@@ -0,0 +1,15 @@
+@@ -1,10 +1,12 @@
+ a
+ c
++e
+ b
+ d
+-e
+ a
+-c
+ b
++b
++a
++b
+ e
+ d

test/hunks/strdiff/diff_test2

@@ -0,0 +1,10 @@
+@@ -1,6 +1,6 @@
++d
+ a
+-b
+ c
+-d
+-e
+ f
++e
++a

test/hunks/strdiff/diff_test3

@@ -0,0 +1,9 @@
+@@ -1,6 +1,6 @@
+-a
+ b
++d
+ c
++a
+ b
+-d
+ a

test/hunks/strdiff/diff_test4

@@ -0,0 +1,6 @@
+@@ -2,4 +2,5 @@
+ o
+ k
+ k
++k
+ o

test/hunks/strdiff/diff_test6

@@ -0,0 +1,2 @@
+@@ -1,1 +1,0 @@
+-a

test/hunks/strdiff/diff_test7

@@ -0,0 +1,2 @@
+@@ -1,0 +1,1 @@
++b

test/hunks/strdiff/diff_test8

@@ -0,0 +1,22 @@
+@@ -1,9 +1,11 @@
+ a
+ c
++e
+ b
+ d
+-e
+ a
++b
++b
+ q
+ q
+ q
+@@ -11,7 +13,7 @@
+ q
+ q
+ q
+-c
++a
+ b
+ e
+ d

test/ses/intdiff/diff_test1

@@ -0,0 +1 @@
++1

test/ses/intdiff/diff_test2

@@ -0,0 +1 @@
+-1

test/ses/intdiff/diff_test3

@@ -0,0 +1,14 @@
+-1
+-2
+ 3
++5
++1
+ 4
+ 5
+-6
++1
+ 7
+-8
+ 9
++6
+ 10

test/ses/intdiff/diff_test4

@@ -0,0 +1,7 @@
+-1
+-2
+ 3
++5
++1
+ 4
+ 5

test/ses/strdiff/custom_test0

@@ -0,0 +1,3 @@
+ a
+ b
+ c

test/ses/strdiff/diff_test0

@@ -0,0 +1,4 @@
+ a
+ b
+-c
++d

test/ses/strdiff/diff_test1

@@ -0,0 +1,14 @@
+ a
+ c
++e
+ b
+ d
+-e
+ a
+-c
+ b
++b
++a
++b
+ e
+ d

test/ses/strdiff/diff_test2

@@ -0,0 +1,9 @@
++d
+ a
+-b
+ c
+-d
+-e
+ f
++e
++a

test/ses/strdiff/diff_test3

@@ -0,0 +1,8 @@
+-a
+ b
++d
+ c
++a
+ b
+-d
+ a

test/ses/strdiff/diff_test4

@@ -0,0 +1,6 @@
+ b
+ o
+ k
+ k
++k
+ o

test/ses/strdiff/diff_test6

@@ -0,0 +1 @@
+-a

test/ses/strdiff/diff_test7

@@ -0,0 +1 @@
++b

test/ses/strdiff/diff_test8

@@ -0,0 +1,21 @@
+ a
+ c
++e
+ b
+ d
+-e
+ a
++b
++b
+ q
+ q
+ q
+ q
+ q
+ q
+ q
++a
+-c
+ b
+ e
+ d