From 94d86a1c9fef79f523a7e7666403e612ad129e5f Mon Sep 17 00:00:00 2001 From: "Scott E. Graves" Date: Mon, 3 Jun 2024 08:20:20 -0500 Subject: [PATCH] formatting and fixes --- .clang-format | 127 ++++ .clang-tidy | 10 + ChangeLog | 10 + dtl/Diff.hpp | 1316 +++++++++++++++++----------------- dtl/Diff3.hpp | 412 ++++++----- dtl/Lcs.hpp | 42 +- dtl/Sequence.hpp | 59 +- dtl/Ses.hpp | 189 +++-- dtl/dtl.hpp | 30 +- dtl/functors.hpp | 229 +++--- dtl/variables.hpp | 195 +++-- examples/bdiff.cpp | 104 ++- examples/common.cpp | 27 +- examples/common.hpp | 6 +- examples/fpatch.cpp | 122 ++-- examples/intdiff.cpp | 74 +- examples/intdiff3.cpp | 94 +-- examples/patch.cpp | 64 +- examples/printers.hpp | 37 +- examples/st2ses.cpp | 43 +- examples/storage.hpp | 35 +- examples/strdiff.cpp | 62 +- examples/strdiff3.cpp | 46 +- examples/strdiff_cp.cpp | 42 +- examples/strdiff_storage.cpp | 46 +- examples/unidiff.cpp | 174 +++-- examples/unistrdiff.cpp | 58 +- test/Intdifftest.cpp | 227 +++--- test/Objdifftest.cpp | 194 ++--- test/Patchtest.cpp | 199 +++-- test/SConstruct | 14 +- test/Strdiff3test.cpp | 310 ++++---- test/Strdifftest.cpp | 491 ++++++------- test/comparators.hpp | 25 +- test/dtl_test.cpp | 6 +- test/dtl_test_common.cpp | 93 +-- test/dtl_test_common.hpp | 89 +-- 37 files changed, 2742 insertions(+), 2559 deletions(-) create mode 100644 .clang-format create mode 100644 .clang-tidy diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..4b12e19 --- /dev/null +++ b/.clang-format @@ -0,0 +1,127 @@ +--- +Language: Cpp +# BasedOnStyle: LLVM +AccessModifierOffset: -2 +AlignAfterOpenBracket: Align +AlignConsecutiveMacros: false +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Right +AlignOperands: true +AlignTrailingComments: true +AllowAllArgumentsOnNextLine: true +AllowAllConstructorInitializersOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortLambdasOnASingleLine: All +AllowShortIfStatementsOnASingleLine: Never +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: MultiLine +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Attach +BreakBeforeInheritanceComma: false +BreakInheritanceList: BeforeColon +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + - Regex: '.*' + Priority: 1 +IncludeIsMainRegex: '(Test)?$' +IndentCaseLabels: false +IndentPPDirectives: None +IndentWidth: 2 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: true +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Right +ReflowComments: true +SortIncludes: false +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: true +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Auto +StatementMacros: + - Q_UNUSED + - QT_REQUIRE_VERSION +TabWidth: 8 +UseTab: Never +... + diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 0000000..2d65a82 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,10 @@ +--- +Checks: '-*,clang-diagnostic-*,clang-analyzer-*,bugprone-*,concurrency-*,cppcoreguidelines-*,modernize-*,readability-*,-readability-redundant-access-specifiers,-readability-function-cognitive-complexity' +ExtraArgs: '-Wno-unknown-warning-option' +FormatStyle: none +HeaderFileExtensions: ['', 'h','hh','hpp','hxx'] +HeaderFilterRegex: '' +ImplementationFileExtensions: ['c','cc','cpp','cxx'] +User: 'scott.e.graves@protonmail.com' +WarningsAsErrors: '' +... diff --git a/ChangeLog b/ChangeLog index de19a6b..fcfa6ef 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,13 @@ +2024-06-03 Scott E. Graves + + * bugfix: fixed compilation issues with GCC 14 + * https://github.com/cubicdaiya/dtl/pull/22 + * https://github.com/cubicdaiya/dtl/pull/18 + * initialize variables to prevent warnings + * https://github.com/cubicdaiya/dtl/pull/16 + + * 1.21 released + 2022-04-11 Tatsuhiko Kubo * bugfix: fixed invalid offset in unified format difference when difference is too large. diff --git a/dtl/Diff.hpp b/dtl/Diff.hpp index e9376d2..44ef022 100644 --- a/dtl/Diff.hpp +++ b/dtl/Diff.hpp @@ -1,25 +1,25 @@ /** dtl -- Diff Template Library - + In short, Diff Template Library is distributed under so called "BSD license", - + Copyright (c) 2015 Tatsuhiko Kubo All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + * Neither the name of the authors nor the names of its contributors - may be used to endorse or promote products derived from this software + may be used to endorse or promote products derived from this software without specific prior written permission. - + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -39,670 +39,648 @@ #define DTL_DIFF_H namespace dtl { - - /** - * diff class template - * sequence must support random_access_iterator. - */ - template , typename comparator = Compare< elem > > - class Diff - { - private : - dtl_typedefs(elem, sequence) - sequence A; - sequence B; - size_t M; - size_t N; - size_t delta; - size_t offset; - long long *fp; - long long editDistance; - Lcs< elem > lcs; - Ses< elem > ses; - editPath path; - editPathCordinates pathCordinates; - bool swapped; - bool huge; - bool trivial; - bool editDistanceOnly; - uniHunkVec uniHunks; - comparator cmp; - long long ox; - long long oy; - public : - Diff () {} - - Diff (const sequence& a, - const sequence& b) : A(a), B(b), ses(false) { - init(); - } - - Diff (const sequence& a, - const sequence& b, - bool deletesFirst) : A(a), B(b), ses(deletesFirst) { - init(); - } - - Diff (const sequence& a, - const sequence& b, - const comparator& comp) : A(a), B(b), ses(false), cmp(comp) { - init(); - } - - Diff (const sequence& a, - const sequence& b, - bool deleteFirst, - const comparator& comp) : A(a), B(b), ses(deleteFirst), cmp(comp) { - init(); - } - - ~Diff() {} - - long long getEditDistance () const { - return editDistance; - } - - Lcs< elem > getLcs () const { - return lcs; - } - - elemVec getLcsVec () const { - return lcs.getSequence(); - } - - Ses< elem > getSes () const { - return ses; - } - - uniHunkVec getUniHunks () const { - return uniHunks; - } - - /* These should be deprecated */ - bool isHuge () const { - return huge; - } - - void onHuge () { - this->huge = true; - } - - void offHuge () { - this->huge = false; - } - - bool isUnserious () const { - return trivial; - } - - void onUnserious () { - this->trivial = true; - } - - void offUnserious () { - this->trivial = false; - } - - void onOnlyEditDistance () { - this->editDistanceOnly = true; - } - - /* These are the replacements for the above */ - bool hugeEnabled () const { - return huge; - } - - void enableHuge () { - this->huge = true; - } - - void disableHuge () { - this->huge = false; - } - - bool trivialEnabled () const { - return trivial; - } - - void enableTrivial () { - this->trivial = true; - } - - void disableTrivial () { - this->trivial = false; - } - - void editDistanceOnlyEnabled () { - this->editDistanceOnly = true; - } - - /** - * patching with Unified Format Hunks - */ - sequence uniPatch (const sequence& seq) { - elemList seqLst(seq.begin(), seq.end()); - sesElemVec shunk; - sesElemVec_iter vsesIt; - elemList_iter lstIt = seqLst.begin(); - long long inc_dec_total = 0; - long long gap = 1; - for (uniHunkVec_iter it=uniHunks.begin();it!=uniHunks.end();++it) { - joinSesVec(shunk, it->common[0]); - joinSesVec(shunk, it->change); - joinSesVec(shunk, it->common[1]); - it->a += inc_dec_total; - inc_dec_total += it->inc_dec_count; - for (long long i=0;ia - gap;++i) { - ++lstIt; - } - gap = it->a + it->b + it->inc_dec_count; - vsesIt = shunk.begin(); - while (vsesIt!=shunk.end()) { - switch (vsesIt->second.type) { - case SES_ADD : - seqLst.insert(lstIt, vsesIt->first); - break; - case SES_DELETE : - if (lstIt != seqLst.end()) { - lstIt = seqLst.erase(lstIt); - } - break; - case SES_COMMON : - if (lstIt != seqLst.end()) { - ++lstIt; - } - break; - default : - // no fall-through - break; - } - ++vsesIt; - } - shunk.clear(); - } - - sequence patchedSeq(seqLst.begin(), seqLst.end()); - return patchedSeq; - } - - /** - * patching with Shortest Edit Script (SES) - */ - sequence patch (const sequence& seq) const { - sesElemVec sesSeq = ses.getSequence(); - elemList seqLst(seq.begin(), seq.end()); - elemList_iter lstIt = seqLst.begin(); - for (sesElemVec_iter sesIt=sesSeq.begin();sesIt!=sesSeq.end();++sesIt) { - switch (sesIt->second.type) { - case SES_ADD : - seqLst.insert(lstIt, sesIt->first); - break; - case SES_DELETE : - lstIt = seqLst.erase(lstIt); - break; - case SES_COMMON : - ++lstIt; - break; - default : - // no through - break; - } - } - sequence patchedSeq(seqLst.begin(), seqLst.end()); - return patchedSeq; - } - - /** - * compose Longest Common Subsequence and Shortest Edit Script. - * The algorithm implemented here is based on "An O(NP) Sequence Comparison Algorithm" - * described by Sun Wu, Udi Manber and Gene Myers - */ - void compose() { - - if (isHuge()) { - pathCordinates.reserve(MAX_CORDINATES_SIZE); - } - ox = 0; - oy = 0; - long long p = -1; - fp = new long long[M + N + 3]; - fill(&fp[0], &fp[M + N + 3], -1); - path = editPath(M + N + 3); - fill(path.begin(), path.end(), -1); - ONP: - do { - ++p; - for (long long k=-p;k<=static_cast(delta)-1;++k) { - fp[k+offset] = snake(k, fp[k-1+offset]+1, fp[k+1+offset]); - } - for (long long k=static_cast(delta)+p;k>=static_cast(delta)+1;--k) { - fp[k+offset] = snake(k, fp[k-1+offset]+1, fp[k+1+offset]); - } - fp[delta+offset] = snake(static_cast(delta), fp[delta-1+offset]+1, fp[delta+1+offset]); - } while (fp[delta+offset] != static_cast(N) && pathCordinates.size() < MAX_CORDINATES_SIZE); - - editDistance += static_cast(delta) + 2 * p; - long long r = path[delta+offset]; - P cordinate{}; - editPathCordinates epc(0); - - // recording edit distance only - if (editDistanceOnly) { - delete[] this->fp; - return; - } - - while(r != -1) { - cordinate.x = pathCordinates[(size_t)r].x; - cordinate.y = pathCordinates[(size_t)r].y; - epc.push_back(cordinate); - r = pathCordinates[(size_t)r].k; - } - - // record Longest Common Subsequence & Shortest Edit Script - if (!recordSequence(epc)) { - pathCordinates.resize(0); - epc.resize(0); - p = -1; - goto ONP; - } - delete[] this->fp; - } - /** - * print difference between A and B as an SES - */ - template < typename stream > - void printSES (stream& out) const { - sesElemVec ses_v = ses.getSequence(); - for_each(ses_v.begin(), ses_v.end(), ChangePrinter< sesElem, stream >(out)); - } - - void printSES (ostream& out = cout) const { - printSES< ostream >(out); - } - - /** - * print differences given an SES - */ - template < typename stream > - static void printSES (const Ses< elem >& s, stream& out) { - sesElemVec ses_v = s.getSequence(); - for_each(ses_v.begin(), ses_v.end(), ChangePrinter< sesElem, stream >(out)); - } - - static void printSES (const Ses< elem >& s, ostream& out = cout) { - printSES< ostream >(s, out); - } +/** + * diff class template + * sequence must support random_access_iterator. + */ +template , + typename comparator = Compare> +class Diff { +private: + dtl_typedefs(elem, sequence) sequence A; + sequence B; + size_t M; + size_t N; + size_t delta; + size_t offset; + long long *fp; + long long editDistance; + Lcs lcs; + Ses ses; + editPath path; + editPathCordinates pathCordinates; + bool swapped; + bool huge; + bool trivial; + bool editDistanceOnly; + uniHunkVec uniHunks; + comparator cmp; + long long ox; + long long oy; - /** - * print difference between A and B as an SES with custom printer - */ - template < typename stream, template < typename SEET, typename STRT > class PT > - void printSES (stream& out) const { - sesElemVec ses_v = ses.getSequence (); - for_each (ses_v.begin (), ses_v.end(), PT < sesElem, stream > (out)); - } +public: + Diff() {} - /** - * store difference between A and B as an SES with custom storage - */ - template < typename storedData, template < typename SEET, typename STRT > class ST > - void storeSES(storedData& sd) const { - sesElemVec ses_v = ses.getSequence(); - for_each(ses_v.begin(), ses_v.end(), ST < sesElem, storedData >(sd)); - } - - /** - * print difference between A and B in the Unified Format - */ - template < typename stream > - void printUnifiedFormat (stream& out) const { - for_each(uniHunks.begin(), uniHunks.end(), UniHunkPrinter< sesElem, stream >(out)); - } - - void printUnifiedFormat (ostream& out = cout) const { - printUnifiedFormat< ostream >(out); - } - - /** - * print unified format difference with given unified format hunks - */ - template < typename stream > - static void printUnifiedFormat (const uniHunkVec& hunks, stream& out) { - for_each(hunks.begin(), hunks.end(), UniHunkPrinter< sesElem >(out)); - } + Diff(const sequence &a, const sequence &b) : A(a), B(b), ses(false) { + init(); + } - static void printUnifiedFormat (const uniHunkVec& hunks, ostream& out = cout) { - printUnifiedFormat< ostream >(hunks, out); - } + Diff(const sequence &a, const sequence &b, bool deletesFirst) + : A(a), B(b), ses(deletesFirst) { + init(); + } - /** - * compose Unified Format Hunks from Shortest Edit Script - */ - void composeUnifiedHunks () { - sesElemVec common[2]; - sesElemVec change; - sesElemVec ses_v = ses.getSequence(); - long long l_cnt = 1; - long long length = distance(ses_v.begin(), ses_v.end()); - long long middle = 0; - bool isMiddle, isAfter; - elemInfo einfo; - long long a, b, c, d; // @@ -a,b +c,d @@ - long long inc_dec_count = 0; - uniHunk< sesElem > hunk; - sesElemVec adds; - sesElemVec deletes; - - isMiddle = isAfter = false; - a = b = c = d = 0; - - for (sesElemVec_iter it=ses_v.begin();it!=ses_v.end();++it, ++l_cnt) { - einfo = it->second; - switch (einfo.type) { - case SES_ADD : - middle = 0; - ++inc_dec_count; - adds.push_back(*it); - if (!isMiddle) isMiddle = true; - if (isMiddle) ++d; - if (l_cnt >= length) { - joinSesVec(change, deletes); - joinSesVec(change, adds); - isAfter = true; - } - break; - case SES_DELETE : - middle = 0; - --inc_dec_count; - deletes.push_back(*it); - if (!isMiddle) isMiddle = true; - if (isMiddle) ++b; - if (l_cnt >= length) { - joinSesVec(change, deletes); - joinSesVec(change, adds); - isAfter = true; - } - break; - case SES_COMMON : - ++b;++d; - if (common[1].empty() && adds.empty() && deletes.empty() && change.empty()) { - if (static_cast(common[0].size()) < DTL_CONTEXT_SIZE) { - if (a == 0 && c == 0) { - if (!wasSwapped()) { - a = einfo.beforeIdx; - c = einfo.afterIdx; - } else { - a = einfo.afterIdx; - c = einfo.beforeIdx; - } - } - common[0].push_back(*it); - } else { - rotate(common[0].begin(), common[0].begin() + 1, common[0].end()); - common[0].pop_back(); - common[0].push_back(*it); - ++a;++c; - --b;--d; - } - } - if (isMiddle && !isAfter) { - ++middle; - joinSesVec(change, deletes); - joinSesVec(change, adds); - change.push_back(*it); - if (middle >= DTL_SEPARATE_SIZE || l_cnt >= length) { - isAfter = true; - } - adds.clear(); - deletes.clear(); - } - break; - default : - // no through - break; - } - // compose unified format hunk - if (isAfter && !change.empty()) { - sesElemVec_iter cit = it; - long long cnt = 0; - for (long long i=0;isecond.type == SES_COMMON) { - ++cnt; - } - } - if (cnt < DTL_SEPARATE_SIZE && l_cnt < length) { - middle = 0; - isAfter = false; - continue; - } - if (static_cast(common[0].size()) >= DTL_SEPARATE_SIZE) { - long long c0size = static_cast(common[0].size()); - rotate(common[0].begin(), - common[0].begin() + (size_t)c0size - DTL_SEPARATE_SIZE, - common[0].end()); - for (long long i=0;i - static Ses< elem > composeSesFromStream (stream& st) - { - elem line; - Ses< elem > ret; - long long x_idx, y_idx; - x_idx = y_idx = 1; - while (getline(st, line)) { - elem mark(line.begin(), line.begin() + 1); - elem e(line.begin() + 1, line.end()); - if (mark == SES_MARK_DELETE) { - ret.addSequence(e, x_idx, 0, SES_DELETE); - ++x_idx; - } else if (mark == SES_MARK_ADD) { - ret.addSequence(e, y_idx, 0, SES_ADD); - ++y_idx; - } else if (mark == SES_MARK_COMMON) { - ret.addSequence(e, x_idx, y_idx, SES_COMMON); - ++x_idx; - ++y_idx; - } - } - return ret; - } - - private : - /** - * initialize - */ - void init () { - M = distance(A.begin(), A.end()); - N = distance(B.begin(), B.end()); - if (M < N) { - swapped = false; - } else { - swap(A, B); - swap(M, N); - swapped = true; - } - editDistance = 0; - delta = N - M; - offset = M + 1; - huge = false; - trivial = false; - editDistanceOnly = false; - fp = NULL; - ox = 0; - oy = 0; - } - - /** - * search shortest path and record the path - */ - long long snake(const long long& k, const long long& above, const long long& below) { - long long r = above > below ? path[(size_t)k-1+offset] : path[(size_t)k+1+offset]; - long long y = max(above, below); - long long x = y - k; - while ((size_t)x < M && (size_t)y < N && (swapped ? cmp.impl(B[(size_t)y], A[(size_t)x]) : cmp.impl(A[(size_t)x], B[(size_t)y]))) { - ++x;++y; - } - - path[(size_t)k+offset] = static_cast(pathCordinates.size()); - if (!editDistanceOnly) { - P p; - p.x = x;p.y = y;p.k = r; - pathCordinates.push_back(p); - } - return y; - } - - /** - * record SES and LCS - */ - bool recordSequence (const editPathCordinates& v) { - sequence_const_iter x(A.begin()); - sequence_const_iter y(B.begin()); - long long x_idx, y_idx; // line number for Unified Format - long long px_idx, py_idx; // cordinates - bool complete = false; - x_idx = y_idx = 1; - px_idx = py_idx = 0; - for (size_t i=v.size()-1;!complete;--i) { - while(px_idx < v[i].x || py_idx < v[i].y) { - if (v[i].y - v[i].x > py_idx - px_idx) { - if (!wasSwapped()) { - ses.addSequence(*y, 0, y_idx + oy, SES_ADD); - } else { - ses.addSequence(*y, y_idx + oy, 0, SES_DELETE); - } - ++y; - ++y_idx; - ++py_idx; - } else if (v[i].y - v[i].x < py_idx - px_idx) { - if (!wasSwapped()) { - ses.addSequence(*x, x_idx + ox, 0, SES_DELETE); - } else { - ses.addSequence(*x, 0, x_idx + ox, SES_ADD); - } - ++x; - ++x_idx; - ++px_idx; - } else { - if (!wasSwapped()) { - lcs.addSequence(*x); - ses.addSequence(*x, x_idx + ox, y_idx + oy, SES_COMMON); - } else { - lcs.addSequence(*y); - ses.addSequence(*y, y_idx + oy, x_idx + ox, SES_COMMON); - } - ++x; - ++y; - ++x_idx; - ++y_idx; - ++px_idx; - ++py_idx; - } - } - if (i == 0) complete = true; - } - - if (x_idx > static_cast(M) && y_idx > static_cast(N)) { - // all recording succeeded - } else { - // trivial difference - if (trivialEnabled()) { - if (!wasSwapped()) { - recordOddSequence(x_idx, M, x, SES_DELETE); - recordOddSequence(y_idx, N, y, SES_ADD); - } else { - recordOddSequence(x_idx, M, x, SES_ADD); - recordOddSequence(y_idx, N, y, SES_DELETE); - } - return true; - } - - // nontrivial difference - sequence A_(A.begin() + (size_t)x_idx - 1, A.end()); - sequence B_(B.begin() + (size_t)y_idx - 1, B.end()); - A = A_; - B = B_; - M = distance(A.begin(), A.end()); - N = distance(B.begin(), B.end()); - delta = N - M; - offset = M + 1; - delete[] fp; - fp = new long long[M + N + 3]; - fill(&fp[0], &fp[M + N + 3], -1); - fill(path.begin(), path.end(), -1); - ox = x_idx - 1; - oy = y_idx - 1; - return false; - } - return true; - } - - /** - * record odd sequence in SES - */ - void inline recordOddSequence (long long idx, long long length, sequence_const_iter it, const edit_t et) { - while(idx < length){ - ses.addSequence(*it, idx, 0, et); - ++it; - ++idx; - ++editDistance; - } - ses.addSequence(*it, idx, 0, et); - ++editDistance; - } - - /** - * join SES vectors - */ - void inline joinSesVec (sesElemVec& s1, sesElemVec& s2) const { - if (!s2.empty()) { - for (sesElemVec_iter vit=s2.begin();vit!=s2.end();++vit) { - s1.push_back(*vit); - } - } - } - - /** - * check if the sequences have been swapped - */ - bool inline wasSwapped () const { - return swapped; - } + Diff(const sequence &a, const sequence &b, const comparator &comp) + : A(a), B(b), ses(false), cmp(comp) { + init(); + } - }; -} + Diff(const sequence &a, const sequence &b, bool deleteFirst, + const comparator &comp) + : A(a), B(b), ses(deleteFirst), cmp(comp) { + init(); + } + + ~Diff() {} + + long long getEditDistance() const { return editDistance; } + + Lcs getLcs() const { return lcs; } + + elemVec getLcsVec() const { return lcs.getSequence(); } + + Ses getSes() const { return ses; } + + uniHunkVec getUniHunks() const { return uniHunks; } + + /* These should be deprecated */ + bool isHuge() const { return huge; } + + void onHuge() { this->huge = true; } + + void offHuge() { this->huge = false; } + + bool isUnserious() const { return trivial; } + + void onUnserious() { this->trivial = true; } + + void offUnserious() { this->trivial = false; } + + void onOnlyEditDistance() { this->editDistanceOnly = true; } + + /* These are the replacements for the above */ + bool hugeEnabled() const { return huge; } + + void enableHuge() { this->huge = true; } + + void disableHuge() { this->huge = false; } + + bool trivialEnabled() const { return trivial; } + + void enableTrivial() { this->trivial = true; } + + void disableTrivial() { this->trivial = false; } + + void editDistanceOnlyEnabled() { this->editDistanceOnly = true; } + + /** + * patching with Unified Format Hunks + */ + sequence uniPatch(const sequence &seq) { + elemList seqLst(seq.begin(), seq.end()); + sesElemVec shunk; + sesElemVec_iter vsesIt; + elemList_iter lstIt = seqLst.begin(); + long long inc_dec_total = 0; + long long gap = 1; + for (uniHunkVec_iter it = uniHunks.begin(); it != uniHunks.end(); ++it) { + joinSesVec(shunk, it->common[0]); + joinSesVec(shunk, it->change); + joinSesVec(shunk, it->common[1]); + it->a += inc_dec_total; + inc_dec_total += it->inc_dec_count; + for (long long i = 0; i < it->a - gap; ++i) { + ++lstIt; + } + gap = it->a + it->b + it->inc_dec_count; + vsesIt = shunk.begin(); + while (vsesIt != shunk.end()) { + switch (vsesIt->second.type) { + case SES_ADD: + seqLst.insert(lstIt, vsesIt->first); + break; + case SES_DELETE: + if (lstIt != seqLst.end()) { + lstIt = seqLst.erase(lstIt); + } + break; + case SES_COMMON: + if (lstIt != seqLst.end()) { + ++lstIt; + } + break; + default: + // no fall-through + break; + } + ++vsesIt; + } + shunk.clear(); + } + + sequence patchedSeq(seqLst.begin(), seqLst.end()); + return patchedSeq; + } + + /** + * patching with Shortest Edit Script (SES) + */ + sequence patch(const sequence &seq) const { + sesElemVec sesSeq = ses.getSequence(); + elemList seqLst(seq.begin(), seq.end()); + elemList_iter lstIt = seqLst.begin(); + for (sesElemVec_iter sesIt = sesSeq.begin(); sesIt != sesSeq.end(); + ++sesIt) { + switch (sesIt->second.type) { + case SES_ADD: + seqLst.insert(lstIt, sesIt->first); + break; + case SES_DELETE: + lstIt = seqLst.erase(lstIt); + break; + case SES_COMMON: + ++lstIt; + break; + default: + // no through + break; + } + } + sequence patchedSeq(seqLst.begin(), seqLst.end()); + return patchedSeq; + } + + /** + * compose Longest Common Subsequence and Shortest Edit Script. + * The algorithm implemented here is based on "An O(NP) Sequence Comparison + * Algorithm" described by Sun Wu, Udi Manber and Gene Myers + */ + void compose() { + + if (isHuge()) { + pathCordinates.reserve(MAX_CORDINATES_SIZE); + } + ox = 0; + oy = 0; + long long p = -1; + fp = new long long[M + N + 3]; + fill(&fp[0], &fp[M + N + 3], -1); + path = editPath(M + N + 3); + fill(path.begin(), path.end(), -1); + ONP: + do { + ++p; + for (long long k = -p; k <= static_cast(delta) - 1; ++k) { + fp[k + offset] = snake(k, fp[k - 1 + offset] + 1, fp[k + 1 + offset]); + } + for (long long k = static_cast(delta) + p; + k >= static_cast(delta) + 1; --k) { + fp[k + offset] = snake(k, fp[k - 1 + offset] + 1, fp[k + 1 + offset]); + } + fp[delta + offset] = + snake(static_cast(delta), fp[delta - 1 + offset] + 1, + fp[delta + 1 + offset]); + } while (fp[delta + offset] != static_cast(N) && + pathCordinates.size() < MAX_CORDINATES_SIZE); + + editDistance += static_cast(delta) + 2 * p; + long long r = path[delta + offset]; + P cordinate{}; + editPathCordinates epc(0); + + // recording edit distance only + if (editDistanceOnly) { + delete[] this->fp; + return; + } + + while (r != -1) { + cordinate.x = pathCordinates[(size_t)r].x; + cordinate.y = pathCordinates[(size_t)r].y; + epc.push_back(cordinate); + r = pathCordinates[(size_t)r].k; + } + + // record Longest Common Subsequence & Shortest Edit Script + if (!recordSequence(epc)) { + pathCordinates.resize(0); + epc.resize(0); + p = -1; + goto ONP; + } + delete[] this->fp; + } + + /** + * print difference between A and B as an SES + */ + template void printSES(stream &out) const { + sesElemVec ses_v = ses.getSequence(); + for_each(ses_v.begin(), ses_v.end(), ChangePrinter(out)); + } + + void printSES(ostream &out = cout) const { printSES(out); } + + /** + * print differences given an SES + */ + template + static void printSES(const Ses &s, stream &out) { + sesElemVec ses_v = s.getSequence(); + for_each(ses_v.begin(), ses_v.end(), ChangePrinter(out)); + } + + static void printSES(const Ses &s, ostream &out = cout) { + printSES(s, out); + } + + /** + * print difference between A and B as an SES with custom printer + */ + template class PT> + void printSES(stream &out) const { + sesElemVec ses_v = ses.getSequence(); + for_each(ses_v.begin(), ses_v.end(), PT(out)); + } + + /** + * store difference between A and B as an SES with custom storage + */ + template class ST> + void storeSES(storedData &sd) const { + sesElemVec ses_v = ses.getSequence(); + for_each(ses_v.begin(), ses_v.end(), ST(sd)); + } + + /** + * print difference between A and B in the Unified Format + */ + template void printUnifiedFormat(stream &out) const { + for_each(uniHunks.begin(), uniHunks.end(), + UniHunkPrinter(out)); + } + + void printUnifiedFormat(ostream &out = cout) const { + printUnifiedFormat(out); + } + + /** + * print unified format difference with given unified format hunks + */ + template + static void printUnifiedFormat(const uniHunkVec &hunks, stream &out) { + for_each(hunks.begin(), hunks.end(), UniHunkPrinter(out)); + } + + static void printUnifiedFormat(const uniHunkVec &hunks, ostream &out = cout) { + printUnifiedFormat(hunks, out); + } + + /** + * compose Unified Format Hunks from Shortest Edit Script + */ + void composeUnifiedHunks() { + sesElemVec common[2]; + sesElemVec change; + sesElemVec ses_v = ses.getSequence(); + long long l_cnt = 1; + long long length = distance(ses_v.begin(), ses_v.end()); + long long middle = 0; + bool isMiddle, isAfter; + elemInfo einfo; + long long a, b, c, d; // @@ -a,b +c,d @@ + long long inc_dec_count = 0; + uniHunk hunk; + sesElemVec adds; + sesElemVec deletes; + + isMiddle = isAfter = false; + a = b = c = d = 0; + + for (sesElemVec_iter it = ses_v.begin(); it != ses_v.end(); ++it, ++l_cnt) { + einfo = it->second; + switch (einfo.type) { + case SES_ADD: + middle = 0; + ++inc_dec_count; + adds.push_back(*it); + if (!isMiddle) + isMiddle = true; + if (isMiddle) + ++d; + if (l_cnt >= length) { + joinSesVec(change, deletes); + joinSesVec(change, adds); + isAfter = true; + } + break; + case SES_DELETE: + middle = 0; + --inc_dec_count; + deletes.push_back(*it); + if (!isMiddle) + isMiddle = true; + if (isMiddle) + ++b; + if (l_cnt >= length) { + joinSesVec(change, deletes); + joinSesVec(change, adds); + isAfter = true; + } + break; + case SES_COMMON: + ++b; + ++d; + if (common[1].empty() && adds.empty() && deletes.empty() && + change.empty()) { + if (static_cast(common[0].size()) < DTL_CONTEXT_SIZE) { + if (a == 0 && c == 0) { + if (!wasSwapped()) { + a = einfo.beforeIdx; + c = einfo.afterIdx; + } else { + a = einfo.afterIdx; + c = einfo.beforeIdx; + } + } + common[0].push_back(*it); + } else { + rotate(common[0].begin(), common[0].begin() + 1, common[0].end()); + common[0].pop_back(); + common[0].push_back(*it); + ++a; + ++c; + --b; + --d; + } + } + if (isMiddle && !isAfter) { + ++middle; + joinSesVec(change, deletes); + joinSesVec(change, adds); + change.push_back(*it); + if (middle >= DTL_SEPARATE_SIZE || l_cnt >= length) { + isAfter = true; + } + adds.clear(); + deletes.clear(); + } + break; + default: + // no through + break; + } + // compose unified format hunk + if (isAfter && !change.empty()) { + sesElemVec_iter cit = it; + long long cnt = 0; + for (long long i = 0; i < DTL_SEPARATE_SIZE && (cit != ses_v.end()); + ++i, ++cit) { + if (cit->second.type == SES_COMMON) { + ++cnt; + } + } + if (cnt < DTL_SEPARATE_SIZE && l_cnt < length) { + middle = 0; + isAfter = false; + continue; + } + if (static_cast(common[0].size()) >= DTL_SEPARATE_SIZE) { + long long c0size = static_cast(common[0].size()); + rotate(common[0].begin(), + common[0].begin() + (size_t)c0size - DTL_SEPARATE_SIZE, + common[0].end()); + for (long long i = 0; i < c0size - DTL_SEPARATE_SIZE; ++i) { + common[0].pop_back(); + } + a += c0size - DTL_SEPARATE_SIZE; + c += c0size - DTL_SEPARATE_SIZE; + } + if (a == 0) + ++a; + if (c == 0) + ++c; + if (wasSwapped()) + swap(a, c); + hunk.a = a; + hunk.b = b; + hunk.c = c; + hunk.d = d; + hunk.common[0] = common[0]; + hunk.change = change; + hunk.common[1] = common[1]; + hunk.inc_dec_count = inc_dec_count; + uniHunks.push_back(hunk); + isMiddle = false; + isAfter = false; + common[0].clear(); + common[1].clear(); + adds.clear(); + deletes.clear(); + change.clear(); + a = b = c = d = middle = inc_dec_count = 0; + } + } + } + + /** + * compose ses from stream + */ + template static Ses composeSesFromStream(stream &st) { + elem line; + Ses ret; + long long x_idx, y_idx; + x_idx = y_idx = 1; + while (getline(st, line)) { + elem mark(line.begin(), line.begin() + 1); + elem e(line.begin() + 1, line.end()); + if (mark == SES_MARK_DELETE) { + ret.addSequence(e, x_idx, 0, SES_DELETE); + ++x_idx; + } else if (mark == SES_MARK_ADD) { + ret.addSequence(e, y_idx, 0, SES_ADD); + ++y_idx; + } else if (mark == SES_MARK_COMMON) { + ret.addSequence(e, x_idx, y_idx, SES_COMMON); + ++x_idx; + ++y_idx; + } + } + return ret; + } + +private: + /** + * initialize + */ + void init() { + M = distance(A.begin(), A.end()); + N = distance(B.begin(), B.end()); + if (M < N) { + swapped = false; + } else { + swap(A, B); + swap(M, N); + swapped = true; + } + editDistance = 0; + delta = N - M; + offset = M + 1; + huge = false; + trivial = false; + editDistanceOnly = false; + fp = NULL; + ox = 0; + oy = 0; + } + + /** + * search shortest path and record the path + */ + long long snake(const long long &k, const long long &above, + const long long &below) { + long long r = above > below ? path[(size_t)k - 1 + offset] + : path[(size_t)k + 1 + offset]; + long long y = max(above, below); + long long x = y - k; + while ((size_t)x < M && (size_t)y < N && + (swapped ? cmp.impl(B[(size_t)y], A[(size_t)x]) + : cmp.impl(A[(size_t)x], B[(size_t)y]))) { + ++x; + ++y; + } + + path[(size_t)k + offset] = static_cast(pathCordinates.size()); + if (!editDistanceOnly) { + P p; + p.x = x; + p.y = y; + p.k = r; + pathCordinates.push_back(p); + } + return y; + } + + /** + * record SES and LCS + */ + bool recordSequence(const editPathCordinates &v) { + sequence_const_iter x(A.begin()); + sequence_const_iter y(B.begin()); + long long x_idx, y_idx; // line number for Unified Format + long long px_idx, py_idx; // cordinates + bool complete = false; + x_idx = y_idx = 1; + px_idx = py_idx = 0; + for (size_t i = v.size() - 1; !complete; --i) { + while (px_idx < v[i].x || py_idx < v[i].y) { + if (v[i].y - v[i].x > py_idx - px_idx) { + if (!wasSwapped()) { + ses.addSequence(*y, 0, y_idx + oy, SES_ADD); + } else { + ses.addSequence(*y, y_idx + oy, 0, SES_DELETE); + } + ++y; + ++y_idx; + ++py_idx; + } else if (v[i].y - v[i].x < py_idx - px_idx) { + if (!wasSwapped()) { + ses.addSequence(*x, x_idx + ox, 0, SES_DELETE); + } else { + ses.addSequence(*x, 0, x_idx + ox, SES_ADD); + } + ++x; + ++x_idx; + ++px_idx; + } else { + if (!wasSwapped()) { + lcs.addSequence(*x); + ses.addSequence(*x, x_idx + ox, y_idx + oy, SES_COMMON); + } else { + lcs.addSequence(*y); + ses.addSequence(*y, y_idx + oy, x_idx + ox, SES_COMMON); + } + ++x; + ++y; + ++x_idx; + ++y_idx; + ++px_idx; + ++py_idx; + } + } + if (i == 0) + complete = true; + } + + if (x_idx > static_cast(M) && + y_idx > static_cast(N)) { + // all recording succeeded + } else { + // trivial difference + if (trivialEnabled()) { + if (!wasSwapped()) { + recordOddSequence(x_idx, M, x, SES_DELETE); + recordOddSequence(y_idx, N, y, SES_ADD); + } else { + recordOddSequence(x_idx, M, x, SES_ADD); + recordOddSequence(y_idx, N, y, SES_DELETE); + } + return true; + } + + // nontrivial difference + sequence A_(A.begin() + (size_t)x_idx - 1, A.end()); + sequence B_(B.begin() + (size_t)y_idx - 1, B.end()); + A = A_; + B = B_; + M = distance(A.begin(), A.end()); + N = distance(B.begin(), B.end()); + delta = N - M; + offset = M + 1; + delete[] fp; + fp = new long long[M + N + 3]; + fill(&fp[0], &fp[M + N + 3], -1); + fill(path.begin(), path.end(), -1); + ox = x_idx - 1; + oy = y_idx - 1; + return false; + } + return true; + } + + /** + * record odd sequence in SES + */ + void inline recordOddSequence(long long idx, long long length, + sequence_const_iter it, const edit_t et) { + while (idx < length) { + ses.addSequence(*it, idx, 0, et); + ++it; + ++idx; + ++editDistance; + } + ses.addSequence(*it, idx, 0, et); + ++editDistance; + } + + /** + * join SES vectors + */ + void inline joinSesVec(sesElemVec &s1, sesElemVec &s2) const { + if (!s2.empty()) { + for (sesElemVec_iter vit = s2.begin(); vit != s2.end(); ++vit) { + s1.push_back(*vit); + } + } + } + + /** + * check if the sequences have been swapped + */ + bool inline wasSwapped() const { return swapped; } +}; +} // namespace dtl #endif // DTL_DIFF_H diff --git a/dtl/Diff3.hpp b/dtl/Diff3.hpp index 854864e..8c8fc62 100644 --- a/dtl/Diff3.hpp +++ b/dtl/Diff3.hpp @@ -1,25 +1,25 @@ /** dtl -- Diff Template Library - + In short, Diff Template Library is distributed under so called "BSD license", - + Copyright (c) 2015 Tatsuhiko Kubo All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + * Neither the name of the authors nor the names of its contributors - may be used to endorse or promote products derived from this software + may be used to endorse or promote products derived from this software without specific prior written permission. - + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -39,207 +39,203 @@ #define DTL_DIFF3_H namespace dtl { - - /** - * diff3 class template - * sequence must support random_access_iterator. - */ - template , typename comparator = Compare< elem > > - class Diff3 - { - private: - dtl_typedefs(elem, sequence) - sequence A; - sequence B; - sequence C; - sequence S; - Diff< elem, sequence, comparator > diff_ba; - Diff< elem, sequence, comparator > diff_bc; - bool conflict; - elem csepabegin; - elem csepa; - elem csepaend; - public : - Diff3 () {} - Diff3 (const sequence& a, - const sequence& b, - const sequence& c) : A(a), B(b), C(c), - diff_ba(b, a), diff_bc(b, c), - conflict(false) {} - - ~Diff3 () {} - - bool isConflict () const { - return conflict; + +/** + * diff3 class template + * sequence must support random_access_iterator. + */ +template , + typename comparator = Compare> +class Diff3 { +private: + dtl_typedefs(elem, sequence) sequence A; + sequence B; + sequence C; + sequence S; + Diff diff_ba; + Diff diff_bc; + bool conflict; + elem csepabegin; + elem csepa; + elem csepaend; + +public: + Diff3() {} + Diff3(const sequence &a, const sequence &b, const sequence &c) + : A(a), B(b), C(c), diff_ba(b, a), diff_bc(b, c), conflict(false) {} + + ~Diff3() {} + + bool isConflict() const { return conflict; } + + sequence getMergedSequence() const { return S; } + + /** + * merge changes B and C into A + */ + bool merge() { + if (diff_ba.getEditDistance() == 0) { // A == B + if (diff_bc.getEditDistance() == 0) { // A == B == C + S = B; + return true; + } + S = C; + return true; + } else { // A != B + if (diff_bc.getEditDistance() == 0) { // A != B == C + S = A; + return true; + } else { // A != B != C + S = merge_(); + if (isConflict()) { // conflict occured + return false; } - - sequence getMergedSequence () const { - return S; + } + } + return true; + } + + /** + * compose differences + */ + void compose() { + diff_ba.compose(); + diff_bc.compose(); + } + +private: + /** + * merge implementation + */ + sequence merge_() { + elemVec seq; + Ses ses_ba = diff_ba.getSes(); + Ses ses_bc = diff_bc.getSes(); + sesElemVec ses_ba_v = ses_ba.getSequence(); + sesElemVec ses_bc_v = ses_bc.getSequence(); + sesElemVec_iter ba_it = ses_ba_v.begin(); + sesElemVec_iter bc_it = ses_bc_v.begin(); + sesElemVec_iter ba_end = ses_ba_v.end(); + sesElemVec_iter bc_end = ses_bc_v.end(); + + while (!isEnd(ba_end, ba_it) || !isEnd(bc_end, bc_it)) { + while (true) { + if (!isEnd(ba_end, ba_it) && !isEnd(bc_end, bc_it) && + ba_it->first == bc_it->first && ba_it->second.type == SES_COMMON && + bc_it->second.type == SES_COMMON) { + // do nothing + } else { + break; } - - /** - * merge changes B and C into A - */ - bool merge () { - if (diff_ba.getEditDistance() == 0) { // A == B - if (diff_bc.getEditDistance() == 0) { // A == B == C - S = B; - return true; - } - S = C; - return true; - } else { // A != B - if (diff_bc.getEditDistance() == 0) { // A != B == C - S = A; - return true; - } else { // A != B != C - S = merge_(); - if (isConflict()) { // conflict occured - return false; - } - } - } - return true; + if (!isEnd(ba_end, ba_it)) + seq.push_back(ba_it->first); + else if (!isEnd(bc_end, bc_it)) + seq.push_back(bc_it->first); + forwardUntilEnd(ba_end, ba_it); + forwardUntilEnd(bc_end, bc_it); + } + if (isEnd(ba_end, ba_it) || isEnd(bc_end, bc_it)) + break; + if (ba_it->second.type == SES_COMMON && + bc_it->second.type == SES_DELETE) { + forwardUntilEnd(ba_end, ba_it); + forwardUntilEnd(bc_end, bc_it); + } else if (ba_it->second.type == SES_COMMON && + bc_it->second.type == SES_ADD) { + seq.push_back(bc_it->first); + forwardUntilEnd(bc_end, bc_it); + } else if (ba_it->second.type == SES_DELETE && + bc_it->second.type == SES_COMMON) { + forwardUntilEnd(ba_end, ba_it); + forwardUntilEnd(bc_end, bc_it); + } else if (ba_it->second.type == SES_DELETE && + bc_it->second.type == SES_DELETE) { + if (ba_it->first == bc_it->first) { + forwardUntilEnd(ba_end, ba_it); + forwardUntilEnd(bc_end, bc_it); + } else { + // conflict + conflict = true; + return B; } - - /** - * compose differences - */ - void compose () { - diff_ba.compose(); - diff_bc.compose(); + } else if (ba_it->second.type == SES_DELETE && + bc_it->second.type == SES_ADD) { + // conflict + conflict = true; + return B; + } else if (ba_it->second.type == SES_ADD && + bc_it->second.type == SES_COMMON) { + seq.push_back(ba_it->first); + forwardUntilEnd(ba_end, ba_it); + } else if (ba_it->second.type == SES_ADD && + bc_it->second.type == SES_DELETE) { + // conflict + conflict = true; + return B; + } else if (ba_it->second.type == SES_ADD && + bc_it->second.type == SES_ADD) { + if (ba_it->first == bc_it->first) { + seq.push_back(ba_it->first); + forwardUntilEnd(ba_end, ba_it); + forwardUntilEnd(bc_end, bc_it); + } else { + // conflict + conflict = true; + return B; } - - private : - /** - * merge implementation - */ - sequence merge_ () { - elemVec seq; - Ses< elem > ses_ba = diff_ba.getSes(); - Ses< elem > ses_bc = diff_bc.getSes(); - sesElemVec ses_ba_v = ses_ba.getSequence(); - sesElemVec ses_bc_v = ses_bc.getSequence(); - sesElemVec_iter ba_it = ses_ba_v.begin(); - sesElemVec_iter bc_it = ses_bc_v.begin(); - sesElemVec_iter ba_end = ses_ba_v.end(); - sesElemVec_iter bc_end = ses_bc_v.end(); - - while (!isEnd(ba_end, ba_it) || !isEnd(bc_end, bc_it)) { - while (true) { - if (!isEnd(ba_end, ba_it) && - !isEnd(bc_end, bc_it) && - ba_it->first == bc_it->first && - ba_it->second.type == SES_COMMON && - bc_it->second.type == SES_COMMON) { - // do nothing - } else { - break; - } - if (!isEnd(ba_end, ba_it)) seq.push_back(ba_it->first); - else if (!isEnd(bc_end, bc_it)) seq.push_back(bc_it->first); - forwardUntilEnd(ba_end, ba_it); - forwardUntilEnd(bc_end, bc_it); - } - if (isEnd(ba_end, ba_it) || isEnd(bc_end, bc_it)) break; - if ( ba_it->second.type == SES_COMMON - && bc_it->second.type == SES_DELETE) { - forwardUntilEnd(ba_end, ba_it); - forwardUntilEnd(bc_end, bc_it); - } else if (ba_it->second.type == SES_COMMON && - bc_it->second.type == SES_ADD) { - seq.push_back(bc_it->first); - forwardUntilEnd(bc_end, bc_it); - } else if (ba_it->second.type == SES_DELETE && - bc_it->second.type == SES_COMMON) { - forwardUntilEnd(ba_end, ba_it); - forwardUntilEnd(bc_end, bc_it); - } else if (ba_it->second.type == SES_DELETE && - bc_it->second.type == SES_DELETE) { - if (ba_it->first == bc_it->first) { - forwardUntilEnd(ba_end, ba_it); - forwardUntilEnd(bc_end, bc_it); - } else { - // conflict - conflict = true; - return B; - } - } else if (ba_it->second.type == SES_DELETE && - bc_it->second.type == SES_ADD) { - // conflict - conflict = true; - return B; - } else if (ba_it->second.type == SES_ADD && - bc_it->second.type == SES_COMMON) { - seq.push_back(ba_it->first); - forwardUntilEnd(ba_end, ba_it); - } else if (ba_it->second.type == SES_ADD && - bc_it->second.type == SES_DELETE) { - // conflict - conflict = true; - return B; - } else if (ba_it->second.type == SES_ADD && - bc_it->second.type == SES_ADD) { - if (ba_it->first == bc_it->first) { - seq.push_back(ba_it->first); - forwardUntilEnd(ba_end, ba_it); - forwardUntilEnd(bc_end, bc_it); - } else { - // conflict - conflict = true; - return B; - } - } - } - - if (isEnd(ba_end, ba_it)) { - addDecentSequence(bc_end, bc_it, seq); - } else if (isEnd(bc_end, bc_it)) { - addDecentSequence(ba_end, ba_it, seq); - } - - sequence mergedSeq(seq.begin(), seq.end()); - return mergedSeq; - } - - /** - * join elem vectors - */ - void inline joinElemVec (elemVec& s1, elemVec& s2) const { - if (!s2.empty()) { - for (elemVec_iter vit=s2.begin();vit!=s2.end();++vit) { - s1.push_back(*vit); - } - } - } - - /** - * check if sequence is at end - */ - template - bool inline isEnd (const T_iter& end, const T_iter& it) const { - return it == end ? true : false; - } - - /** - * increment iterator until iterator is at end - */ - template - void inline forwardUntilEnd (const T_iter& end, T_iter& it) const { - if (!isEnd(end, it)) ++it; - } - - /** - * add elements whose SES's type is ADD - */ - void inline addDecentSequence (const sesElemVec_iter& end, sesElemVec_iter& it, elemVec& seq) const { - while (!isEnd(end, it)) { - if (it->second.type == SES_ADD) seq.push_back(it->first); - ++it; - } - } - - }; -} + } + } + + if (isEnd(ba_end, ba_it)) { + addDecentSequence(bc_end, bc_it, seq); + } else if (isEnd(bc_end, bc_it)) { + addDecentSequence(ba_end, ba_it, seq); + } + + sequence mergedSeq(seq.begin(), seq.end()); + return mergedSeq; + } + + /** + * join elem vectors + */ + void inline joinElemVec(elemVec &s1, elemVec &s2) const { + if (!s2.empty()) { + for (elemVec_iter vit = s2.begin(); vit != s2.end(); ++vit) { + s1.push_back(*vit); + } + } + } + + /** + * check if sequence is at end + */ + template + bool inline isEnd(const T_iter &end, const T_iter &it) const { + return it == end ? true : false; + } + + /** + * increment iterator until iterator is at end + */ + template + void inline forwardUntilEnd(const T_iter &end, T_iter &it) const { + if (!isEnd(end, it)) + ++it; + } + + /** + * add elements whose SES's type is ADD + */ + void inline addDecentSequence(const sesElemVec_iter &end, sesElemVec_iter &it, + elemVec &seq) const { + while (!isEnd(end, it)) { + if (it->second.type == SES_ADD) + seq.push_back(it->first); + ++it; + } + } +}; +} // namespace dtl #endif // DTL_DIFF3_H diff --git a/dtl/Lcs.hpp b/dtl/Lcs.hpp index e47c238..2ae422e 100644 --- a/dtl/Lcs.hpp +++ b/dtl/Lcs.hpp @@ -1,25 +1,25 @@ /** dtl -- Diff Template Library - + In short, Diff Template Library is distributed under so called "BSD license", - + Copyright (c) 2015 Tatsuhiko Kubo All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + * Neither the name of the authors nor the names of its contributors - may be used to endorse or promote products derived from this software + may be used to endorse or promote products derived from this software without specific prior written permission. - + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -39,17 +39,15 @@ #define DTL_LCS_H namespace dtl { - - /** - * Longest Common Subsequence template class - */ - template - class Lcs : public Sequence< elem > - { - public : - Lcs () {} - ~Lcs () {} - }; -} + +/** + * Longest Common Subsequence template class + */ +template class Lcs : public Sequence { +public: + Lcs() {} + ~Lcs() {} +}; +} // namespace dtl #endif // DTL_LCS_H diff --git a/dtl/Sequence.hpp b/dtl/Sequence.hpp index eeab0ed..c2f29d0 100644 --- a/dtl/Sequence.hpp +++ b/dtl/Sequence.hpp @@ -1,25 +1,25 @@ /** dtl -- Diff Template Library - + In short, Diff Template Library is distributed under so called "BSD license", - + Copyright (c) 2015 Tatsuhiko Kubo All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + * Neither the name of the authors nor the names of its contributors - may be used to endorse or promote products derived from this software + may be used to endorse or promote products derived from this software without specific prior written permission. - + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -39,27 +39,22 @@ #define DTL_SEQUENCE_H namespace dtl { - - /** - * sequence class template - */ - template - class Sequence - { - public : - typedef vector< elem > elemVec; - Sequence () {} - virtual ~Sequence () {} - - elemVec getSequence () const { - return sequence; - } - void addSequence (elem e) { - sequence.push_back(e); - } - protected : - elemVec sequence; - }; -} + +/** + * sequence class template + */ +template class Sequence { +public: + typedef vector elemVec; + Sequence() {} + virtual ~Sequence() {} + + elemVec getSequence() const { return sequence; } + void addSequence(elem e) { sequence.push_back(e); } + +protected: + elemVec sequence; +}; +} // namespace dtl #endif // DTL_SEQUENCE_H diff --git a/dtl/Ses.hpp b/dtl/Ses.hpp index 281144e..7781a43 100644 --- a/dtl/Ses.hpp +++ b/dtl/Ses.hpp @@ -1,25 +1,25 @@ /** dtl -- Diff Template Library - + In short, Diff Template Library is distributed under so called "BSD license", - + Copyright (c) 2015 Tatsuhiko Kubo All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + * Neither the name of the authors nor the names of its contributors - may be used to endorse or promote products derived from this software + may be used to endorse or promote products derived from this software without specific prior written permission. - + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -39,94 +39,85 @@ #define DTL_SES_H namespace dtl { - - /** - * Shortest Edit Script template class - */ - template - class Ses : public Sequence< elem > - { - private : - typedef pair< elem, elemInfo > sesElem; - typedef vector< sesElem > sesElemVec; - public : - - Ses () : onlyAdd(true), onlyDelete(true), onlyCopy(true), deletesFirst(false) { - nextDeleteIdx = 0; - } - Ses (bool moveDel) : onlyAdd(true), onlyDelete(true), onlyCopy(true), deletesFirst(moveDel) { - nextDeleteIdx = 0; - } - ~Ses () {} - - bool isOnlyAdd () const { - return onlyAdd; - } - - bool isOnlyDelete () const { - return onlyDelete; - } - - bool isOnlyCopy () const { - return onlyCopy; - } - - bool isOnlyOneOperation () const { - return isOnlyAdd() || isOnlyDelete() || isOnlyCopy(); - } - - bool isChange () const { - return !onlyCopy; - } - - using Sequence< elem >::addSequence; - void addSequence (elem e, long long beforeIdx, long long afterIdx, const edit_t type) { - elemInfo info; - info.beforeIdx = beforeIdx; - info.afterIdx = afterIdx; - info.type = type; - sesElem pe(e, info); - if (!deletesFirst) { - sequence.push_back(pe); - } - switch (type) { - case SES_DELETE: - onlyCopy = false; - onlyAdd = false; - if (deletesFirst) { - sequence.insert(sequence.begin() + nextDeleteIdx, pe); - nextDeleteIdx++; - } - break; - case SES_COMMON: - onlyAdd = false; - onlyDelete = false; - if (deletesFirst) { - sequence.push_back(pe); - nextDeleteIdx = sequence.size(); - } - break; - case SES_ADD: - onlyDelete = false; - onlyCopy = false; - if (deletesFirst) { - sequence.push_back(pe); - } - break; - } - } - - sesElemVec getSequence () const { - return sequence; - } - private : - sesElemVec sequence; - bool onlyAdd; - bool onlyDelete; - bool onlyCopy; - bool deletesFirst; - size_t nextDeleteIdx; - }; -} + +/** + * Shortest Edit Script template class + */ +template class Ses : public Sequence { +private: + typedef pair sesElem; + typedef vector sesElemVec; + +public: + Ses() : onlyAdd(true), onlyDelete(true), onlyCopy(true), deletesFirst(false) { + nextDeleteIdx = 0; + } + Ses(bool moveDel) + : onlyAdd(true), onlyDelete(true), onlyCopy(true), deletesFirst(moveDel) { + nextDeleteIdx = 0; + } + ~Ses() {} + + bool isOnlyAdd() const { return onlyAdd; } + + bool isOnlyDelete() const { return onlyDelete; } + + bool isOnlyCopy() const { return onlyCopy; } + + bool isOnlyOneOperation() const { + return isOnlyAdd() || isOnlyDelete() || isOnlyCopy(); + } + + bool isChange() const { return !onlyCopy; } + + using Sequence::addSequence; + void addSequence(elem e, long long beforeIdx, long long afterIdx, + const edit_t type) { + elemInfo info; + info.beforeIdx = beforeIdx; + info.afterIdx = afterIdx; + info.type = type; + sesElem pe(e, info); + if (!deletesFirst) { + sequence.push_back(pe); + } + switch (type) { + case SES_DELETE: + onlyCopy = false; + onlyAdd = false; + if (deletesFirst) { + sequence.insert(sequence.begin() + nextDeleteIdx, pe); + nextDeleteIdx++; + } + break; + case SES_COMMON: + onlyAdd = false; + onlyDelete = false; + if (deletesFirst) { + sequence.push_back(pe); + nextDeleteIdx = sequence.size(); + } + break; + case SES_ADD: + onlyDelete = false; + onlyCopy = false; + if (deletesFirst) { + sequence.push_back(pe); + } + break; + } + } + + sesElemVec getSequence() const { return sequence; } + +private: + sesElemVec sequence; + bool onlyAdd; + bool onlyDelete; + bool onlyCopy; + bool deletesFirst; + size_t nextDeleteIdx; +}; +} // namespace dtl #endif // DTL_SES_H diff --git a/dtl/dtl.hpp b/dtl/dtl.hpp index b6231ba..1f37ac2 100644 --- a/dtl/dtl.hpp +++ b/dtl/dtl.hpp @@ -1,25 +1,25 @@ /** dtl -- Diff Template Library - + In short, Diff Template Library is distributed under so called "BSD license", - + Copyright (c) 2015 Tatsuhiko Kubo All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + * Neither the name of the authors nor the names of its contributors - may be used to endorse or promote products derived from this software + may be used to endorse or promote products derived from this software without specific prior written permission. - + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -36,12 +36,12 @@ #ifndef DTL_H #define DTL_H -#include "variables.hpp" -#include "functors.hpp" -#include "Sequence.hpp" -#include "Lcs.hpp" -#include "Ses.hpp" #include "Diff.hpp" #include "Diff3.hpp" +#include "Lcs.hpp" +#include "Sequence.hpp" +#include "Ses.hpp" +#include "functors.hpp" +#include "variables.hpp" #endif // DTL_H diff --git a/dtl/functors.hpp b/dtl/functors.hpp index 86d8709..7e789f3 100644 --- a/dtl/functors.hpp +++ b/dtl/functors.hpp @@ -1,25 +1,25 @@ /** dtl -- Diff Template Library - + In short, Diff Template Library is distributed under so called "BSD license", - + Copyright (c) 2015 Tatsuhiko Kubo All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + * Neither the name of the authors nor the names of its contributors - may be used to endorse or promote products derived from this software + may be used to endorse or promote products derived from this software without specific prior written permission. - + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -39,113 +39,108 @@ #define DTL_FUNCTORS_H namespace dtl { - - /** - * printer class template - */ - template - class Printer - { - public : - Printer () : out_(cout) {} - Printer (stream& out) : out_(out) {} - virtual ~Printer () {} - virtual void operator() (const sesElem& se) const = 0; - protected : - stream& out_; - }; - - /** - * common element printer class template - */ - template - class CommonPrinter : public Printer < sesElem, stream > - { - public : - CommonPrinter () : Printer < sesElem, stream > () {} - CommonPrinter (stream& out) : Printer < sesElem, stream > (out) {} - ~CommonPrinter () {} - void operator() (const sesElem& se) const { - this->out_ << SES_MARK_COMMON << se.first << endl; - } - }; - - /** - * ses element printer class template - */ - template - class ChangePrinter : public Printer < sesElem, stream > - { - public : - ChangePrinter () : Printer < sesElem, stream > () {} - ChangePrinter (stream& out) : Printer < sesElem, stream > (out) {} - ~ChangePrinter () {} - void operator() (const sesElem& se) const { - switch (se.second.type) { - case SES_ADD: - this->out_ << SES_MARK_ADD << se.first << endl; - break; - case SES_DELETE: - this->out_ << SES_MARK_DELETE << se.first << endl; - break; - case SES_COMMON: - this->out_ << SES_MARK_COMMON << se.first << endl; - break; - } - } - }; - - /** - * unified format element printer class template - */ - template - class UniHunkPrinter - { - public : - UniHunkPrinter () : out_(cout) {} - UniHunkPrinter (stream& out) : out_(out) {} - ~UniHunkPrinter () {} - void operator() (const uniHunk< sesElem >& hunk) const { - out_ << "@@" - << " -" << hunk.a << "," << hunk.b - << " +" << hunk.c << "," << hunk.d - << " @@" << endl; - - for_each(hunk.common[0].begin(), hunk.common[0].end(), CommonPrinter< sesElem, stream >(out_)); - for_each(hunk.change.begin(), hunk.change.end(), ChangePrinter< sesElem, stream >(out_)); - for_each(hunk.common[1].begin(), hunk.common[1].end(), CommonPrinter< sesElem, stream >(out_)); - } - private : - stream& out_; - }; - /** - * storage class template - */ - template - class Storage - { - public: - Storage(storedData& sd) : storedData_(sd) {} - virtual ~Storage() {} - virtual void operator() (const sesElem& se) const = 0; - protected: - storedData& storedData_; - }; - - /** - * compare class template - */ - template - class Compare - { - public : - Compare () {} - virtual ~Compare () {} - virtual inline bool impl (const elem& e1, const elem& e2) const { - return e1 == e2; - } - }; -} +/** + * printer class template + */ +template class Printer { +public: + Printer() : out_(cout) {} + Printer(stream &out) : out_(out) {} + virtual ~Printer() {} + virtual void operator()(const sesElem &se) const = 0; + +protected: + stream &out_; +}; + +/** + * common element printer class template + */ +template +class CommonPrinter : public Printer { +public: + CommonPrinter() : Printer() {} + CommonPrinter(stream &out) : Printer(out) {} + ~CommonPrinter() {} + void operator()(const sesElem &se) const { + this->out_ << SES_MARK_COMMON << se.first << endl; + } +}; + +/** + * ses element printer class template + */ +template +class ChangePrinter : public Printer { +public: + ChangePrinter() : Printer() {} + ChangePrinter(stream &out) : Printer(out) {} + ~ChangePrinter() {} + void operator()(const sesElem &se) const { + switch (se.second.type) { + case SES_ADD: + this->out_ << SES_MARK_ADD << se.first << endl; + break; + case SES_DELETE: + this->out_ << SES_MARK_DELETE << se.first << endl; + break; + case SES_COMMON: + this->out_ << SES_MARK_COMMON << se.first << endl; + break; + } + } +}; + +/** + * unified format element printer class template + */ +template class UniHunkPrinter { +public: + UniHunkPrinter() : out_(cout) {} + UniHunkPrinter(stream &out) : out_(out) {} + ~UniHunkPrinter() {} + void operator()(const uniHunk &hunk) const { + out_ << "@@" + << " -" << hunk.a << "," << hunk.b << " +" << hunk.c << "," << hunk.d + << " @@" << endl; + + for_each(hunk.common[0].begin(), hunk.common[0].end(), + CommonPrinter(out_)); + for_each(hunk.change.begin(), hunk.change.end(), + ChangePrinter(out_)); + for_each(hunk.common[1].begin(), hunk.common[1].end(), + CommonPrinter(out_)); + } + +private: + stream &out_; +}; + +/** + * storage class template + */ +template class Storage { +public: + Storage(storedData &sd) : storedData_(sd) {} + virtual ~Storage() {} + virtual void operator()(const sesElem &se) const = 0; + +protected: + storedData &storedData_; +}; + +/** + * compare class template + */ +template class Compare { +public: + Compare() {} + virtual ~Compare() {} + virtual inline bool impl(const elem &e1, const elem &e2) const { + return e1 == e2; + } +}; +} // namespace dtl #endif // DTL_FUNCTORS_H diff --git a/dtl/variables.hpp b/dtl/variables.hpp index 6720ec8..e93f843 100644 --- a/dtl/variables.hpp +++ b/dtl/variables.hpp @@ -1,25 +1,25 @@ /** dtl -- Diff Template Library - + In short, Diff Template Library is distributed under so called "BSD license", - + Copyright (c) 2015 Tatsuhiko Kubo All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + * Neither the name of the authors nor the names of its contributors - may be used to endorse or promote products derived from this software + may be used to endorse or promote products derived from this software without specific prior written permission. - + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -38,105 +38,104 @@ #ifndef DTL_VARIABLES_H #define DTL_VARIABLES_H -#include -#include -#include #include #include +#include +#include +#include namespace dtl { - - using std::vector; - using std::string; - using std::pair; - using std::ostream; - using std::list; - using std::for_each; - using std::distance; - using std::fill; - using std::cout; - using std::endl; - using std::rotate; - using std::swap; - using std::max; - /** - * version string - */ - const string version = "1.20"; +using std::cout; +using std::distance; +using std::endl; +using std::fill; +using std::for_each; +using std::list; +using std::max; +using std::ostream; +using std::pair; +using std::rotate; +using std::string; +using std::swap; +using std::vector; - /** - * type of edit for SES - */ - typedef int edit_t; - const edit_t SES_DELETE = -1; - const edit_t SES_COMMON = 0; - const edit_t SES_ADD = 1; - - /** - * mark of SES - */ +/** + * version string + */ +const string version = "1.21"; + +/** + * type of edit for SES + */ +typedef int edit_t; +const edit_t SES_DELETE = -1; +const edit_t SES_COMMON = 0; +const edit_t SES_ADD = 1; + +/** + * mark of SES + */ #define SES_MARK_DELETE "-" #define SES_MARK_COMMON " " -#define SES_MARK_ADD "+" +#define SES_MARK_ADD "+" - /** - * info for Unified Format - */ - typedef struct eleminfo { - long long beforeIdx; // index of prev sequence - long long afterIdx; // index of after sequence - edit_t type; // type of edit(Add, Delete, Common) - bool operator==(const eleminfo& other) const{ - return (this->beforeIdx == other.beforeIdx && this->afterIdx == other.afterIdx && this->type == other.type); - } - } elemInfo; - - const long long DTL_SEPARATE_SIZE = 3; - const long long DTL_CONTEXT_SIZE = 3; - - /** - * cordinate for registering route - */ - typedef struct Point { - long long x; // x cordinate - long long y; // y cordinate - long long k; // vertex - } P; - - /** - * limit of cordinate size - */ - const unsigned long long MAX_CORDINATES_SIZE = 2000000; - - typedef vector< long long > editPath; - typedef vector< P > editPathCordinates; - - /** - * Structure of Unified Format Hunk - */ - template - struct uniHunk { - long long a, b, c, d; // @@ -a,b +c,d @@ - vector< sesElem > common[2]; // anteroposterior commons on changes - vector< sesElem > change; // changes - long long inc_dec_count; // count of increace and decrease - }; +/** + * info for Unified Format + */ +typedef struct eleminfo { + long long beforeIdx; // index of prev sequence + long long afterIdx; // index of after sequence + edit_t type; // type of edit(Add, Delete, Common) + bool operator==(const eleminfo &other) const { + return (this->beforeIdx == other.beforeIdx && + this->afterIdx == other.afterIdx && this->type == other.type); + } +} elemInfo; -#define dtl_typedefs(elem, sequence) \ - typedef pair< elem, elemInfo > sesElem; \ - typedef vector< sesElem > sesElemVec; \ - typedef vector< uniHunk< sesElem > > uniHunkVec; \ - typedef list< elem > elemList; \ - typedef vector< elem > elemVec; \ - typedef typename uniHunkVec::iterator uniHunkVec_iter; \ - typedef typename sesElemVec::iterator sesElemVec_iter; \ - typedef typename elemList::iterator elemList_iter; \ - typedef typename sequence::iterator sequence_iter; \ - typedef typename sequence::const_iterator sequence_const_iter; \ - typedef typename elemVec::iterator elemVec_iter; +const long long DTL_SEPARATE_SIZE = 3; +const long long DTL_CONTEXT_SIZE = 3; +/** + * cordinate for registering route + */ +typedef struct Point { + long long x; // x cordinate + long long y; // y cordinate + long long k; // vertex +} P; -} +/** + * limit of cordinate size + */ +const unsigned long long MAX_CORDINATES_SIZE = 2000000; + +typedef vector editPath; +typedef vector

editPathCordinates; + +/** + * Structure of Unified Format Hunk + */ +template struct uniHunk { + long long a, b, c, d; // @@ -a,b +c,d @@ + vector common[2]; // anteroposterior commons on changes + vector change; // changes + long long inc_dec_count; // count of increace and decrease +}; + +#define dtl_typedefs(elem, sequence) \ + typedef pair sesElem; \ + typedef vector sesElemVec; \ + typedef vector> uniHunkVec; \ + typedef list elemList; \ + typedef vector elemVec; \ + typedef typename uniHunkVec::iterator uniHunkVec_iter; \ + typedef typename sesElemVec::iterator sesElemVec_iter; \ + typedef typename elemList::iterator elemList_iter; \ + typedef typename sequence::iterator sequence_iter; \ + typedef typename sequence::const_iterator sequence_const_iter; \ + typedef typename elemVec::iterator elemVec_iter; + +} // namespace dtl #endif // DTL_VARIABLES_H diff --git a/examples/bdiff.cpp b/examples/bdiff.cpp index 5108bd2..638b930 100644 --- a/examples/bdiff.cpp +++ b/examples/bdiff.cpp @@ -1,14 +1,14 @@ -#include #include "common.hpp" +#include -#include -#include -#include #include -#include -#include #include +#include +#include +#include +#include +#include #ifdef HAVE_UNISTD_H #include #endif // HAVE_UNISTD_H @@ -17,57 +17,55 @@ using namespace std; using dtl::Diff; -typedef unsigned char elem; -typedef vector< elem > sequence; +typedef unsigned char elem; +typedef vector sequence; -static int create_byte_seq(const char *fs, sequence& seq); -static int create_byte_seq(const char *fs, sequence& seq) -{ - int fd; - int siz; - elem buf[BUFSIZ]; - if ((fd = open(fs, O_RDONLY)) == -1) { - cout << "Opening failed." << endl; - return -1; - } - while ((siz = read(fd, buf, sizeof(buf))) > 0) { - for (int i=0;i 0) { + for (int i = 0; i < siz; ++i) { + seq.push_back(buf[i]); } + } + if (siz < 0) { close(fd); - return 0; + cout << "Read error." << endl; + return -1; + } + close(fd); + return 0; } -int main(int argc, char *argv[]) -{ - - if (isFewArgs(argc)) { - cerr << "Too few arguments." << endl; - return -1; - } - - string fs1(argv[1]); - string fs2(argv[2]); - sequence seq1; - sequence seq2; - - create_byte_seq(fs1.c_str(), seq1); - create_byte_seq(fs2.c_str(), seq2); - - Diff< elem, sequence > d(seq1, seq2); - d.compose(); +int main(int argc, char *argv[]) { - if (d.getEditDistance() == 0) { - cout << fs1 << " is the same as " << fs2 << endl; - } else { - cout << fs1 << " is different from " << fs2 << endl; - } - - return 0; + if (isFewArgs(argc)) { + cerr << "Too few arguments." << endl; + return -1; + } + + string fs1(argv[1]); + string fs2(argv[2]); + sequence seq1; + sequence seq2; + + create_byte_seq(fs1.c_str(), seq1); + create_byte_seq(fs2.c_str(), seq2); + + Diff d(seq1, seq2); + d.compose(); + + if (d.getEditDistance() == 0) { + cout << fs1 << " is the same as " << fs2 << endl; + } else { + cout << fs1 << " is different from " << fs2 << endl; + } + + return 0; } diff --git a/examples/common.cpp b/examples/common.cpp index cd2a9b6..4cf47d5 100644 --- a/examples/common.cpp +++ b/examples/common.cpp @@ -1,20 +1,19 @@ #include "common.hpp" -bool isFileExist (string& fs) { - FILE *fp; - if ((fp = fopen(fs.c_str(), "r")) == NULL) { - return false; - } - fclose(fp); - return true; +bool isFileExist(string &fs) { + FILE *fp; + if ((fp = fopen(fs.c_str(), "r")) == NULL) { + return false; + } + fclose(fp); + return true; } -bool isFewArgs (int argc, int limit) { - bool ret = false; - if (argc < limit) { - ret = true; - } - return ret; +bool isFewArgs(int argc, int limit) { + bool ret = false; + if (argc < limit) { + ret = true; + } + return ret; } - diff --git a/examples/common.hpp b/examples/common.hpp index 7159841..56fb9f2 100644 --- a/examples/common.hpp +++ b/examples/common.hpp @@ -2,12 +2,12 @@ #ifndef DTL_EXAMPLE_COMMON_H #define DTL_EXAMPLE_COMMON_H -#include #include +#include using namespace std; -bool isFileExist (string& fs); -bool isFewArgs (int argc, int limit = 3); +bool isFileExist(string &fs); +bool isFewArgs(int argc, int limit = 3); #endif diff --git a/examples/fpatch.cpp b/examples/fpatch.cpp index eef90de..a5b7a41 100644 --- a/examples/fpatch.cpp +++ b/examples/fpatch.cpp @@ -1,73 +1,73 @@ -#include #include "common.hpp" +#include +#include +#include #include #include -#include #include -#include using namespace std; using dtl::Diff; -int main(int argc, char *argv[]){ - - if (isFewArgs(argc)) { - cerr << "Too few arguments." << endl; - return -1; - } - - string A(argv[1]); - string B(argv[2]); - bool fileExist = true; - - if (!isFileExist(A)) { - cerr << "file A does not exist" << endl; - fileExist = false; - } - - if (!isFileExist(B)) { - cerr << "file B does not exist" << endl; - fileExist = false; - } - - if (!fileExist) { - return -1; - } - - typedef string elem; - typedef vector< elem > sequence; +int main(int argc, char *argv[]) { - ifstream Aifs(A.c_str()); - ifstream Bifs(B.c_str()); - elem buf; - sequence ALines, BLines; - ostringstream ossLine, ossInfo; - - while(getline(Aifs, buf)){ - ALines.push_back(buf); - } - while(getline(Bifs, buf)){ - BLines.push_back(buf); - } - - Diff< elem > d(ALines, BLines); - d.compose(); - - sequence s1 = ALines; - sequence s2 = d.patch(s1); - - // fpatch - assert(BLines == s2); - cout << "fpatch succeeded" << endl; - - d.composeUnifiedHunks(); - sequence s3 = d.uniPatch(s1); - - // unipatch - assert(BLines == s3); - cout << "unipatch succeeded" << endl; - - return 0; + if (isFewArgs(argc)) { + cerr << "Too few arguments." << endl; + return -1; + } + + string A(argv[1]); + string B(argv[2]); + bool fileExist = true; + + if (!isFileExist(A)) { + cerr << "file A does not exist" << endl; + fileExist = false; + } + + if (!isFileExist(B)) { + cerr << "file B does not exist" << endl; + fileExist = false; + } + + if (!fileExist) { + return -1; + } + + typedef string elem; + typedef vector sequence; + + ifstream Aifs(A.c_str()); + ifstream Bifs(B.c_str()); + elem buf; + sequence ALines, BLines; + ostringstream ossLine, ossInfo; + + while (getline(Aifs, buf)) { + ALines.push_back(buf); + } + while (getline(Bifs, buf)) { + BLines.push_back(buf); + } + + Diff d(ALines, BLines); + d.compose(); + + sequence s1 = ALines; + sequence s2 = d.patch(s1); + + // fpatch + assert(BLines == s2); + cout << "fpatch succeeded" << endl; + + d.composeUnifiedHunks(); + sequence s3 = d.uniPatch(s1); + + // unipatch + assert(BLines == s3); + cout << "unipatch succeeded" << endl; + + return 0; } diff --git a/examples/intdiff.cpp b/examples/intdiff.cpp index 4478065..af56f5a 100644 --- a/examples/intdiff.cpp +++ b/examples/intdiff.cpp @@ -1,49 +1,49 @@ +#include #include #include -#include using namespace std; using dtl::Diff; -int main(int, char**){ - - int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; - int b[] = {3, 5, 1, 4, 5, 1, 7, 9, 6, 10}; - int asiz = sizeof(a) / sizeof(int); - int bsiz = sizeof(b) / sizeof(int); - for (int i=0;i sequence; +int main(int, char **) { - sequence A(&a[0], &a[asiz]); - sequence B(&b[0], &b[bsiz]); - Diff< elem > d(A, B); - d.compose(); + int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int b[] = {3, 5, 1, 4, 5, 1, 7, 9, 6, 10}; + int asiz = sizeof(a) / sizeof(int); + int bsiz = sizeof(b) / sizeof(int); + for (int i = 0; i < asiz; ++i) { + cout << a[i] << " "; + } + cout << endl; + for (int i = 0; i < bsiz; ++i) { + cout << b[i] << " "; + } + cout << endl; - // editDistance - cout << "editDistance:" << d.getEditDistance() << endl; + typedef int elem; + typedef vector sequence; - // Longest Common Subsequence - sequence lcs_v = d.getLcsVec(); - cout << "LCS: "; - for (sequence::iterator vit=lcs_v.begin();vit!=lcs_v.end();++vit) { - cout << *vit << " "; - } - cout << endl; - - // Shortest Edit Script - cout << "SES" << endl; - d.printSES(); - - return 0; + sequence A(&a[0], &a[asiz]); + sequence B(&b[0], &b[bsiz]); + Diff d(A, B); + d.compose(); + + // editDistance + cout << "editDistance:" << d.getEditDistance() << endl; + + // Longest Common Subsequence + sequence lcs_v = d.getLcsVec(); + cout << "LCS: "; + for (sequence::iterator vit = lcs_v.begin(); vit != lcs_v.end(); ++vit) { + cout << *vit << " "; + } + cout << endl; + + // Shortest Edit Script + cout << "SES" << endl; + d.printSES(); + + return 0; } diff --git a/examples/intdiff3.cpp b/examples/intdiff3.cpp index 3c215fc..2c0c324 100644 --- a/examples/intdiff3.cpp +++ b/examples/intdiff3.cpp @@ -1,57 +1,57 @@ +#include #include #include #include -#include using namespace std; using dtl::Diff3; -int main(int, char**) { - - int a[10] = {1, 2, 3, 4, 5, 6, 7, 3, 9, 10}; - int b[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; - int c[10] = {1, 2, 3, 9, 5, 6, 7, 8, 9, 10}; - int answer[10] = {1, 2, 3, 9, 5, 6, 7, 3, 9, 10}; - - cout << "a:"; - for (int i=0;i<10;++i) { - cout << a[i] << " "; - } - cout << endl; - cout << "b:"; - for (int i=0;i<10;++i) { - cout << b[i] << " "; - } - cout << endl; - cout << "c:"; - for (int i=0;i<10;++i) { - cout << c[i] << " "; - } - cout << endl; - - typedef int elem; - typedef vector< int > sequence; - sequence A(&a[0], &a[10]); - sequence B(&b[0], &b[10]); - sequence C(&c[0], &c[10]); - sequence Answer(&answer[0], &answer[10]); - Diff3< elem > diff3(A, B, C); - diff3.compose(); - if (!diff3.merge()) { - cerr << "conflict." << endl; - return -1; - } - sequence s = diff3.getMergedSequence(); - cout << "s:"; - for (sequence::iterator it=s.begin();it!=s.end();++it) { - cout << *it << " "; - } - cout << endl; - - assert(s == Answer); - cout << "intdiff3 OK" << endl; - - return 0; +int main(int, char **) { + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 3, 9, 10}; + int b[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int c[10] = {1, 2, 3, 9, 5, 6, 7, 8, 9, 10}; + int answer[10] = {1, 2, 3, 9, 5, 6, 7, 3, 9, 10}; + + cout << "a:"; + for (int i = 0; i < 10; ++i) { + cout << a[i] << " "; + } + cout << endl; + cout << "b:"; + for (int i = 0; i < 10; ++i) { + cout << b[i] << " "; + } + cout << endl; + cout << "c:"; + for (int i = 0; i < 10; ++i) { + cout << c[i] << " "; + } + cout << endl; + + typedef int elem; + typedef vector sequence; + sequence A(&a[0], &a[10]); + sequence B(&b[0], &b[10]); + sequence C(&c[0], &c[10]); + sequence Answer(&answer[0], &answer[10]); + Diff3 diff3(A, B, C); + diff3.compose(); + if (!diff3.merge()) { + cerr << "conflict." << endl; + return -1; + } + sequence s = diff3.getMergedSequence(); + cout << "s:"; + for (sequence::iterator it = s.begin(); it != s.end(); ++it) { + cout << *it << " "; + } + cout << endl; + + assert(s == Answer); + cout << "intdiff3 OK" << endl; + + return 0; } diff --git a/examples/patch.cpp b/examples/patch.cpp index 909ed11..a1b2d7f 100644 --- a/examples/patch.cpp +++ b/examples/patch.cpp @@ -1,44 +1,44 @@ -#include #include "common.hpp" +#include +#include #include #include -#include using namespace std; using dtl::Diff; int main(int argc, char *argv[]) { - - if (isFewArgs(argc)) { - cerr << "Too few arguments." << endl; - return -1; - } - - typedef char elem; - typedef string sequence; - sequence A(argv[1]); - sequence B(argv[2]); - - Diff< elem, sequence > d(A, B); - d.compose(); - - sequence s1(A); - sequence s2 = d.patch(s1); - d.composeUnifiedHunks(); - sequence s3 = d.uniPatch(s1); - - cout << "before:" << s1 << endl; - cout << "after :" << s2 << endl; - assert(B == s2); - cout << "patch succeeded" << endl; - - cout << "before:" << s1 << endl; - cout << "after :" << s3 << endl; - assert(B == s3); - cout << "unipatch succeeded" << endl; - - return 0; + if (isFewArgs(argc)) { + cerr << "Too few arguments." << endl; + return -1; + } + + typedef char elem; + typedef string sequence; + + sequence A(argv[1]); + sequence B(argv[2]); + + Diff d(A, B); + d.compose(); + + sequence s1(A); + sequence s2 = d.patch(s1); + d.composeUnifiedHunks(); + sequence s3 = d.uniPatch(s1); + + cout << "before:" << s1 << endl; + cout << "after :" << s2 << endl; + assert(B == s2); + cout << "patch succeeded" << endl; + + cout << "before:" << s1 << endl; + cout << "after :" << s3 << endl; + assert(B == s3); + cout << "unipatch succeeded" << endl; + + return 0; } diff --git a/examples/printers.hpp b/examples/printers.hpp index e256d45..7f50457 100644 --- a/examples/printers.hpp +++ b/examples/printers.hpp @@ -3,26 +3,25 @@ #include -template -class customChangePrinter : public dtl::Printer < sesElem, stream > -{ -public : - customChangePrinter () : dtl::Printer < sesElem, stream > () {} - customChangePrinter (stream& out) : dtl::Printer < sesElem, stream > (out) {} - ~customChangePrinter () {} - void operator() (const sesElem& se) const { - switch (se.second.type) { - case dtl::SES_ADD: - this->out_ << "Add: " << se.first << std::endl; - break; - case dtl::SES_DELETE: - this->out_ << "Delete: " << se.first << std::endl; - break; - case dtl::SES_COMMON: - this->out_ << "Common: " << se.first << std::endl; - break; - } +template +class customChangePrinter : public dtl::Printer { +public: + customChangePrinter() : dtl::Printer() {} + customChangePrinter(stream &out) : dtl::Printer(out) {} + ~customChangePrinter() {} + void operator()(const sesElem &se) const { + switch (se.second.type) { + case dtl::SES_ADD: + this->out_ << "Add: " << se.first << std::endl; + break; + case dtl::SES_DELETE: + this->out_ << "Delete: " << se.first << std::endl; + break; + case dtl::SES_COMMON: + this->out_ << "Common: " << se.first << std::endl; + break; } + } }; #endif // DTL_PRINTERS diff --git a/examples/st2ses.cpp b/examples/st2ses.cpp index 1c1b88b..dc64479 100644 --- a/examples/st2ses.cpp +++ b/examples/st2ses.cpp @@ -1,35 +1,36 @@ -#include #include "common.hpp" -#include +#include #include +#include #include -#include #include +#include using namespace std; using namespace dtl; -int main(int argc, char *argv[]){ - - if (isFewArgs(argc, 2)) { - cerr << "Too few arguments." << endl; - return -1; - } +int main(int argc, char *argv[]) { - typedef string elem; - typedef vector< string > sequence; + if (isFewArgs(argc, 2)) { + cerr << "Too few arguments." << endl; + return -1; + } - string s(argv[1]); + typedef string elem; + typedef vector sequence; - if (!isFileExist(s)) { - cerr << s << " is invalid." << endl; - return -1; - } + string s(argv[1]); - ifstream fs(s.c_str()); - const Ses< elem > ses = Diff< elem, sequence >::composeSesFromStream< ifstream >(fs); - dtl::Diff< elem, sequence >::printSES(ses); - - return 0; + if (!isFileExist(s)) { + cerr << s << " is invalid." << endl; + return -1; + } + + ifstream fs(s.c_str()); + const Ses ses = + Diff::composeSesFromStream(fs); + dtl::Diff::printSES(ses); + + return 0; } diff --git a/examples/storage.hpp b/examples/storage.hpp index 1b020f4..349f473 100644 --- a/examples/storage.hpp +++ b/examples/storage.hpp @@ -3,25 +3,24 @@ #include -template -class CustomStorage : public dtl::Storage < sesElem, storedData > -{ -public : - CustomStorage(storedData& sd) : dtl::Storage < sesElem, storedData > (sd) {} - ~CustomStorage() {} - void operator() (const sesElem& se) const { - switch (se.second.type) { - case dtl::SES_ADD: - this->storedData_ = this->storedData_ + "Add: " + se.first + "\n"; - break; - case dtl::SES_DELETE: - this->storedData_ = this->storedData_ + "Delete: " + se.first + "\n"; - break; - case dtl::SES_COMMON: - this->storedData_ = this->storedData_ + "Common: " + se.first + "\n"; - break; - } +template +class CustomStorage : public dtl::Storage { +public: + CustomStorage(storedData &sd) : dtl::Storage(sd) {} + ~CustomStorage() {} + void operator()(const sesElem &se) const { + switch (se.second.type) { + case dtl::SES_ADD: + this->storedData_ = this->storedData_ + "Add: " + se.first + "\n"; + break; + case dtl::SES_DELETE: + this->storedData_ = this->storedData_ + "Delete: " + se.first + "\n"; + break; + case dtl::SES_COMMON: + this->storedData_ = this->storedData_ + "Common: " + se.first + "\n"; + break; } + } }; #endif // DTL_STORAGE diff --git a/examples/strdiff.cpp b/examples/strdiff.cpp index d5abc6a..fdeea0c 100644 --- a/examples/strdiff.cpp +++ b/examples/strdiff.cpp @@ -1,42 +1,42 @@ -#include #include "common.hpp" +#include #include -#include #include +#include using namespace std; using dtl::Diff; -int main(int argc, char *argv[]){ - - if (isFewArgs(argc)) { - cerr << "Too few arguments." << endl; - return -1; - } - - typedef char elem; - typedef string sequence; +int main(int argc, char *argv[]) { - sequence A(argv[1]); - sequence B(argv[2]); - - Diff< elem, sequence > d(A, B); - //d.onOnlyEditDistance(); - d.compose(); - - // editDistance - cout << "editDistance:" << d.getEditDistance() << endl; - - // Longest Common Subsequence - vector< elem > lcs_v = d.getLcsVec(); - sequence lcs_s(lcs_v.begin(), lcs_v.end()); - cout << "LCS:" << lcs_s << endl; - - // Shortest Edit Script - cout << "SES" << endl; - d.printSES(); - - return 0; + if (isFewArgs(argc)) { + cerr << "Too few arguments." << endl; + return -1; + } + + typedef char elem; + typedef string sequence; + + sequence A(argv[1]); + sequence B(argv[2]); + + Diff d(A, B); + // d.onOnlyEditDistance(); + d.compose(); + + // editDistance + cout << "editDistance:" << d.getEditDistance() << endl; + + // Longest Common Subsequence + vector lcs_v = d.getLcsVec(); + sequence lcs_s(lcs_v.begin(), lcs_v.end()); + cout << "LCS:" << lcs_s << endl; + + // Shortest Edit Script + cout << "SES" << endl; + d.printSES(); + + return 0; } diff --git a/examples/strdiff3.cpp b/examples/strdiff3.cpp index 048f37b..c6fc02b 100644 --- a/examples/strdiff3.cpp +++ b/examples/strdiff3.cpp @@ -1,35 +1,35 @@ -#include #include "common.hpp" +#include #include -#include #include +#include using namespace std; using dtl::Diff3; -int main(int argc, char *argv[]){ - - if (isFewArgs(argc, 4)) { - cerr << "Too few arguments." << endl; - return -1; - } - - typedef char elem; - typedef string sequence; +int main(int argc, char *argv[]) { - sequence A(argv[1]); - sequence B(argv[2]); - sequence C(argv[3]); - - Diff3< elem, sequence > diff3(A, B, C); - diff3.compose(); - if (!diff3.merge()) { - cerr << "conflict." << endl; - return 0; - } - cout << "result:" << diff3.getMergedSequence() << endl; - + if (isFewArgs(argc, 4)) { + cerr << "Too few arguments." << endl; + return -1; + } + + typedef char elem; + typedef string sequence; + + sequence A(argv[1]); + sequence B(argv[2]); + sequence C(argv[3]); + + Diff3 diff3(A, B, C); + diff3.compose(); + if (!diff3.merge()) { + cerr << "conflict." << endl; return 0; + } + cout << "result:" << diff3.getMergedSequence() << endl; + + return 0; } diff --git a/examples/strdiff_cp.cpp b/examples/strdiff_cp.cpp index 85d9659..d3929e1 100644 --- a/examples/strdiff_cp.cpp +++ b/examples/strdiff_cp.cpp @@ -1,5 +1,5 @@ -#include #include "common.hpp" +#include #include #include #include @@ -10,26 +10,26 @@ using namespace std; using dtl::Diff; -int main(int argc, char *argv[]){ - - if (isFewArgs(argc)) { - cerr << "Too few arguments." << endl; - return -1; - } - - typedef char elem; - typedef string sequence; +int main(int argc, char *argv[]) { - sequence A(argv[1]); - sequence B(argv[2]); - - Diff< elem, sequence > d(A, B); - d.compose(); - - // Shortest Edit Script - cout << "SES" << endl; + if (isFewArgs(argc)) { + cerr << "Too few arguments." << endl; + return -1; + } - d.printSES < ostream, customChangePrinter > (cout); - - return 0; + typedef char elem; + typedef string sequence; + + sequence A(argv[1]); + sequence B(argv[2]); + + Diff d(A, B); + d.compose(); + + // Shortest Edit Script + cout << "SES" << endl; + + d.printSES(cout); + + return 0; } diff --git a/examples/strdiff_storage.cpp b/examples/strdiff_storage.cpp index b1b3ae7..285b67b 100644 --- a/examples/strdiff_storage.cpp +++ b/examples/strdiff_storage.cpp @@ -1,5 +1,5 @@ -#include #include "common.hpp" +#include #include #include @@ -9,30 +9,30 @@ using namespace std; using dtl::Diff; -int main(int argc, char *argv[]){ - - if (isFewArgs(argc)) { - cerr << "Too few arguments." << endl; - return -1; - } - - typedef char elem; - typedef string sequence; +int main(int argc, char *argv[]) { - sequence A(argv[1]); - sequence B(argv[2]); - - Diff< elem, sequence > d(A, B); - d.compose(); - - // Shortest Edit Script - cout << "SES" << endl; + if (isFewArgs(argc)) { + cerr << "Too few arguments." << endl; + return -1; + } - string result; + typedef char elem; + typedef string sequence; - d.storeSES < string, CustomStorage > (result); + sequence A(argv[1]); + sequence B(argv[2]); - cout << result; - - return 0; + Diff d(A, B); + d.compose(); + + // Shortest Edit Script + cout << "SES" << endl; + + string result; + + d.storeSES(result); + + cout << result; + + return 0; } diff --git a/examples/unidiff.cpp b/examples/unidiff.cpp index fe1ae92..c07ac26 100644 --- a/examples/unidiff.cpp +++ b/examples/unidiff.cpp @@ -1,13 +1,13 @@ -#include #include "common.hpp" -#include +#include #include +#include #include #include -#include #include +#include using namespace std; @@ -15,97 +15,93 @@ using dtl::Diff; using dtl::elemInfo; using dtl::uniHunk; -static void showStats (string fp1, string fp2); -static void unifiedDiff (string fp1, string fp2); +static void showStats(string fp1, string fp2); +static void unifiedDiff(string fp1, string fp2); -static void showStats (string fp1, string fp2) -{ - const int MAX_LENGTH = 255; - char time_format[] = "%Y-%m-%d %H:%M:%S %z"; - time_t rawtime[2]; - struct tm *timeinfo[2]; - struct stat st[2]; - - if (stat(fp1.c_str(), &st[0]) == -1) { - cerr << "argv1 is invalid." << endl; - exit(-1); - } - if (stat(fp2.c_str(), &st[1]) == -1) { - cerr << "argv2 is invalid" << endl; - exit(-1); - } - - char buf[2][MAX_LENGTH + 1]; - rawtime[0] = st[0].st_mtime; - timeinfo[0] = localtime(&rawtime[0]); - strftime(buf[0], MAX_LENGTH, time_format, timeinfo[0]); - cout << "--- " << fp1 << '\t' << buf[0] << endl; - rawtime[1] = st[1].st_mtime; - timeinfo[1] = localtime(&rawtime[1]); - strftime(buf[1], MAX_LENGTH, time_format, timeinfo[1]); - cout << "+++ " << fp2 << '\t' << buf[1] << endl; +static void showStats(string fp1, string fp2) { + const int MAX_LENGTH = 255; + char time_format[] = "%Y-%m-%d %H:%M:%S %z"; + time_t rawtime[2]; + struct tm *timeinfo[2]; + struct stat st[2]; + + if (stat(fp1.c_str(), &st[0]) == -1) { + cerr << "argv1 is invalid." << endl; + exit(-1); + } + if (stat(fp2.c_str(), &st[1]) == -1) { + cerr << "argv2 is invalid" << endl; + exit(-1); + } + + char buf[2][MAX_LENGTH + 1]; + rawtime[0] = st[0].st_mtime; + timeinfo[0] = localtime(&rawtime[0]); + strftime(buf[0], MAX_LENGTH, time_format, timeinfo[0]); + cout << "--- " << fp1 << '\t' << buf[0] << endl; + rawtime[1] = st[1].st_mtime; + timeinfo[1] = localtime(&rawtime[1]); + strftime(buf[1], MAX_LENGTH, time_format, timeinfo[1]); + cout << "+++ " << fp2 << '\t' << buf[1] << endl; } -static void unifiedDiff (string fp1, string fp2) -{ - typedef string elem; - typedef vector< elem > sequence; - typedef pair< elem, elemInfo > sesElem; +static void unifiedDiff(string fp1, string fp2) { + typedef string elem; + typedef vector sequence; + typedef pair sesElem; - ifstream Aifs(fp1.c_str()); - ifstream Bifs(fp2.c_str()); - elem buf; - sequence ALines, BLines; - - while(getline(Aifs, buf)){ - ALines.push_back(buf); - } - while(getline(Bifs, buf)){ - BLines.push_back(buf); - } - - Diff< elem > diff(ALines, BLines); - diff.onHuge(); - //diff.onUnserious(); - diff.compose(); - - // type unihunk definition test - uniHunk< sesElem > hunk; - - if (diff.getEditDistance() > 0) { - showStats(fp1, fp2); // show file info - } - - diff.composeUnifiedHunks(); - diff.printUnifiedFormat(); + ifstream Aifs(fp1.c_str()); + ifstream Bifs(fp2.c_str()); + elem buf; + sequence ALines, BLines; + + while (getline(Aifs, buf)) { + ALines.push_back(buf); + } + while (getline(Bifs, buf)) { + BLines.push_back(buf); + } + + Diff diff(ALines, BLines); + diff.onHuge(); + // diff.onUnserious(); + diff.compose(); + + // type unihunk definition test + uniHunk hunk; + + if (diff.getEditDistance() > 0) { + showStats(fp1, fp2); // show file info + } + + diff.composeUnifiedHunks(); + diff.printUnifiedFormat(); } +int main(int argc, char *argv[]) { + if (isFewArgs(argc)) { + cerr << "Too few arguments." << endl; + return -1; + } -int main(int argc, char *argv[]) -{ - if (isFewArgs(argc)) { - cerr << "Too few arguments." << endl; - return -1; - } - - string s1(argv[1]); - string s2(argv[2]); - bool fileExist = true; - - if (!isFileExist(s1)) { - cerr << s1 << " is invalid." << endl; - fileExist = false; - } - - if (!isFileExist(s2)) { - cerr << s2 << " is invalid." << endl; - fileExist = false; - } - - if (!fileExist) { - return -1; - } - - unifiedDiff(s1, s2); - return 0; + string s1(argv[1]); + string s2(argv[2]); + bool fileExist = true; + + if (!isFileExist(s1)) { + cerr << s1 << " is invalid." << endl; + fileExist = false; + } + + if (!isFileExist(s2)) { + cerr << s2 << " is invalid." << endl; + fileExist = false; + } + + if (!fileExist) { + return -1; + } + + unifiedDiff(s1, s2); + return 0; } diff --git a/examples/unistrdiff.cpp b/examples/unistrdiff.cpp index 66726a5..f45122c 100644 --- a/examples/unistrdiff.cpp +++ b/examples/unistrdiff.cpp @@ -1,6 +1,6 @@ -#include #include "common.hpp" +#include #include #include @@ -8,33 +8,33 @@ using namespace std; using dtl::Diff; -int main(int argc, char *argv[]){ - - if (isFewArgs(argc)) { - cerr << "Too few arguments." << endl; - return -1; - } - - typedef char elem; - typedef string sequence; +int main(int argc, char *argv[]) { - sequence A(argv[1]); - sequence B(argv[2]); - - Diff d(A, B); - d.compose(); - d.composeUnifiedHunks(); - - // editDistance - cout << "editDistance:" << d.getEditDistance() << endl; - - // Longest Common Subsequence - vector lcs_v = d.getLcsVec(); - sequence lcs_s(lcs_v.begin(), lcs_v.end()); - cout << "LCS:" << lcs_s << endl; - - // print Unified Format - d.printUnifiedFormat(); - - return 0; + if (isFewArgs(argc)) { + cerr << "Too few arguments." << endl; + return -1; + } + + typedef char elem; + typedef string sequence; + + sequence A(argv[1]); + sequence B(argv[2]); + + Diff d(A, B); + d.compose(); + d.composeUnifiedHunks(); + + // editDistance + cout << "editDistance:" << d.getEditDistance() << endl; + + // Longest Common Subsequence + vector lcs_v = d.getLcsVec(); + sequence lcs_s(lcs_v.begin(), lcs_v.end()); + cout << "LCS:" << lcs_s << endl; + + // print Unified Format + d.printUnifiedFormat(); + + return 0; } diff --git a/test/Intdifftest.cpp b/test/Intdifftest.cpp index 301ca76..688ec13 100644 --- a/test/Intdifftest.cpp +++ b/test/Intdifftest.cpp @@ -1,83 +1,80 @@ #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); +class Intdifftest : public ::testing::Test { +protected: + dtl_test_typedefs(int, vector) 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 caseVec; + caseVec cases; - 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; - } + case_t createCase(const sequence a, const sequence b, string test_name) { + case_t c; + string diff_name("intdiff"); + Diff 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); - c.A = a; - c.B = b; - c.editdis = diff.getEditDistance(); - c.lcs_v = diff.getLcsVec(); - c.ses_seq = diff.getSes().getSequence(); - return c; + create_file>(path_rses, diff, + TYPE_DIFF_SES); + create_file>(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; } - - 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 >()); - } - + + 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()); } }; /** @@ -87,58 +84,58 @@ protected : * - 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); +TEST_F(Intdifftest, diff_test0) { + EXPECT_EQ(0, cases[0].editdis); - ASSERT_EQ(0, cases[0].editdis_uni); + 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); +TEST_F(Intdifftest, diff_test1) { + EXPECT_EQ(1, cases[1].editdis); - ASSERT_EQ(0, cases[1].editdis_uni); + 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); +TEST_F(Intdifftest, diff_test2) { + EXPECT_EQ(1, cases[2].editdis); - ASSERT_EQ(0, cases[2].editdis_uni); + 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); +TEST_F(Intdifftest, diff_test3) { + EXPECT_EQ(8, cases[3].editdis); - ASSERT_EQ(0, cases[3].editdis_uni); + 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); +TEST_F(Intdifftest, diff_test4) { + EXPECT_EQ(4, cases[4].editdis); - ASSERT_EQ(0, cases[4].editdis_uni); + 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); } diff --git a/test/Objdifftest.cpp b/test/Objdifftest.cpp index 2a729dc..8e23415 100644 --- a/test/Objdifftest.cpp +++ b/test/Objdifftest.cpp @@ -1,116 +1,118 @@ -#include "dtl_test_common.hpp" #include "comparators.hpp" +#include "dtl_test_common.hpp" -class Objdifftest : public ::testing::Test -{ -protected : - dtl_test_typedefs(string, vector) - 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"); +class Objdifftest : public ::testing::Test { +protected: + dtl_test_typedefs(string, vector) typedef struct case_t { + sequence A; + sequence B; + sesElemVec expected; + sesElemVec ses_seq; + } case_t; + typedef vector caseVec; - Diff< elem, sequence, comparator > diff(a, b, true); + caseVec obj_diff_cases; - diff.compose(); - - c.A = a; - c.B = b; - c.ses_seq = diff.getSes().getSequence(); - c.expected = ses; - - return c; + template + 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 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 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( + A, B, ses.getSequence(), "objdiff_test0_pattern")); } - - 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")); - } + + { + 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 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( + A, B, ses.getSequence(), "objdiff_test1_unswapped")); } - - void TearDown () { - //for_each(obj_diff_cases.begin(), obj_diff_cases.end(), Remover< case_t >()); + { + 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 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( + 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 + * - 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_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_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_F(Objdifftest, objdiff_test2_swapped) { + EXPECT_EQ(obj_diff_cases[2].expected, obj_diff_cases[2].ses_seq); } diff --git a/test/Patchtest.cpp b/test/Patchtest.cpp index 2e87cf3..8f94d55 100644 --- a/test/Patchtest.cpp +++ b/test/Patchtest.cpp @@ -1,45 +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 - cases.push_back(createCase("aaaaaaaaaaaaa>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>aaaadsafabcaaaaaaaaaaaaaaaaaaewaaabdaaaaaabbb", "aaaaaaaaaaaaaaadasfdsafsadasdafbaaaaaaaaaaaaaaaaaeaaaaaaaaaae&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&saaabcaaaaaaccc")); // 10 - } - - void TearDown () {} - +class Patchtest : public ::testing::Test { +protected: + dtl_test_typedefs(char, string) typedef struct case_t { + sequence A; + sequence B; + Diff diff; + } case_t; + typedef vector caseVec; + + caseVec cases; + + case_t createCase(sequence a, sequence b) { + case_t c; + c.A = a; + c.B = b; + c.diff = Diff(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( + "abcdefq3wefarhgorequgho4euhfteowauhfwehogfewrquhoi23hroewhoahfotrhguoi" + "ewahrgqqabcdef", + "3abcdef4976fd86ouofita67t85r876e5e746578tgliuhopoqqabcdef")); // 8 + cases.push_back(createCase("abcqqqeqqqccc", "abdqqqeqqqddd")); // 9 + cases.push_back(createCase( + "aaaaaaaaaaaaa>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + "aaaadsafabcaaaaaaaaaaaaaaaaaaewaaabdaaaaaabbb", + "aaaaaaaaaaaaaaadasfdsafsadasdafbaaaaaaaaaaaaaaaaaeaaaaaaaaaae&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" + "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&saaabcaaaaaaccc")); // 10 + } + + void TearDown() {} }; /** @@ -48,57 +101,57 @@ protected : * - 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_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_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_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_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_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_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_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_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_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_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_F (Patchtest, patch_test10) { - ASSERT_EQ(cases[10].B, cases[10].diff.patch(cases[10].A)); - ASSERT_EQ(cases[10].B, cases[10].diff.uniPatch(cases[10].A)); +TEST_F(Patchtest, patch_test10) { + ASSERT_EQ(cases[10].B, cases[10].diff.patch(cases[10].A)); + ASSERT_EQ(cases[10].B, cases[10].diff.uniPatch(cases[10].A)); } diff --git a/test/SConstruct b/test/SConstruct index 37873dd..b9541d6 100644 --- a/test/SConstruct +++ b/test/SConstruct @@ -3,18 +3,20 @@ import os + def path_chomp(path): if path[-1] == '/': return path[:-1] return path -env = Environment( + +env = Environment( CPPFLAGS=['-Wall', '-O2'], CPPPATH=['..'], - CXXFLAGS="-std=c++11", + CXXFLAGS="-std=c++11", ) -conf = Configure(env); +conf = Configure(env) if not conf.CheckCXX(): print("c++ compiler is not installed!") @@ -33,10 +35,6 @@ test = env.Program( [Glob('*.cpp')], ) -test_alias = env.Alias( - 'check', - test, - test[0].abspath -) +test_alias = env.Alias('check', test, test[0].abspath) env.AlwaysBuild(test_alias) diff --git a/test/Strdiff3test.cpp b/test/Strdiff3test.cpp index 0517815..6ad77c5 100644 --- a/test/Strdiff3test.cpp +++ b/test/Strdiff3test.cpp @@ -1,71 +1,95 @@ -#include "dtl_test_common.hpp" #include "comparators.hpp" +#include "dtl_test_common.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; +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 caseVec; - diff3.compose(); + caseVec merge_cases; + caseVec detect_cases; + caseVec custom_cases; - 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 () {} - + template + case_t createCase(sequence a, sequence b, sequence c, sequence s) { + Diff3 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>("ab", "b", "bc", "abc")); // 0 + merge_cases.push_back( + createCase>("bc", "b", "ab", "abc")); // 1 + merge_cases.push_back( + createCase>("qqqabc", "abc", "abcdef", "qqqabcdef")); // 2 + merge_cases.push_back( + createCase>("abcdef", "abc", "qqqabc", "qqqabcdef")); // 3 + merge_cases.push_back(createCase>( + "aaacccbbb", "aaabbb", "aaabbbqqq", "aaacccbbbqqq")); // 4 + merge_cases.push_back(createCase>( + "aaabbbqqq", "aaabbb", "aaacccbbb", "aaacccbbbqqq")); // 5 + merge_cases.push_back(createCase>( + "aeaacccbbb", "aaabbb", "aaabbbqqq", "aeaacccbbbqqq")); // 6 + merge_cases.push_back(createCase>( + "aaabbbqqq", "aaabbb", "aeaacccbbb", "aeaacccbbbqqq")); // 7 + merge_cases.push_back(createCase>( + "aeaacccbbb", "aaabbb", "aaabebbqqq", "aeaacccbebbqqq")); // 8 + merge_cases.push_back(createCase>( + "aaabebbqqq", "aaabbb", "aeaacccbbb", "aeaacccbebbqqq")); // 9 + merge_cases.push_back(createCase>( + "aaacccbbb", "aaabbb", "aeaabbbqqq", "aeaacccbbbqqq")); // 10 + merge_cases.push_back(createCase>( + "aeaabbbqqq", "aaabbb", "aaacccbbb", "aeaacccbbbqqq")); // 11 + merge_cases.push_back(createCase>( + "aaacccbbb", "aaabbb", "aaabeebbeeqqq", "aaacccbeebbeeqqq")); // 12 + merge_cases.push_back(createCase>( + "aaabeebbeeqqq", "aaabbb", "aaacccbbb", "aaacccbeebbeeqqq")); // 13 + merge_cases.push_back(createCase>("aiueo", "aeo", "aeKokaki", + "aiueKokaki")); // 14 + merge_cases.push_back(createCase>("aeKokaki", "aeo", "aiueo", + "aiueKokaki")); // 15 + merge_cases.push_back(createCase>( + "1234567390", "1234567890", "1239567890", "1239567390")); // 16 + merge_cases.push_back(createCase>( + "1239567890", "1234567890", "1234567390", "1239567390")); // 17 + merge_cases.push_back( + createCase>("qabcdef", "abcdef", "ab", "qab")); // 18 + merge_cases.push_back( + createCase>("ab", "abcdef", "qabcdef", "qab")); // 19 + merge_cases.push_back( + createCase>("abcdf", "abcdef", "acdef", "acdf")); // 20 + merge_cases.push_back( + createCase>("acdef", "abcdef", "abcdf", "acdf")); // 21 + merge_cases.push_back(createCase>("acdef", "abcdef", + "abcdfaa", "acdfaa")); // 22 + merge_cases.push_back(createCase>("abcdfaa", "abcdef", + "acdef", "acdfaa")); // 23 + + // detect confliction test + detect_cases.push_back( + createCase>("adc", "abc", "aec", "")); // 0 + detect_cases.push_back( + createCase>("abqdcf", "abcdef", "abqqef", "")); // 1 + + // use custom comparator + custom_cases.push_back( + createCase("abc", "abc", "abC", "abc")); + } + + void TearDown() {} }; /** @@ -74,135 +98,135 @@ protected : * - 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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, 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_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, 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_F(Strdiff3test, custom_comparator_test0) { + ASSERT_TRUE(custom_cases[0].is_merge_success); + ASSERT_EQ(custom_cases[0].S, custom_cases[0].merged_seq); } diff --git a/test/Strdifftest.cpp b/test/Strdifftest.cpp index 99ca0a8..4f1fdf7 100644 --- a/test/Strdifftest.cpp +++ b/test/Strdifftest.cpp @@ -1,102 +1,113 @@ -#include "dtl_test_common.hpp" #include "comparators.hpp" +#include "dtl_test_common.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"); +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 caseVec; - Diff< elem, sequence, comparator > diff(a, b); - if (onlyEditdis) { - diff.onOnlyEditDistance(); - } + caseVec diff_cases; + caseVec only_editdis_cases; + caseVec custom_cases; - 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; - } + template + 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"); - 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; + Diff diff(a, b); + if (onlyEditdis) { + diff.onOnlyEditDistance(); } - - 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 >()); + + 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(path_rses, diff, TYPE_DIFF_SES); + create_file(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>("abc", "abd", "diff_test0")); + diff_cases.push_back( + createCase>("acbdeacbed", "acebdabbabed", "diff_test1")); + diff_cases.push_back( + createCase>("abcdef", "dacfea", "diff_test2")); + diff_cases.push_back( + createCase>("abcbda", "bdcaba", "diff_test3")); + diff_cases.push_back( + createCase>("bokko", "bokkko", "diff_test4")); + diff_cases.push_back(createCase>("", "", "diff_test5")); + diff_cases.push_back(createCase>("a", "", "diff_test6")); + diff_cases.push_back(createCase>("", "b", "diff_test7")); + diff_cases.push_back(createCase>( + "acbdeaqqqqqqqcbed", "acebdabbqqqqqqqabed", "diff_test8")); + + only_editdis_cases.push_back( + createCase>("abc", "abd", "", true)); + only_editdis_cases.push_back( + createCase>("acbdeacbed", "acebdabbabed", "", true)); + only_editdis_cases.push_back( + createCase>("abcdef", "dacfea", "", true)); + only_editdis_cases.push_back( + createCase>("abcbda", "bdcaba", "", true)); + only_editdis_cases.push_back( + createCase>("bokko", "bokkko", "", true)); + only_editdis_cases.push_back(createCase>("", "", "", true)); + only_editdis_cases.push_back(createCase>("a", "", "", true)); + only_editdis_cases.push_back(createCase>("", "b", "", true)); + only_editdis_cases.push_back(createCase>( + "acbdeaqqqqqqqcbed", "acebdabbqqqqqqqabed", "", true)); + + custom_cases.push_back( + createCase("abc", "Abc", "custom_test0")); + } + + void TearDown() { + for_each(diff_cases.begin(), diff_cases.end(), Remover()); + for_each(custom_cases.begin(), custom_cases.end(), Remover()); + } }; - /** * Strdifftest * check list is following @@ -107,193 +118,193 @@ protected : * - 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); +TEST_F(Strdifftest, diff_test0) { - ASSERT_EQ(0, diff_cases[0].editdis_uni); + 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_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_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_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_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_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_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_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); +TEST_F(Strdifftest, diff_test8) { + EXPECT_EQ(6, diff_cases[8].editdis); - ASSERT_EQ(0, diff_cases[8].editdis_uni); + 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_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_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_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_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_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_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_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_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, 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); +TEST_F(Strdifftest, custom_comparator_test0) { + EXPECT_EQ(0, custom_cases[0].editdis); - ASSERT_EQ(0, custom_cases[0].editdis_ses); - - ASSERT_TRUE(custom_cases[0].hunk_v.empty()); + EXPECT_EQ("abc", custom_cases[0].lcs_s); + + ASSERT_EQ(0, custom_cases[0].editdis_ses); + + ASSERT_TRUE(custom_cases[0].hunk_v.empty()); } diff --git a/test/comparators.hpp b/test/comparators.hpp index bc13b0f..0a32344 100644 --- a/test/comparators.hpp +++ b/test/comparators.hpp @@ -1,24 +1,23 @@ #ifndef DTL_COMPARATORS #define DTL_COMPARATORS -class CaseInsensitive: public dtl::Compare { +class CaseInsensitive : public dtl::Compare { public: - virtual bool impl(const char& a, const char& b) const { - return tolower(a) == tolower(b); - } + virtual bool impl(const char &a, const char &b) const { + return tolower(a) == tolower(b); + } }; -class StringCaseInsensitive: public dtl::Compare { +class StringCaseInsensitive : public dtl::Compare { 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; - } + 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 diff --git a/test/dtl_test.cpp b/test/dtl_test.cpp index d2c20b4..47c7573 100644 --- a/test/dtl_test.cpp +++ b/test/dtl_test.cpp @@ -4,7 +4,7 @@ #include -int main (int argc, char *argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); +int main(int argc, char *argv[]) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/test/dtl_test_common.cpp b/test/dtl_test_common.cpp index f727a1f..84f8794 100644 --- a/test/dtl_test_common.cpp +++ b/test/dtl_test_common.cpp @@ -1,56 +1,63 @@ #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; +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()); +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; + vector llines; + vector rlines; - while (getline(lifs, buf)) { - llines.push_back(buf); - } - - while (getline(rifs, buf)) { - rlines.push_back(buf); - } + while (getline(lifs, buf)) { + llines.push_back(buf); + } - Diff< string, vector< string > > diff_uni(llines, rlines); - diff_uni.compose(); - return diff_uni.getEditDistance(); + while (getline(rifs, buf)) { + rlines.push_back(buf); + } + + Diff> 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; +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); - } +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); + } } diff --git a/test/dtl_test_common.hpp b/test/dtl_test_common.hpp index 76ad921..20adaea 100644 --- a/test/dtl_test_common.hpp +++ b/test/dtl_test_common.hpp @@ -2,69 +2,70 @@ #ifndef DTL_TEST_COMMON #define DTL_TEST_COMMON -#include #include -#include -#include -#include -#include -#include #include +#include +#include +#include +#include +#include +#include using std::cerr; using std::endl; -using std::string; -using std::vector; -using std::pair; using std::ifstream; using std::ofstream; +using std::pair; +using std::string; +using std::vector; +using dtl::Compare; 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::SES_ADD; +using dtl::SES_COMMON; +using dtl::SES_DELETE; 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; +#define dtl_test_typedefs(e_type, seq_type) \ + typedef e_type elem; \ + typedef seq_type sequence; \ + typedef pair sesElem; \ + typedef vector elemVec; \ + typedef vector sesElemVec; \ + typedef vector> 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); +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 -class Remover { -public : - void operator()(const T& v){ - remove(v.path_rses.c_str()); - remove(v.path_rhunks.c_str()); - } +template 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(); +template +void create_file(const string &path, Diff &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