Public/dtl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

formatting and fixes

Browse Source
This commit is contained in:
Scott E. Graves 2024-06-03 08:20:20 -05:00
parent 0e4c24a23d
commit 94d86a1c9f
37 changed files with 2742 additions and 2559 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
.clang-format Normal file
View File

@ -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
...

10
.clang-tidy Normal file
View File

@ -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: ''
...

10
ChangeLog
View File

@ -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 <cubicdaiya@gmail.com> 2022-04-11 Tatsuhiko Kubo <cubicdaiya@gmail.com>
* bugfix: fixed invalid offset in unified format difference when difference is too large. * bugfix: fixed invalid offset in unified format difference when difference is too large.

340
dtl/Diff.hpp
View File

@ -6,8 +6,8 @@
Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com> Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com>
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without
are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. this list of conditions and the following disclaimer.
@ -40,16 +40,15 @@
namespace dtl { namespace dtl {
/** /**
* diff class template * diff class template
* sequence must support random_access_iterator. * sequence must support random_access_iterator.
*/ */
template <typename elem, typename sequence = vector< elem >, typename comparator = Compare< elem > > template <typename elem, typename sequence = vector<elem>,
class Diff typename comparator = Compare<elem>>
{ class Diff {
private : private:
dtl_typedefs(elem, sequence) dtl_typedefs(elem, sequence) sequence A;
sequence A;
sequence B; sequence B;
size_t M; size_t M;
size_t N; size_t N;
@ -57,8 +56,8 @@ namespace dtl {
size_t offset; size_t offset;
long long *fp; long long *fp;
long long editDistance; long long editDistance;
Lcs< elem > lcs; Lcs<elem> lcs;
Ses< elem > ses; Ses<elem> ses;
editPath path; editPath path;
editPathCordinates pathCordinates; editPathCordinates pathCordinates;
bool swapped; bool swapped;
@ -69,150 +68,109 @@ namespace dtl {
comparator cmp; comparator cmp;
long long ox; long long ox;
long long oy; long long oy;
public :
Diff () {}
Diff (const sequence& a, public:
const sequence& b) : A(a), B(b), ses(false) { Diff() {}
Diff(const sequence &a, const sequence &b) : A(a), B(b), ses(false) {
init(); init();
} }
Diff (const sequence& a, Diff(const sequence &a, const sequence &b, bool deletesFirst)
const sequence& b, : A(a), B(b), ses(deletesFirst) {
bool deletesFirst) : A(a), B(b), ses(deletesFirst) {
init(); init();
} }
Diff (const sequence& a, Diff(const sequence &a, const sequence &b, const comparator &comp)
const sequence& b, : A(a), B(b), ses(false), cmp(comp) {
const comparator& comp) : A(a), B(b), ses(false), cmp(comp) {
init(); init();
} }
Diff (const sequence& a, Diff(const sequence &a, const sequence &b, bool deleteFirst,
const sequence& b, const comparator &comp)
bool deleteFirst, : A(a), B(b), ses(deleteFirst), cmp(comp) {
const comparator& comp) : A(a), B(b), ses(deleteFirst), cmp(comp) {
init(); init();
} }
~Diff() {} ~Diff() {}
long long getEditDistance () const { long long getEditDistance() const { return editDistance; }
return editDistance;
}
Lcs< elem > getLcs () const { Lcs<elem> getLcs() const { return lcs; }
return lcs;
}
elemVec getLcsVec () const { elemVec getLcsVec() const { return lcs.getSequence(); }
return lcs.getSequence();
}
Ses< elem > getSes () const { Ses<elem> getSes() const { return ses; }
return ses;
}
uniHunkVec getUniHunks () const { uniHunkVec getUniHunks() const { return uniHunks; }
return uniHunks;
}
/* These should be deprecated */ /* These should be deprecated */
bool isHuge () const { bool isHuge() const { return huge; }
return huge;
}
void onHuge () { void onHuge() { this->huge = true; }
this->huge = true;
}
void offHuge () { void offHuge() { this->huge = false; }
this->huge = false;
}
bool isUnserious () const { bool isUnserious() const { return trivial; }
return trivial;
}
void onUnserious () { void onUnserious() { this->trivial = true; }
this->trivial = true;
}
void offUnserious () { void offUnserious() { this->trivial = false; }
this->trivial = false;
}
void onOnlyEditDistance () { void onOnlyEditDistance() { this->editDistanceOnly = true; }
this->editDistanceOnly = true;
}
/* These are the replacements for the above */ /* These are the replacements for the above */
bool hugeEnabled () const { bool hugeEnabled() const { return huge; }
return huge;
}
void enableHuge () { void enableHuge() { this->huge = true; }
this->huge = true;
}
void disableHuge () { void disableHuge() { this->huge = false; }
this->huge = false;
}
bool trivialEnabled () const { bool trivialEnabled() const { return trivial; }
return trivial;
}
void enableTrivial () { void enableTrivial() { this->trivial = true; }
this->trivial = true;
}
void disableTrivial () { void disableTrivial() { this->trivial = false; }
this->trivial = false;
}
void editDistanceOnlyEnabled () { void editDistanceOnlyEnabled() { this->editDistanceOnly = true; }
this->editDistanceOnly = true;
}
/** /**
* patching with Unified Format Hunks * patching with Unified Format Hunks
*/ */
sequence uniPatch (const sequence& seq) { sequence uniPatch(const sequence &seq) {
elemList seqLst(seq.begin(), seq.end()); elemList seqLst(seq.begin(), seq.end());
sesElemVec shunk; sesElemVec shunk;
sesElemVec_iter vsesIt; sesElemVec_iter vsesIt;
elemList_iter lstIt = seqLst.begin(); elemList_iter lstIt = seqLst.begin();
long long inc_dec_total = 0; long long inc_dec_total = 0;
long long gap = 1; long long gap = 1;
for (uniHunkVec_iter it=uniHunks.begin();it!=uniHunks.end();++it) { for (uniHunkVec_iter it = uniHunks.begin(); it != uniHunks.end(); ++it) {
joinSesVec(shunk, it->common[0]); joinSesVec(shunk, it->common[0]);
joinSesVec(shunk, it->change); joinSesVec(shunk, it->change);
joinSesVec(shunk, it->common[1]); joinSesVec(shunk, it->common[1]);
it->a += inc_dec_total; it->a += inc_dec_total;
inc_dec_total += it->inc_dec_count; inc_dec_total += it->inc_dec_count;
for (long long i=0;i<it->a - gap;++i) { for (long long i = 0; i < it->a - gap; ++i) {
++lstIt; ++lstIt;
} }
gap = it->a + it->b + it->inc_dec_count; gap = it->a + it->b + it->inc_dec_count;
vsesIt = shunk.begin(); vsesIt = shunk.begin();
while (vsesIt!=shunk.end()) { while (vsesIt != shunk.end()) {
switch (vsesIt->second.type) { switch (vsesIt->second.type) {
case SES_ADD : case SES_ADD:
seqLst.insert(lstIt, vsesIt->first); seqLst.insert(lstIt, vsesIt->first);
break; break;
case SES_DELETE : case SES_DELETE:
if (lstIt != seqLst.end()) { if (lstIt != seqLst.end()) {
lstIt = seqLst.erase(lstIt); lstIt = seqLst.erase(lstIt);
} }
break; break;
case SES_COMMON : case SES_COMMON:
if (lstIt != seqLst.end()) { if (lstIt != seqLst.end()) {
++lstIt; ++lstIt;
} }
break; break;
default : default:
// no fall-through // no fall-through
break; break;
} }
@ -228,22 +186,23 @@ namespace dtl {
/** /**
* patching with Shortest Edit Script (SES) * patching with Shortest Edit Script (SES)
*/ */
sequence patch (const sequence& seq) const { sequence patch(const sequence &seq) const {
sesElemVec sesSeq = ses.getSequence(); sesElemVec sesSeq = ses.getSequence();
elemList seqLst(seq.begin(), seq.end()); elemList seqLst(seq.begin(), seq.end());
elemList_iter lstIt = seqLst.begin(); elemList_iter lstIt = seqLst.begin();
for (sesElemVec_iter sesIt=sesSeq.begin();sesIt!=sesSeq.end();++sesIt) { for (sesElemVec_iter sesIt = sesSeq.begin(); sesIt != sesSeq.end();
++sesIt) {
switch (sesIt->second.type) { switch (sesIt->second.type) {
case SES_ADD : case SES_ADD:
seqLst.insert(lstIt, sesIt->first); seqLst.insert(lstIt, sesIt->first);
break; break;
case SES_DELETE : case SES_DELETE:
lstIt = seqLst.erase(lstIt); lstIt = seqLst.erase(lstIt);
break; break;
case SES_COMMON : case SES_COMMON:
++lstIt; ++lstIt;
break; break;
default : default:
// no through // no through
break; break;
} }
@ -254,8 +213,8 @@ namespace dtl {
/** /**
* compose Longest Common Subsequence and Shortest Edit Script. * compose Longest Common Subsequence and Shortest Edit Script.
* The algorithm implemented here is based on "An O(NP) Sequence Comparison Algorithm" * The algorithm implemented here is based on "An O(NP) Sequence Comparison
* described by Sun Wu, Udi Manber and Gene Myers * Algorithm" described by Sun Wu, Udi Manber and Gene Myers
*/ */
void compose() { void compose() {
@ -272,17 +231,21 @@ namespace dtl {
ONP: ONP:
do { do {
++p; ++p;
for (long long k=-p;k<=static_cast<long long>(delta)-1;++k) { for (long long k = -p; k <= static_cast<long long>(delta) - 1; ++k) {
fp[k+offset] = snake(k, fp[k-1+offset]+1, fp[k+1+offset]); fp[k + offset] = snake(k, fp[k - 1 + offset] + 1, fp[k + 1 + offset]);
} }
for (long long k=static_cast<long long>(delta)+p;k>=static_cast<long long>(delta)+1;--k) { for (long long k = static_cast<long long>(delta) + p;
fp[k+offset] = snake(k, fp[k-1+offset]+1, fp[k+1+offset]); k >= static_cast<long long>(delta) + 1; --k) {
fp[k + offset] = snake(k, fp[k - 1 + offset] + 1, fp[k + 1 + offset]);
} }
fp[delta+offset] = snake(static_cast<long long>(delta), fp[delta-1+offset]+1, fp[delta+1+offset]); fp[delta + offset] =
} while (fp[delta+offset] != static_cast<long long>(N) && pathCordinates.size() < MAX_CORDINATES_SIZE); snake(static_cast<long long>(delta), fp[delta - 1 + offset] + 1,
fp[delta + 1 + offset]);
} while (fp[delta + offset] != static_cast<long long>(N) &&
pathCordinates.size() < MAX_CORDINATES_SIZE);
editDistance += static_cast<long long>(delta) + 2 * p; editDistance += static_cast<long long>(delta) + 2 * p;
long long r = path[delta+offset]; long long r = path[delta + offset];
P cordinate{}; P cordinate{};
editPathCordinates epc(0); editPathCordinates epc(0);
@ -292,7 +255,7 @@ namespace dtl {
return; return;
} }
while(r != -1) { while (r != -1) {
cordinate.x = pathCordinates[(size_t)r].x; cordinate.x = pathCordinates[(size_t)r].x;
cordinate.y = pathCordinates[(size_t)r].y; cordinate.y = pathCordinates[(size_t)r].y;
epc.push_back(cordinate); epc.push_back(cordinate);
@ -312,75 +275,73 @@ namespace dtl {
/** /**
* print difference between A and B as an SES * print difference between A and B as an SES
*/ */
template < typename stream > template <typename stream> void printSES(stream &out) const {
void printSES (stream& out) const {
sesElemVec ses_v = ses.getSequence(); sesElemVec ses_v = ses.getSequence();
for_each(ses_v.begin(), ses_v.end(), ChangePrinter< sesElem, stream >(out)); for_each(ses_v.begin(), ses_v.end(), ChangePrinter<sesElem, stream>(out));
} }
void printSES (ostream& out = cout) const { void printSES(ostream &out = cout) const { printSES<ostream>(out); }
printSES< ostream >(out);
}
/** /**
* print differences given an SES * print differences given an SES
*/ */
template < typename stream > template <typename stream>
static void printSES (const Ses< elem >& s, stream& out) { static void printSES(const Ses<elem> &s, stream &out) {
sesElemVec ses_v = s.getSequence(); sesElemVec ses_v = s.getSequence();
for_each(ses_v.begin(), ses_v.end(), ChangePrinter< sesElem, stream >(out)); for_each(ses_v.begin(), ses_v.end(), ChangePrinter<sesElem, stream>(out));
} }
static void printSES (const Ses< elem >& s, ostream& out = cout) { static void printSES(const Ses<elem> &s, ostream &out = cout) {
printSES< ostream >(s, out); printSES<ostream>(s, out);
} }
/** /**
* print difference between A and B as an SES with custom printer * print difference between A and B as an SES with custom printer
*/ */
template < typename stream, template < typename SEET, typename STRT > class PT > template <typename stream, template <typename SEET, typename STRT> class PT>
void printSES (stream& out) const { void printSES(stream &out) const {
sesElemVec ses_v = ses.getSequence (); sesElemVec ses_v = ses.getSequence();
for_each (ses_v.begin (), ses_v.end(), PT < sesElem, stream > (out)); for_each(ses_v.begin(), ses_v.end(), PT<sesElem, stream>(out));
} }
/** /**
* store difference between A and B as an SES with custom storage * store difference between A and B as an SES with custom storage
*/ */
template < typename storedData, template < typename SEET, typename STRT > class ST > template <typename storedData,
void storeSES(storedData& sd) const { template <typename SEET, typename STRT> class ST>
void storeSES(storedData &sd) const {
sesElemVec ses_v = ses.getSequence(); sesElemVec ses_v = ses.getSequence();
for_each(ses_v.begin(), ses_v.end(), ST < sesElem, storedData >(sd)); for_each(ses_v.begin(), ses_v.end(), ST<sesElem, storedData>(sd));
} }
/** /**
* print difference between A and B in the Unified Format * print difference between A and B in the Unified Format
*/ */
template < typename stream > template <typename stream> void printUnifiedFormat(stream &out) const {
void printUnifiedFormat (stream& out) const { for_each(uniHunks.begin(), uniHunks.end(),
for_each(uniHunks.begin(), uniHunks.end(), UniHunkPrinter< sesElem, stream >(out)); UniHunkPrinter<sesElem, stream>(out));
} }
void printUnifiedFormat (ostream& out = cout) const { void printUnifiedFormat(ostream &out = cout) const {
printUnifiedFormat< ostream >(out); printUnifiedFormat<ostream>(out);
} }
/** /**
* print unified format difference with given unified format hunks * print unified format difference with given unified format hunks
*/ */
template < typename stream > template <typename stream>
static void printUnifiedFormat (const uniHunkVec& hunks, stream& out) { static void printUnifiedFormat(const uniHunkVec &hunks, stream &out) {
for_each(hunks.begin(), hunks.end(), UniHunkPrinter< sesElem >(out)); for_each(hunks.begin(), hunks.end(), UniHunkPrinter<sesElem>(out));
} }
static void printUnifiedFormat (const uniHunkVec& hunks, ostream& out = cout) { static void printUnifiedFormat(const uniHunkVec &hunks, ostream &out = cout) {
printUnifiedFormat< ostream >(hunks, out); printUnifiedFormat<ostream>(hunks, out);
} }
/** /**
* compose Unified Format Hunks from Shortest Edit Script * compose Unified Format Hunks from Shortest Edit Script
*/ */
void composeUnifiedHunks () { void composeUnifiedHunks() {
sesElemVec common[2]; sesElemVec common[2];
sesElemVec change; sesElemVec change;
sesElemVec ses_v = ses.getSequence(); sesElemVec ses_v = ses.getSequence();
@ -391,43 +352,49 @@ namespace dtl {
elemInfo einfo; elemInfo einfo;
long long a, b, c, d; // @@ -a,b +c,d @@ long long a, b, c, d; // @@ -a,b +c,d @@
long long inc_dec_count = 0; long long inc_dec_count = 0;
uniHunk< sesElem > hunk; uniHunk<sesElem> hunk;
sesElemVec adds; sesElemVec adds;
sesElemVec deletes; sesElemVec deletes;
isMiddle = isAfter = false; isMiddle = isAfter = false;
a = b = c = d = 0; a = b = c = d = 0;
for (sesElemVec_iter it=ses_v.begin();it!=ses_v.end();++it, ++l_cnt) { for (sesElemVec_iter it = ses_v.begin(); it != ses_v.end(); ++it, ++l_cnt) {
einfo = it->second; einfo = it->second;
switch (einfo.type) { switch (einfo.type) {
case SES_ADD : case SES_ADD:
middle = 0; middle = 0;
++inc_dec_count; ++inc_dec_count;
adds.push_back(*it); adds.push_back(*it);
if (!isMiddle) isMiddle = true; if (!isMiddle)
if (isMiddle) ++d; isMiddle = true;
if (isMiddle)
++d;
if (l_cnt >= length) { if (l_cnt >= length) {
joinSesVec(change, deletes); joinSesVec(change, deletes);
joinSesVec(change, adds); joinSesVec(change, adds);
isAfter = true; isAfter = true;
} }
break; break;
case SES_DELETE : case SES_DELETE:
middle = 0; middle = 0;
--inc_dec_count; --inc_dec_count;
deletes.push_back(*it); deletes.push_back(*it);
if (!isMiddle) isMiddle = true; if (!isMiddle)
if (isMiddle) ++b; isMiddle = true;
if (isMiddle)
++b;
if (l_cnt >= length) { if (l_cnt >= length) {
joinSesVec(change, deletes); joinSesVec(change, deletes);
joinSesVec(change, adds); joinSesVec(change, adds);
isAfter = true; isAfter = true;
} }
break; break;
case SES_COMMON : case SES_COMMON:
++b;++d; ++b;
if (common[1].empty() && adds.empty() && deletes.empty() && change.empty()) { ++d;
if (common[1].empty() && adds.empty() && deletes.empty() &&
change.empty()) {
if (static_cast<long long>(common[0].size()) < DTL_CONTEXT_SIZE) { if (static_cast<long long>(common[0].size()) < DTL_CONTEXT_SIZE) {
if (a == 0 && c == 0) { if (a == 0 && c == 0) {
if (!wasSwapped()) { if (!wasSwapped()) {
@ -443,8 +410,10 @@ namespace dtl {
rotate(common[0].begin(), common[0].begin() + 1, common[0].end()); rotate(common[0].begin(), common[0].begin() + 1, common[0].end());
common[0].pop_back(); common[0].pop_back();
common[0].push_back(*it); common[0].push_back(*it);
++a;++c; ++a;
--b;--d; ++c;
--b;
--d;
} }
} }
if (isMiddle && !isAfter) { if (isMiddle && !isAfter) {
@ -459,7 +428,7 @@ namespace dtl {
deletes.clear(); deletes.clear();
} }
break; break;
default : default:
// no through // no through
break; break;
} }
@ -467,7 +436,8 @@ namespace dtl {
if (isAfter && !change.empty()) { if (isAfter && !change.empty()) {
sesElemVec_iter cit = it; sesElemVec_iter cit = it;
long long cnt = 0; long long cnt = 0;
for (long long i=0;i<DTL_SEPARATE_SIZE && (cit != ses_v.end());++i, ++cit) { for (long long i = 0; i < DTL_SEPARATE_SIZE && (cit != ses_v.end());
++i, ++cit) {
if (cit->second.type == SES_COMMON) { if (cit->second.type == SES_COMMON) {
++cnt; ++cnt;
} }
@ -482,15 +452,18 @@ namespace dtl {
rotate(common[0].begin(), rotate(common[0].begin(),
common[0].begin() + (size_t)c0size - DTL_SEPARATE_SIZE, common[0].begin() + (size_t)c0size - DTL_SEPARATE_SIZE,
common[0].end()); common[0].end());
for (long long i=0;i<c0size - DTL_SEPARATE_SIZE;++i) { for (long long i = 0; i < c0size - DTL_SEPARATE_SIZE; ++i) {
common[0].pop_back(); common[0].pop_back();
} }
a += c0size - DTL_SEPARATE_SIZE; a += c0size - DTL_SEPARATE_SIZE;
c += c0size - DTL_SEPARATE_SIZE; c += c0size - DTL_SEPARATE_SIZE;
} }
if (a == 0) ++a; if (a == 0)
if (c == 0) ++c; ++a;
if (wasSwapped()) swap(a, c); if (c == 0)
++c;
if (wasSwapped())
swap(a, c);
hunk.a = a; hunk.a = a;
hunk.b = b; hunk.b = b;
hunk.c = c; hunk.c = c;
@ -515,11 +488,9 @@ namespace dtl {
/** /**
* compose ses from stream * compose ses from stream
*/ */
template <typename stream> template <typename stream> static Ses<elem> composeSesFromStream(stream &st) {
static Ses< elem > composeSesFromStream (stream& st)
{
elem line; elem line;
Ses< elem > ret; Ses<elem> ret;
long long x_idx, y_idx; long long x_idx, y_idx;
x_idx = y_idx = 1; x_idx = y_idx = 1;
while (getline(st, line)) { while (getline(st, line)) {
@ -540,11 +511,11 @@ namespace dtl {
return ret; return ret;
} }
private : private:
/** /**
* initialize * initialize
*/ */
void init () { void init() {
M = distance(A.begin(), A.end()); M = distance(A.begin(), A.end());
N = distance(B.begin(), B.end()); N = distance(B.begin(), B.end());
if (M < N) { if (M < N) {
@ -568,18 +539,25 @@ namespace dtl {
/** /**
* search shortest path and record the path * search shortest path and record the path
*/ */
long long snake(const long long& k, const long long& above, const long long& below) { long long snake(const long long &k, const long long &above,
long long r = above > below ? path[(size_t)k-1+offset] : path[(size_t)k+1+offset]; 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 y = max(above, below);
long long x = y - k; 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]))) { while ((size_t)x < M && (size_t)y < N &&
++x;++y; (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<long long>(pathCordinates.size()); path[(size_t)k + offset] = static_cast<long long>(pathCordinates.size());
if (!editDistanceOnly) { if (!editDistanceOnly) {
P p; P p;
p.x = x;p.y = y;p.k = r; p.x = x;
p.y = y;
p.k = r;
pathCordinates.push_back(p); pathCordinates.push_back(p);
} }
return y; return y;
@ -588,7 +566,7 @@ namespace dtl {
/** /**
* record SES and LCS * record SES and LCS
*/ */
bool recordSequence (const editPathCordinates& v) { bool recordSequence(const editPathCordinates &v) {
sequence_const_iter x(A.begin()); sequence_const_iter x(A.begin());
sequence_const_iter y(B.begin()); sequence_const_iter y(B.begin());
long long x_idx, y_idx; // line number for Unified Format long long x_idx, y_idx; // line number for Unified Format
@ -596,8 +574,8 @@ namespace dtl {
bool complete = false; bool complete = false;
x_idx = y_idx = 1; x_idx = y_idx = 1;
px_idx = py_idx = 0; px_idx = py_idx = 0;
for (size_t i=v.size()-1;!complete;--i) { for (size_t i = v.size() - 1; !complete; --i) {
while(px_idx < v[i].x || py_idx < v[i].y) { while (px_idx < v[i].x || py_idx < v[i].y) {
if (v[i].y - v[i].x > py_idx - px_idx) { if (v[i].y - v[i].x > py_idx - px_idx) {
if (!wasSwapped()) { if (!wasSwapped()) {
ses.addSequence(*y, 0, y_idx + oy, SES_ADD); ses.addSequence(*y, 0, y_idx + oy, SES_ADD);
@ -632,10 +610,12 @@ namespace dtl {
++py_idx; ++py_idx;
} }
} }
if (i == 0) complete = true; if (i == 0)
complete = true;
} }
if (x_idx > static_cast<long long>(M) && y_idx > static_cast<long long>(N)) { if (x_idx > static_cast<long long>(M) &&
y_idx > static_cast<long long>(N)) {
// all recording succeeded // all recording succeeded
} else { } else {
// trivial difference // trivial difference
@ -673,8 +653,9 @@ namespace dtl {
/** /**
* record odd sequence in SES * record odd sequence in SES
*/ */
void inline recordOddSequence (long long idx, long long length, sequence_const_iter it, const edit_t et) { void inline recordOddSequence(long long idx, long long length,
while(idx < length){ sequence_const_iter it, const edit_t et) {
while (idx < length) {
ses.addSequence(*it, idx, 0, et); ses.addSequence(*it, idx, 0, et);
++it; ++it;
++idx; ++idx;
@ -687,9 +668,9 @@ namespace dtl {
/** /**
* join SES vectors * join SES vectors
*/ */
void inline joinSesVec (sesElemVec& s1, sesElemVec& s2) const { void inline joinSesVec(sesElemVec &s1, sesElemVec &s2) const {
if (!s2.empty()) { if (!s2.empty()) {
for (sesElemVec_iter vit=s2.begin();vit!=s2.end();++vit) { for (sesElemVec_iter vit = s2.begin(); vit != s2.end(); ++vit) {
s1.push_back(*vit); s1.push_back(*vit);
} }
} }
@ -698,11 +679,8 @@ namespace dtl {
/** /**
* check if the sequences have been swapped * check if the sequences have been swapped
*/ */
bool inline wasSwapped () const { bool inline wasSwapped() const { return swapped; }
return swapped; };
} } // namespace dtl
};
}
#endif // DTL_DIFF_H #endif // DTL_DIFF_H

96
dtl/Diff3.hpp
View File

@ -6,8 +6,8 @@
Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com> Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com>
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without
are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. this list of conditions and the following disclaimer.
@ -40,47 +40,40 @@
namespace dtl { namespace dtl {
/** /**
* diff3 class template * diff3 class template
* sequence must support random_access_iterator. * sequence must support random_access_iterator.
*/ */
template <typename elem, typename sequence = vector< elem >, typename comparator = Compare< elem > > template <typename elem, typename sequence = vector<elem>,
class Diff3 typename comparator = Compare<elem>>
{ class Diff3 {
private: private:
dtl_typedefs(elem, sequence) dtl_typedefs(elem, sequence) sequence A;
sequence A;
sequence B; sequence B;
sequence C; sequence C;
sequence S; sequence S;
Diff< elem, sequence, comparator > diff_ba; Diff<elem, sequence, comparator> diff_ba;
Diff< elem, sequence, comparator > diff_bc; Diff<elem, sequence, comparator> diff_bc;
bool conflict; bool conflict;
elem csepabegin; elem csepabegin;
elem csepa; elem csepa;
elem csepaend; 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 () {} 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) {}
bool isConflict () const { ~Diff3() {}
return conflict;
}
sequence getMergedSequence () const { bool isConflict() const { return conflict; }
return S;
} sequence getMergedSequence() const { return S; }
/** /**
* merge changes B and C into A * merge changes B and C into A
*/ */
bool merge () { bool merge() {
if (diff_ba.getEditDistance() == 0) { // A == B if (diff_ba.getEditDistance() == 0) { // A == B
if (diff_bc.getEditDistance() == 0) { // A == B == C if (diff_bc.getEditDistance() == 0) { // A == B == C
S = B; S = B;
@ -105,19 +98,19 @@ namespace dtl {
/** /**
* compose differences * compose differences
*/ */
void compose () { void compose() {
diff_ba.compose(); diff_ba.compose();
diff_bc.compose(); diff_bc.compose();
} }
private : private:
/** /**
* merge implementation * merge implementation
*/ */
sequence merge_ () { sequence merge_() {
elemVec seq; elemVec seq;
Ses< elem > ses_ba = diff_ba.getSes(); Ses<elem> ses_ba = diff_ba.getSes();
Ses< elem > ses_bc = diff_bc.getSes(); Ses<elem> ses_bc = diff_bc.getSes();
sesElemVec ses_ba_v = ses_ba.getSequence(); sesElemVec ses_ba_v = ses_ba.getSequence();
sesElemVec ses_bc_v = ses_bc.getSequence(); sesElemVec ses_bc_v = ses_bc.getSequence();
sesElemVec_iter ba_it = ses_ba_v.begin(); sesElemVec_iter ba_it = ses_ba_v.begin();
@ -127,23 +120,24 @@ namespace dtl {
while (!isEnd(ba_end, ba_it) || !isEnd(bc_end, bc_it)) { while (!isEnd(ba_end, ba_it) || !isEnd(bc_end, bc_it)) {
while (true) { while (true) {
if (!isEnd(ba_end, ba_it) && if (!isEnd(ba_end, ba_it) && !isEnd(bc_end, bc_it) &&
!isEnd(bc_end, bc_it) && ba_it->first == bc_it->first && ba_it->second.type == SES_COMMON &&
ba_it->first == bc_it->first &&
ba_it->second.type == SES_COMMON &&
bc_it->second.type == SES_COMMON) { bc_it->second.type == SES_COMMON) {
// do nothing // do nothing
} else { } else {
break; break;
} }
if (!isEnd(ba_end, ba_it)) seq.push_back(ba_it->first); if (!isEnd(ba_end, ba_it))
else if (!isEnd(bc_end, bc_it)) seq.push_back(bc_it->first); 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(ba_end, ba_it);
forwardUntilEnd(bc_end, bc_it); forwardUntilEnd(bc_end, bc_it);
} }
if (isEnd(ba_end, ba_it) || isEnd(bc_end, bc_it)) break; if (isEnd(ba_end, ba_it) || isEnd(bc_end, bc_it))
if ( ba_it->second.type == SES_COMMON break;
&& bc_it->second.type == SES_DELETE) { if (ba_it->second.type == SES_COMMON &&
bc_it->second.type == SES_DELETE) {
forwardUntilEnd(ba_end, ba_it); forwardUntilEnd(ba_end, ba_it);
forwardUntilEnd(bc_end, bc_it); forwardUntilEnd(bc_end, bc_it);
} else if (ba_it->second.type == SES_COMMON && } else if (ba_it->second.type == SES_COMMON &&
@ -205,9 +199,9 @@ namespace dtl {
/** /**
* join elem vectors * join elem vectors
*/ */
void inline joinElemVec (elemVec& s1, elemVec& s2) const { void inline joinElemVec(elemVec &s1, elemVec &s2) const {
if (!s2.empty()) { if (!s2.empty()) {
for (elemVec_iter vit=s2.begin();vit!=s2.end();++vit) { for (elemVec_iter vit = s2.begin(); vit != s2.end(); ++vit) {
s1.push_back(*vit); s1.push_back(*vit);
} }
} }
@ -217,7 +211,7 @@ namespace dtl {
* check if sequence is at end * check if sequence is at end
*/ */
template <typename T_iter> template <typename T_iter>
bool inline isEnd (const T_iter& end, const T_iter& it) const { bool inline isEnd(const T_iter &end, const T_iter &it) const {
return it == end ? true : false; return it == end ? true : false;
} }
@ -225,21 +219,23 @@ namespace dtl {
* increment iterator until iterator is at end * increment iterator until iterator is at end
*/ */
template <typename T_iter> template <typename T_iter>
void inline forwardUntilEnd (const T_iter& end, T_iter& it) const { void inline forwardUntilEnd(const T_iter &end, T_iter &it) const {
if (!isEnd(end, it)) ++it; if (!isEnd(end, it))
++it;
} }
/** /**
* add elements whose SES's type is ADD * add elements whose SES's type is ADD
*/ */
void inline addDecentSequence (const sesElemVec_iter& end, sesElemVec_iter& it, elemVec& seq) const { void inline addDecentSequence(const sesElemVec_iter &end, sesElemVec_iter &it,
elemVec &seq) const {
while (!isEnd(end, it)) { while (!isEnd(end, it)) {
if (it->second.type == SES_ADD) seq.push_back(it->first); if (it->second.type == SES_ADD)
seq.push_back(it->first);
++it; ++it;
} }
} }
};
}; } // namespace dtl
}
#endif // DTL_DIFF3_H #endif // DTL_DIFF3_H

20
dtl/Lcs.hpp
View File

@ -6,8 +6,8 @@
Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com> Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com>
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without
are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. this list of conditions and the following disclaimer.
@ -40,16 +40,14 @@
namespace dtl { namespace dtl {
/** /**
* Longest Common Subsequence template class * Longest Common Subsequence template class
*/ */
template <typename elem> template <typename elem> class Lcs : public Sequence<elem> {
class Lcs : public Sequence< elem > public:
{ Lcs() {}
public : ~Lcs() {}
Lcs () {} };
~Lcs () {} } // namespace dtl
};
}
#endif // DTL_LCS_H #endif // DTL_LCS_H

33
dtl/Sequence.hpp
View File

@ -6,8 +6,8 @@
Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com> Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com>
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without
are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. this list of conditions and the following disclaimer.
@ -40,26 +40,21 @@
namespace dtl { namespace dtl {
/** /**
* sequence class template * sequence class template
*/ */
template <typename elem> template <typename elem> class Sequence {
class Sequence public:
{ typedef vector<elem> elemVec;
public : Sequence() {}
typedef vector< elem > elemVec; virtual ~Sequence() {}
Sequence () {}
virtual ~Sequence () {}
elemVec getSequence () const { elemVec getSequence() const { return sequence; }
return sequence; void addSequence(elem e) { sequence.push_back(e); }
}
void addSequence (elem e) { protected:
sequence.push_back(e);
}
protected :
elemVec sequence; elemVec sequence;
}; };
} } // namespace dtl
#endif // DTL_SEQUENCE_H #endif // DTL_SEQUENCE_H

59
dtl/Ses.hpp
View File

@ -6,8 +6,8 @@
Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com> Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com>
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without
are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. this list of conditions and the following disclaimer.
@ -40,47 +40,39 @@
namespace dtl { namespace dtl {
/** /**
* Shortest Edit Script template class * Shortest Edit Script template class
*/ */
template <typename elem> template <typename elem> class Ses : public Sequence<elem> {
class Ses : public Sequence< elem > private:
{ typedef pair<elem, elemInfo> sesElem;
private : typedef vector<sesElem> sesElemVec;
typedef pair< elem, elemInfo > sesElem;
typedef vector< sesElem > sesElemVec;
public :
Ses () : onlyAdd(true), onlyDelete(true), onlyCopy(true), deletesFirst(false) { public:
Ses() : onlyAdd(true), onlyDelete(true), onlyCopy(true), deletesFirst(false) {
nextDeleteIdx = 0; nextDeleteIdx = 0;
} }
Ses (bool moveDel) : onlyAdd(true), onlyDelete(true), onlyCopy(true), deletesFirst(moveDel) { Ses(bool moveDel)
: onlyAdd(true), onlyDelete(true), onlyCopy(true), deletesFirst(moveDel) {
nextDeleteIdx = 0; nextDeleteIdx = 0;
} }
~Ses () {} ~Ses() {}
bool isOnlyAdd () const { bool isOnlyAdd() const { return onlyAdd; }
return onlyAdd;
}
bool isOnlyDelete () const { bool isOnlyDelete() const { return onlyDelete; }
return onlyDelete;
}
bool isOnlyCopy () const { bool isOnlyCopy() const { return onlyCopy; }
return onlyCopy;
}
bool isOnlyOneOperation () const { bool isOnlyOneOperation() const {
return isOnlyAdd() || isOnlyDelete() || isOnlyCopy(); return isOnlyAdd() || isOnlyDelete() || isOnlyCopy();
} }
bool isChange () const { bool isChange() const { return !onlyCopy; }
return !onlyCopy;
}
using Sequence< elem >::addSequence; using Sequence<elem>::addSequence;
void addSequence (elem e, long long beforeIdx, long long afterIdx, const edit_t type) { void addSequence(elem e, long long beforeIdx, long long afterIdx,
const edit_t type) {
elemInfo info; elemInfo info;
info.beforeIdx = beforeIdx; info.beforeIdx = beforeIdx;
info.afterIdx = afterIdx; info.afterIdx = afterIdx;
@ -116,17 +108,16 @@ namespace dtl {
} }
} }
sesElemVec getSequence () const { sesElemVec getSequence() const { return sequence; }
return sequence;
} private:
private :
sesElemVec sequence; sesElemVec sequence;
bool onlyAdd; bool onlyAdd;
bool onlyDelete; bool onlyDelete;
bool onlyCopy; bool onlyCopy;
bool deletesFirst; bool deletesFirst;
size_t nextDeleteIdx; size_t nextDeleteIdx;
}; };
} } // namespace dtl
#endif // DTL_SES_H #endif // DTL_SES_H

14
dtl/dtl.hpp
View File

@ -6,8 +6,8 @@
Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com> Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com>
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without
are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. this list of conditions and the following disclaimer.
@ -36,12 +36,12 @@
#ifndef DTL_H #ifndef DTL_H
#define DTL_H #define DTL_H
#include "variables.hpp"
#include "functors.hpp"
#include "Sequence.hpp"
#include "Lcs.hpp"
#include "Ses.hpp"
#include "Diff.hpp" #include "Diff.hpp"
#include "Diff3.hpp" #include "Diff3.hpp"
#include "Lcs.hpp"
#include "Sequence.hpp"
#include "Ses.hpp"
#include "functors.hpp"
#include "variables.hpp"
#endif // DTL_H #endif // DTL_H

137
dtl/functors.hpp
View File

@ -6,8 +6,8 @@
Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com> Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com>
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without
are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. this list of conditions and the following disclaimer.
@ -40,47 +40,44 @@
namespace dtl { namespace dtl {
/** /**
* printer class template * printer class template
*/ */
template <typename sesElem, typename stream = ostream > template <typename sesElem, typename stream = ostream> class Printer {
class Printer public:
{ Printer() : out_(cout) {}
public : Printer(stream &out) : out_(out) {}
Printer () : out_(cout) {} virtual ~Printer() {}
Printer (stream& out) : out_(out) {} virtual void operator()(const sesElem &se) const = 0;
virtual ~Printer () {}
virtual void operator() (const sesElem& se) const = 0;
protected :
stream& out_;
};
/** protected:
stream &out_;
};
/**
* common element printer class template * common element printer class template
*/ */
template <typename sesElem, typename stream = ostream > template <typename sesElem, typename stream = ostream>
class CommonPrinter : public Printer < sesElem, stream > class CommonPrinter : public Printer<sesElem, stream> {
{ public:
public : CommonPrinter() : Printer<sesElem, stream>() {}
CommonPrinter () : Printer < sesElem, stream > () {} CommonPrinter(stream &out) : Printer<sesElem, stream>(out) {}
CommonPrinter (stream& out) : Printer < sesElem, stream > (out) {} ~CommonPrinter() {}
~CommonPrinter () {} void operator()(const sesElem &se) const {
void operator() (const sesElem& se) const {
this->out_ << SES_MARK_COMMON << se.first << endl; this->out_ << SES_MARK_COMMON << se.first << endl;
} }
}; };
/** /**
* ses element printer class template * ses element printer class template
*/ */
template <typename sesElem, typename stream = ostream > template <typename sesElem, typename stream = ostream>
class ChangePrinter : public Printer < sesElem, stream > class ChangePrinter : public Printer<sesElem, stream> {
{ public:
public : ChangePrinter() : Printer<sesElem, stream>() {}
ChangePrinter () : Printer < sesElem, stream > () {} ChangePrinter(stream &out) : Printer<sesElem, stream>(out) {}
ChangePrinter (stream& out) : Printer < sesElem, stream > (out) {} ~ChangePrinter() {}
~ChangePrinter () {} void operator()(const sesElem &se) const {
void operator() (const sesElem& se) const {
switch (se.second.type) { switch (se.second.type) {
case SES_ADD: case SES_ADD:
this->out_ << SES_MARK_ADD << se.first << endl; this->out_ << SES_MARK_ADD << se.first << endl;
@ -93,59 +90,57 @@ namespace dtl {
break; break;
} }
} }
}; };
/** /**
* unified format element printer class template * unified format element printer class template
*/ */
template <typename sesElem, typename stream = ostream > template <typename sesElem, typename stream = ostream> class UniHunkPrinter {
class UniHunkPrinter public:
{ UniHunkPrinter() : out_(cout) {}
public : UniHunkPrinter(stream &out) : out_(out) {}
UniHunkPrinter () : out_(cout) {} ~UniHunkPrinter() {}
UniHunkPrinter (stream& out) : out_(out) {} void operator()(const uniHunk<sesElem> &hunk) const {
~UniHunkPrinter () {}
void operator() (const uniHunk< sesElem >& hunk) const {
out_ << "@@" out_ << "@@"
<< " -" << hunk.a << "," << hunk.b << " -" << hunk.a << "," << hunk.b << " +" << hunk.c << "," << hunk.d
<< " +" << hunk.c << "," << hunk.d
<< " @@" << endl; << " @@" << endl;
for_each(hunk.common[0].begin(), hunk.common[0].end(), CommonPrinter< sesElem, stream >(out_)); for_each(hunk.common[0].begin(), hunk.common[0].end(),
for_each(hunk.change.begin(), hunk.change.end(), ChangePrinter< sesElem, stream >(out_)); CommonPrinter<sesElem, stream>(out_));
for_each(hunk.common[1].begin(), hunk.common[1].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_;
};
/** private:
stream &out_;
};
/**
* storage class template * storage class template
*/ */
template <typename sesElem, typename storedData > template <typename sesElem, typename storedData> class Storage {
class Storage public:
{ Storage(storedData &sd) : storedData_(sd) {}
public:
Storage(storedData& sd) : storedData_(sd) {}
virtual ~Storage() {} virtual ~Storage() {}
virtual void operator() (const sesElem& se) const = 0; virtual void operator()(const sesElem &se) const = 0;
protected:
storedData& storedData_;
};
/** protected:
storedData &storedData_;
};
/**
* compare class template * compare class template
*/ */
template <typename elem> template <typename elem> class Compare {
class Compare public:
{ Compare() {}
public : virtual ~Compare() {}
Compare () {} virtual inline bool impl(const elem &e1, const elem &e2) const {
virtual ~Compare () {}
virtual inline bool impl (const elem& e1, const elem& e2) const {
return e1 == e2; return e1 == e2;
} }
}; };
} } // namespace dtl
#endif // DTL_FUNCTORS_H #endif // DTL_FUNCTORS_H

105
dtl/variables.hpp
View File

@ -6,8 +6,8 @@
Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com> Copyright (c) 2015 Tatsuhiko Kubo <cubicdaiya@gmail.com>
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without
are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. this list of conditions and the following disclaimer.
@ -38,97 +38,97 @@
#ifndef DTL_VARIABLES_H #ifndef DTL_VARIABLES_H
#define DTL_VARIABLES_H #define DTL_VARIABLES_H
#include <vector>
#include <list>
#include <string>
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include <list>
#include <string>
#include <vector>
namespace dtl { namespace dtl {
using std::vector; using std::cout;
using std::string; using std::distance;
using std::pair; using std::endl;
using std::ostream; using std::fill;
using std::list; using std::for_each;
using std::for_each; using std::list;
using std::distance; using std::max;
using std::fill; using std::ostream;
using std::cout; using std::pair;
using std::endl; using std::rotate;
using std::rotate; using std::string;
using std::swap; using std::swap;
using std::max; using std::vector;
/** /**
* version string * version string
*/ */
const string version = "1.20"; const string version = "1.21";
/** /**
* type of edit for SES * type of edit for SES
*/ */
typedef int edit_t; typedef int edit_t;
const edit_t SES_DELETE = -1; const edit_t SES_DELETE = -1;
const edit_t SES_COMMON = 0; const edit_t SES_COMMON = 0;
const edit_t SES_ADD = 1; const edit_t SES_ADD = 1;
/** /**
* mark of SES * mark of SES
*/ */
#define SES_MARK_DELETE "-" #define SES_MARK_DELETE "-"
#define SES_MARK_COMMON " " #define SES_MARK_COMMON " "
#define SES_MARK_ADD "+" #define SES_MARK_ADD "+"
/** /**
* info for Unified Format * info for Unified Format
*/ */
typedef struct eleminfo { typedef struct eleminfo {
long long beforeIdx; // index of prev sequence long long beforeIdx; // index of prev sequence
long long afterIdx; // index of after sequence long long afterIdx; // index of after sequence
edit_t type; // type of edit(Add, Delete, Common) edit_t type; // type of edit(Add, Delete, Common)
bool operator==(const eleminfo& other) const{ bool operator==(const eleminfo &other) const {
return (this->beforeIdx == other.beforeIdx && this->afterIdx == other.afterIdx && this->type == other.type); return (this->beforeIdx == other.beforeIdx &&
this->afterIdx == other.afterIdx && this->type == other.type);
} }
} elemInfo; } elemInfo;
const long long DTL_SEPARATE_SIZE = 3; const long long DTL_SEPARATE_SIZE = 3;
const long long DTL_CONTEXT_SIZE = 3; const long long DTL_CONTEXT_SIZE = 3;
/** /**
* cordinate for registering route * cordinate for registering route
*/ */
typedef struct Point { typedef struct Point {
long long x; // x cordinate long long x; // x cordinate
long long y; // y cordinate long long y; // y cordinate
long long k; // vertex long long k; // vertex
} P; } P;
/** /**
* limit of cordinate size * limit of cordinate size
*/ */
const unsigned long long MAX_CORDINATES_SIZE = 2000000; const unsigned long long MAX_CORDINATES_SIZE = 2000000;
typedef vector< long long > editPath; typedef vector<long long> editPath;
typedef vector< P > editPathCordinates; typedef vector<P> editPathCordinates;
/** /**
* Structure of Unified Format Hunk * Structure of Unified Format Hunk
*/ */
template <typename sesElem> template <typename sesElem> struct uniHunk {
struct uniHunk {
long long a, b, c, d; // @@ -a,b +c,d @@ long long a, b, c, d; // @@ -a,b +c,d @@
vector< sesElem > common[2]; // anteroposterior commons on changes vector<sesElem> common[2]; // anteroposterior commons on changes
vector< sesElem > change; // changes vector<sesElem> change; // changes
long long inc_dec_count; // count of increace and decrease long long inc_dec_count; // count of increace and decrease
}; };
#define dtl_typedefs(elem, sequence) \ #define dtl_typedefs(elem, sequence) \
typedef pair< elem, elemInfo > sesElem; \ typedef pair<elem, elemInfo> sesElem; \
typedef vector< sesElem > sesElemVec; \ typedef vector<sesElem> sesElemVec; \
typedef vector< uniHunk< sesElem > > uniHunkVec; \ typedef vector<uniHunk<sesElem>> uniHunkVec; \
typedef list< elem > elemList; \ typedef list<elem> elemList; \
typedef vector< elem > elemVec; \ typedef vector<elem> elemVec; \
typedef typename uniHunkVec::iterator uniHunkVec_iter; \ typedef typename uniHunkVec::iterator uniHunkVec_iter; \
typedef typename sesElemVec::iterator sesElemVec_iter; \ typedef typename sesElemVec::iterator sesElemVec_iter; \
typedef typename elemList::iterator elemList_iter; \ typedef typename elemList::iterator elemList_iter; \
@ -136,7 +136,6 @@ namespace dtl {
typedef typename sequence::const_iterator sequence_const_iter; \ typedef typename sequence::const_iterator sequence_const_iter; \
typedef typename elemVec::iterator elemVec_iter; typedef typename elemVec::iterator elemVec_iter;
} // namespace dtl
}
#endif // DTL_VARIABLES_H #endif // DTL_VARIABLES_H

26
examples/bdiff.cpp
View File

@ -1,14 +1,14 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <dtl/dtl.hpp>
#include <iostream>
#include <vector>
#include <string>
#include <cstdio> #include <cstdio>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <iostream>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <vector>
#ifdef HAVE_UNISTD_H #ifdef HAVE_UNISTD_H
#include <unistd.h> #include <unistd.h>
#endif // HAVE_UNISTD_H #endif // HAVE_UNISTD_H
@ -18,11 +18,10 @@ using namespace std;
using dtl::Diff; using dtl::Diff;
typedef unsigned char elem; typedef unsigned char elem;
typedef vector< elem > sequence; typedef vector<elem> sequence;
static int create_byte_seq(const char *fs, sequence& seq); static int create_byte_seq(const char *fs, sequence &seq);
static int create_byte_seq(const char *fs, sequence& seq) static int create_byte_seq(const char *fs, sequence &seq) {
{
int fd; int fd;
int siz; int siz;
elem buf[BUFSIZ]; elem buf[BUFSIZ];
@ -31,7 +30,7 @@ static int create_byte_seq(const char *fs, sequence& seq)
return -1; return -1;
} }
while ((siz = read(fd, buf, sizeof(buf))) > 0) { while ((siz = read(fd, buf, sizeof(buf))) > 0) {
for (int i=0;i<siz;++i) { for (int i = 0; i < siz; ++i) {
seq.push_back(buf[i]); seq.push_back(buf[i]);
} }
} }
@ -44,8 +43,7 @@ static int create_byte_seq(const char *fs, sequence& seq)
return 0; return 0;
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[]) {
{
if (isFewArgs(argc)) { if (isFewArgs(argc)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
@ -60,7 +58,7 @@ int main(int argc, char *argv[])
create_byte_seq(fs1.c_str(), seq1); create_byte_seq(fs1.c_str(), seq1);
create_byte_seq(fs2.c_str(), seq2); create_byte_seq(fs2.c_str(), seq2);
Diff< elem, sequence > d(seq1, seq2); Diff<elem, sequence> d(seq1, seq2);
d.compose(); d.compose();
if (d.getEditDistance() == 0) { if (d.getEditDistance() == 0) {

5
examples/common.cpp
View File

@ -1,7 +1,7 @@
#include "common.hpp" #include "common.hpp"
bool isFileExist (string& fs) { bool isFileExist(string &fs) {
FILE *fp; FILE *fp;
if ((fp = fopen(fs.c_str(), "r")) == NULL) { if ((fp = fopen(fs.c_str(), "r")) == NULL) {
return false; return false;
@ -10,11 +10,10 @@ bool isFileExist (string& fs) {
return true; return true;
} }
bool isFewArgs (int argc, int limit) { bool isFewArgs(int argc, int limit) {
bool ret = false; bool ret = false;
if (argc < limit) { if (argc < limit) {
ret = true; ret = true;
} }
return ret; return ret;
} }

6
examples/common.hpp
View File

@ -2,12 +2,12 @@
#ifndef DTL_EXAMPLE_COMMON_H #ifndef DTL_EXAMPLE_COMMON_H
#define DTL_EXAMPLE_COMMON_H #define DTL_EXAMPLE_COMMON_H
#include <string>
#include <cstdio> #include <cstdio>
#include <string>
using namespace std; using namespace std;
bool isFileExist (string& fs); bool isFileExist(string &fs);
bool isFewArgs (int argc, int limit = 3); bool isFewArgs(int argc, int limit = 3);
#endif #endif

16
examples/fpatch.cpp
View File

@ -1,17 +1,17 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <cassert>
#include <dtl/dtl.hpp>
#include <fstream>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <fstream>
#include <vector> #include <vector>
#include <cassert>
using namespace std; using namespace std;
using dtl::Diff; using dtl::Diff;
int main(int argc, char *argv[]){ int main(int argc, char *argv[]) {
if (isFewArgs(argc)) { if (isFewArgs(argc)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
@ -37,7 +37,7 @@ int main(int argc, char *argv[]){
} }
typedef string elem; typedef string elem;
typedef vector< elem > sequence; typedef vector<elem> sequence;
ifstream Aifs(A.c_str()); ifstream Aifs(A.c_str());
ifstream Bifs(B.c_str()); ifstream Bifs(B.c_str());
@ -45,14 +45,14 @@ int main(int argc, char *argv[]){
sequence ALines, BLines; sequence ALines, BLines;
ostringstream ossLine, ossInfo; ostringstream ossLine, ossInfo;
while(getline(Aifs, buf)){ while (getline(Aifs, buf)) {
ALines.push_back(buf); ALines.push_back(buf);
} }
while(getline(Bifs, buf)){ while (getline(Bifs, buf)) {
BLines.push_back(buf); BLines.push_back(buf);
} }
Diff< elem > d(ALines, BLines); Diff<elem> d(ALines, BLines);
d.compose(); d.compose();
sequence s1 = ALines; sequence s1 = ALines;

14
examples/intdiff.cpp
View File

@ -1,33 +1,33 @@
#include <dtl/dtl.hpp>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include <dtl/dtl.hpp>
using namespace std; using namespace std;
using dtl::Diff; using dtl::Diff;
int main(int, char**){ int main(int, char **) {
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 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 b[] = {3, 5, 1, 4, 5, 1, 7, 9, 6, 10};
int asiz = sizeof(a) / sizeof(int); int asiz = sizeof(a) / sizeof(int);
int bsiz = sizeof(b) / sizeof(int); int bsiz = sizeof(b) / sizeof(int);
for (int i=0;i<asiz;++i) { for (int i = 0; i < asiz; ++i) {
cout << a[i] << " "; cout << a[i] << " ";
} }
cout << endl; cout << endl;
for (int i=0;i<bsiz;++i) { for (int i = 0; i < bsiz; ++i) {
cout << b[i] << " "; cout << b[i] << " ";
} }
cout << endl; cout << endl;
typedef int elem; typedef int elem;
typedef vector< int > sequence; typedef vector<int> sequence;
sequence A(&a[0], &a[asiz]); sequence A(&a[0], &a[asiz]);
sequence B(&b[0], &b[bsiz]); sequence B(&b[0], &b[bsiz]);
Diff< elem > d(A, B); Diff<elem> d(A, B);
d.compose(); d.compose();
// editDistance // editDistance
@ -36,7 +36,7 @@ int main(int, char**){
// Longest Common Subsequence // Longest Common Subsequence
sequence lcs_v = d.getLcsVec(); sequence lcs_v = d.getLcsVec();
cout << "LCS: "; cout << "LCS: ";
for (sequence::iterator vit=lcs_v.begin();vit!=lcs_v.end();++vit) { for (sequence::iterator vit = lcs_v.begin(); vit != lcs_v.end(); ++vit) {
cout << *vit << " "; cout << *vit << " ";
} }
cout << endl; cout << endl;

16
examples/intdiff3.cpp
View File

@ -1,14 +1,14 @@
#include <cassert>
#include <dtl/dtl.hpp> #include <dtl/dtl.hpp>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include <cassert>
using namespace std; using namespace std;
using dtl::Diff3; using dtl::Diff3;
int main(int, char**) { int main(int, char **) {
int a[10] = {1, 2, 3, 4, 5, 6, 7, 3, 9, 10}; 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 b[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
@ -16,28 +16,28 @@ int main(int, char**) {
int answer[10] = {1, 2, 3, 9, 5, 6, 7, 3, 9, 10}; int answer[10] = {1, 2, 3, 9, 5, 6, 7, 3, 9, 10};
cout << "a:"; cout << "a:";
for (int i=0;i<10;++i) { for (int i = 0; i < 10; ++i) {
cout << a[i] << " "; cout << a[i] << " ";
} }
cout << endl; cout << endl;
cout << "b:"; cout << "b:";
for (int i=0;i<10;++i) { for (int i = 0; i < 10; ++i) {
cout << b[i] << " "; cout << b[i] << " ";
} }
cout << endl; cout << endl;
cout << "c:"; cout << "c:";
for (int i=0;i<10;++i) { for (int i = 0; i < 10; ++i) {
cout << c[i] << " "; cout << c[i] << " ";
} }
cout << endl; cout << endl;
typedef int elem; typedef int elem;
typedef vector< int > sequence; typedef vector<int> sequence;
sequence A(&a[0], &a[10]); sequence A(&a[0], &a[10]);
sequence B(&b[0], &b[10]); sequence B(&b[0], &b[10]);
sequence C(&c[0], &c[10]); sequence C(&c[0], &c[10]);
sequence Answer(&answer[0], &answer[10]); sequence Answer(&answer[0], &answer[10]);
Diff3< elem > diff3(A, B, C); Diff3<elem> diff3(A, B, C);
diff3.compose(); diff3.compose();
if (!diff3.merge()) { if (!diff3.merge()) {
cerr << "conflict." << endl; cerr << "conflict." << endl;
@ -45,7 +45,7 @@ int main(int, char**) {
} }
sequence s = diff3.getMergedSequence(); sequence s = diff3.getMergedSequence();
cout << "s:"; cout << "s:";
for (sequence::iterator it=s.begin();it!=s.end();++it) { for (sequence::iterator it = s.begin(); it != s.end(); ++it) {
cout << *it << " "; cout << *it << " ";
} }
cout << endl; cout << endl;

6
examples/patch.cpp
View File

@ -1,9 +1,9 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <cassert>
#include <dtl/dtl.hpp>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include <cassert>
using namespace std; using namespace std;
@ -22,7 +22,7 @@ int main(int argc, char *argv[]) {
sequence A(argv[1]); sequence A(argv[1]);
sequence B(argv[2]); sequence B(argv[2]);
Diff< elem, sequence > d(A, B); Diff<elem, sequence> d(A, B);
d.compose(); d.compose();
sequence s1(A); sequence s1(A);

15
examples/printers.hpp
View File

@ -3,14 +3,13 @@
#include <dtl/dtl.hpp> #include <dtl/dtl.hpp>
template <typename sesElem, typename stream = ostream > template <typename sesElem, typename stream = ostream>
class customChangePrinter : public dtl::Printer < sesElem, stream > class customChangePrinter : public dtl::Printer<sesElem, stream> {
{ public:
public : customChangePrinter() : dtl::Printer<sesElem, stream>() {}
customChangePrinter () : dtl::Printer < sesElem, stream > () {} customChangePrinter(stream &out) : dtl::Printer<sesElem, stream>(out) {}
customChangePrinter (stream& out) : dtl::Printer < sesElem, stream > (out) {} ~customChangePrinter() {}
~customChangePrinter () {} void operator()(const sesElem &se) const {
void operator() (const sesElem& se) const {
switch (se.second.type) { switch (se.second.type) {
case dtl::SES_ADD: case dtl::SES_ADD:
this->out_ << "Add: " << se.first << std::endl; this->out_ << "Add: " << se.first << std::endl;

15
examples/st2ses.cpp
View File

@ -1,16 +1,16 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <iostream> #include <dtl/dtl.hpp>
#include <fstream> #include <fstream>
#include <iostream>
#include <sstream> #include <sstream>
#include <vector>
#include <string> #include <string>
#include <vector>
using namespace std; using namespace std;
using namespace dtl; using namespace dtl;
int main(int argc, char *argv[]){ int main(int argc, char *argv[]) {
if (isFewArgs(argc, 2)) { if (isFewArgs(argc, 2)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
@ -18,7 +18,7 @@ int main(int argc, char *argv[]){
} }
typedef string elem; typedef string elem;
typedef vector< string > sequence; typedef vector<string> sequence;
string s(argv[1]); string s(argv[1]);
@ -28,8 +28,9 @@ int main(int argc, char *argv[]){
} }
ifstream fs(s.c_str()); ifstream fs(s.c_str());
const Ses< elem > ses = Diff< elem, sequence >::composeSesFromStream< ifstream >(fs); const Ses<elem> ses =
dtl::Diff< elem, sequence >::printSES(ses); Diff<elem, sequence>::composeSesFromStream<ifstream>(fs);
dtl::Diff<elem, sequence>::printSES(ses);
return 0; return 0;
} }

11
examples/storage.hpp
View File

@ -3,13 +3,12 @@
#include <dtl/dtl.hpp> #include <dtl/dtl.hpp>
template <typename sesElem, typename storedData > template <typename sesElem, typename storedData>
class CustomStorage : public dtl::Storage < sesElem, storedData > class CustomStorage : public dtl::Storage<sesElem, storedData> {
{ public:
public : CustomStorage(storedData &sd) : dtl::Storage<sesElem, storedData>(sd) {}
CustomStorage(storedData& sd) : dtl::Storage < sesElem, storedData > (sd) {}
~CustomStorage() {} ~CustomStorage() {}
void operator() (const sesElem& se) const { void operator()(const sesElem &se) const {
switch (se.second.type) { switch (se.second.type) {
case dtl::SES_ADD: case dtl::SES_ADD:
this->storedData_ = this->storedData_ + "Add: " + se.first + "\n"; this->storedData_ = this->storedData_ + "Add: " + se.first + "\n";

12
examples/strdiff.cpp
View File

@ -1,15 +1,15 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <dtl/dtl.hpp>
#include <iostream> #include <iostream>
#include <vector>
#include <string> #include <string>
#include <vector>
using namespace std; using namespace std;
using dtl::Diff; using dtl::Diff;
int main(int argc, char *argv[]){ int main(int argc, char *argv[]) {
if (isFewArgs(argc)) { if (isFewArgs(argc)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
@ -22,15 +22,15 @@ int main(int argc, char *argv[]){
sequence A(argv[1]); sequence A(argv[1]);
sequence B(argv[2]); sequence B(argv[2]);
Diff< elem, sequence > d(A, B); Diff<elem, sequence> d(A, B);
//d.onOnlyEditDistance(); // d.onOnlyEditDistance();
d.compose(); d.compose();
// editDistance // editDistance
cout << "editDistance:" << d.getEditDistance() << endl; cout << "editDistance:" << d.getEditDistance() << endl;
// Longest Common Subsequence // Longest Common Subsequence
vector< elem > lcs_v = d.getLcsVec(); vector<elem> lcs_v = d.getLcsVec();
sequence lcs_s(lcs_v.begin(), lcs_v.end()); sequence lcs_s(lcs_v.begin(), lcs_v.end());
cout << "LCS:" << lcs_s << endl; cout << "LCS:" << lcs_s << endl;

8
examples/strdiff3.cpp
View File

@ -1,15 +1,15 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <dtl/dtl.hpp>
#include <iostream> #include <iostream>
#include <vector>
#include <string> #include <string>
#include <vector>
using namespace std; using namespace std;
using dtl::Diff3; using dtl::Diff3;
int main(int argc, char *argv[]){ int main(int argc, char *argv[]) {
if (isFewArgs(argc, 4)) { if (isFewArgs(argc, 4)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
@ -23,7 +23,7 @@ int main(int argc, char *argv[]){
sequence B(argv[2]); sequence B(argv[2]);
sequence C(argv[3]); sequence C(argv[3]);
Diff3< elem, sequence > diff3(A, B, C); Diff3<elem, sequence> diff3(A, B, C);
diff3.compose(); diff3.compose();
if (!diff3.merge()) { if (!diff3.merge()) {
cerr << "conflict." << endl; cerr << "conflict." << endl;

8
examples/strdiff_cp.cpp
View File

@ -1,5 +1,5 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <dtl/dtl.hpp>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <string> #include <string>
@ -10,7 +10,7 @@ using namespace std;
using dtl::Diff; using dtl::Diff;
int main(int argc, char *argv[]){ int main(int argc, char *argv[]) {
if (isFewArgs(argc)) { if (isFewArgs(argc)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
@ -23,13 +23,13 @@ int main(int argc, char *argv[]){
sequence A(argv[1]); sequence A(argv[1]);
sequence B(argv[2]); sequence B(argv[2]);
Diff< elem, sequence > d(A, B); Diff<elem, sequence> d(A, B);
d.compose(); d.compose();
// Shortest Edit Script // Shortest Edit Script
cout << "SES" << endl; cout << "SES" << endl;
d.printSES < ostream, customChangePrinter > (cout); d.printSES<ostream, customChangePrinter>(cout);
return 0; return 0;
} }

8
examples/strdiff_storage.cpp
View File

@ -1,5 +1,5 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <dtl/dtl.hpp>
#include <iostream> #include <iostream>
#include <string> #include <string>
@ -9,7 +9,7 @@ using namespace std;
using dtl::Diff; using dtl::Diff;
int main(int argc, char *argv[]){ int main(int argc, char *argv[]) {
if (isFewArgs(argc)) { if (isFewArgs(argc)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
@ -22,7 +22,7 @@ int main(int argc, char *argv[]){
sequence A(argv[1]); sequence A(argv[1]);
sequence B(argv[2]); sequence B(argv[2]);
Diff< elem, sequence > d(A, B); Diff<elem, sequence> d(A, B);
d.compose(); d.compose();
// Shortest Edit Script // Shortest Edit Script
@ -30,7 +30,7 @@ int main(int argc, char *argv[]){
string result; string result;
d.storeSES < string, CustomStorage > (result); d.storeSES<string, CustomStorage>(result);
cout << result; cout << result;

34
examples/unidiff.cpp
View File

@ -1,13 +1,13 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <iostream> #include <dtl/dtl.hpp>
#include <fstream> #include <fstream>
#include <iostream>
#include <sstream> #include <sstream>
#include <vector> #include <vector>
#include <time.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <time.h>
using namespace std; using namespace std;
@ -15,11 +15,10 @@ using dtl::Diff;
using dtl::elemInfo; using dtl::elemInfo;
using dtl::uniHunk; using dtl::uniHunk;
static void showStats (string fp1, string fp2); static void showStats(string fp1, string fp2);
static void unifiedDiff (string fp1, string fp2); static void unifiedDiff(string fp1, string fp2);
static void showStats (string fp1, string fp2) static void showStats(string fp1, string fp2) {
{
const int MAX_LENGTH = 255; const int MAX_LENGTH = 255;
char time_format[] = "%Y-%m-%d %H:%M:%S %z"; char time_format[] = "%Y-%m-%d %H:%M:%S %z";
time_t rawtime[2]; time_t rawtime[2];
@ -46,31 +45,30 @@ static void showStats (string fp1, string fp2)
cout << "+++ " << fp2 << '\t' << buf[1] << endl; cout << "+++ " << fp2 << '\t' << buf[1] << endl;
} }
static void unifiedDiff (string fp1, string fp2) static void unifiedDiff(string fp1, string fp2) {
{
typedef string elem; typedef string elem;
typedef vector< elem > sequence; typedef vector<elem> sequence;
typedef pair< elem, elemInfo > sesElem; typedef pair<elem, elemInfo> sesElem;
ifstream Aifs(fp1.c_str()); ifstream Aifs(fp1.c_str());
ifstream Bifs(fp2.c_str()); ifstream Bifs(fp2.c_str());
elem buf; elem buf;
sequence ALines, BLines; sequence ALines, BLines;
while(getline(Aifs, buf)){ while (getline(Aifs, buf)) {
ALines.push_back(buf); ALines.push_back(buf);
} }
while(getline(Bifs, buf)){ while (getline(Bifs, buf)) {
BLines.push_back(buf); BLines.push_back(buf);
} }
Diff< elem > diff(ALines, BLines); Diff<elem> diff(ALines, BLines);
diff.onHuge(); diff.onHuge();
//diff.onUnserious(); // diff.onUnserious();
diff.compose(); diff.compose();
// type unihunk definition test // type unihunk definition test
uniHunk< sesElem > hunk; uniHunk<sesElem> hunk;
if (diff.getEditDistance() > 0) { if (diff.getEditDistance() > 0) {
showStats(fp1, fp2); // show file info showStats(fp1, fp2); // show file info
@ -80,9 +78,7 @@ static void unifiedDiff (string fp1, string fp2)
diff.printUnifiedFormat(); diff.printUnifiedFormat();
} }
int main(int argc, char *argv[]) {
int main(int argc, char *argv[])
{
if (isFewArgs(argc)) { if (isFewArgs(argc)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
return -1; return -1;

6
examples/unistrdiff.cpp
View File

@ -1,6 +1,6 @@
#include <dtl/dtl.hpp>
#include "common.hpp" #include "common.hpp"
#include <dtl/dtl.hpp>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
@ -8,7 +8,7 @@ using namespace std;
using dtl::Diff; using dtl::Diff;
int main(int argc, char *argv[]){ int main(int argc, char *argv[]) {
if (isFewArgs(argc)) { if (isFewArgs(argc)) {
cerr << "Too few arguments." << endl; cerr << "Too few arguments." << endl;
@ -21,7 +21,7 @@ int main(int argc, char *argv[]){
sequence A(argv[1]); sequence A(argv[1]);
sequence B(argv[2]); sequence B(argv[2]);
Diff<elem, sequence > d(A, B); Diff<elem, sequence> d(A, B);
d.compose(); d.compose();
d.composeUnifiedHunks(); d.composeUnifiedHunks();

39
test/Intdifftest.cpp
View File

@ -1,10 +1,8 @@
#include "dtl_test_common.hpp" #include "dtl_test_common.hpp"
class Intdifftest : public ::testing::Test class Intdifftest : public ::testing::Test {
{ protected:
protected : dtl_test_typedefs(int, vector<int>) typedef struct case_t {
dtl_test_typedefs(int, vector< int >)
typedef struct case_t {
sequence A; sequence A;
sequence B; sequence B;
size_t editdis; size_t editdis;
@ -17,13 +15,13 @@ protected :
string path_rses; string path_rses;
string path_rhunks; string path_rhunks;
} case_t; } case_t;
typedef vector< case_t > caseVec; typedef vector<case_t> caseVec;
caseVec cases; caseVec cases;
case_t createCase (const sequence a, const sequence b, string test_name) { case_t createCase(const sequence a, const sequence b, string test_name) {
case_t c; case_t c;
string diff_name("intdiff"); string diff_name("intdiff");
Diff< elem > diff(a, b); Diff<elem> diff(a, b);
diff.compose(); diff.compose();
diff.composeUnifiedHunks(); diff.composeUnifiedHunks();
@ -31,17 +29,19 @@ protected :
string path_lses = create_path(test_name, diff_name, TYPE_DIFF_SES); 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_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_lhunks = create_path(test_name, diff_name, TYPE_DIFF_UNI);
string path_rhunks = create_path(test_name, diff_name, TYPE_DIFF_UNI, true); string path_rhunks =
create_path(test_name, diff_name, TYPE_DIFF_UNI, true);
create_file< elem, sequence, Compare< elem > >(path_rses, diff, TYPE_DIFF_SES); create_file<elem, sequence, Compare<elem>>(path_rses, diff,
create_file< elem, sequence, Compare< elem > >(path_rhunks, diff, TYPE_DIFF_UNI); 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_ses = cal_diff_uni(path_lses, path_rses);
c.editdis_uni = cal_diff_uni(path_lhunks, path_rhunks); c.editdis_uni = cal_diff_uni(path_lhunks, path_rhunks);
c.path_rses = path_rses; c.path_rses = path_rses;
c.path_rhunks = path_rhunks; c.path_rhunks = path_rhunks;
} }
c.A = a; c.A = a;
c.B = b; c.B = b;
c.editdis = diff.getEditDistance(); c.editdis = diff.getEditDistance();
@ -74,10 +74,7 @@ protected :
cases.push_back(createCase(A5, B5, "diff_test4")); cases.push_back(createCase(A5, B5, "diff_test4"));
} }
void TearDown () { void TearDown() { for_each(cases.begin(), cases.end(), Remover<case_t>()); }
for_each(cases.begin(), cases.end(), Remover< case_t >());
}
}; };
/** /**
@ -87,7 +84,7 @@ protected :
* - LCS * - LCS
* - SES * - SES
*/ */
TEST_F (Intdifftest, diff_test0) { TEST_F(Intdifftest, diff_test0) {
EXPECT_EQ(0, cases[0].editdis); EXPECT_EQ(0, cases[0].editdis);
EXPECT_TRUE(cases[0].lcs_v.empty()); EXPECT_TRUE(cases[0].lcs_v.empty());
@ -97,7 +94,7 @@ TEST_F (Intdifftest, diff_test0) {
ASSERT_EQ(0, cases[0].editdis_uni); ASSERT_EQ(0, cases[0].editdis_uni);
} }
TEST_F (Intdifftest, diff_test1) { TEST_F(Intdifftest, diff_test1) {
EXPECT_EQ(1, cases[1].editdis); EXPECT_EQ(1, cases[1].editdis);
EXPECT_TRUE(cases[1].lcs_v.empty()); EXPECT_TRUE(cases[1].lcs_v.empty());
@ -107,7 +104,7 @@ TEST_F (Intdifftest, diff_test1) {
ASSERT_EQ(0, cases[1].editdis_uni); ASSERT_EQ(0, cases[1].editdis_uni);
} }
TEST_F (Intdifftest, diff_test2) { TEST_F(Intdifftest, diff_test2) {
EXPECT_EQ(1, cases[2].editdis); EXPECT_EQ(1, cases[2].editdis);
EXPECT_TRUE(cases[2].lcs_v.empty()); EXPECT_TRUE(cases[2].lcs_v.empty());
@ -117,7 +114,7 @@ TEST_F (Intdifftest, diff_test2) {
ASSERT_EQ(0, cases[2].editdis_uni); ASSERT_EQ(0, cases[2].editdis_uni);
} }
TEST_F (Intdifftest, diff_test3) { TEST_F(Intdifftest, diff_test3) {
EXPECT_EQ(8, cases[3].editdis); EXPECT_EQ(8, cases[3].editdis);
EXPECT_EQ(3, cases[3].lcs_v[0]); EXPECT_EQ(3, cases[3].lcs_v[0]);
@ -131,7 +128,7 @@ TEST_F (Intdifftest, diff_test3) {
ASSERT_EQ(0, cases[3].editdis_uni); ASSERT_EQ(0, cases[3].editdis_uni);
} }
TEST_F (Intdifftest, diff_test4) { TEST_F(Intdifftest, diff_test4) {
EXPECT_EQ(4, cases[4].editdis); EXPECT_EQ(4, cases[4].editdis);
EXPECT_EQ(3, cases[4].lcs_v[0]); EXPECT_EQ(3, cases[4].lcs_v[0]);

46
test/Objdifftest.cpp
View File

@ -1,27 +1,26 @@
#include "dtl_test_common.hpp"
#include "comparators.hpp" #include "comparators.hpp"
#include "dtl_test_common.hpp"
class Objdifftest : public ::testing::Test class Objdifftest : public ::testing::Test {
{ protected:
protected : dtl_test_typedefs(string, vector<elem>) typedef struct case_t {
dtl_test_typedefs(string, vector<elem>)
typedef struct case_t {
sequence A; sequence A;
sequence B; sequence B;
sesElemVec expected; sesElemVec expected;
sesElemVec ses_seq; sesElemVec ses_seq;
} case_t; } case_t;
typedef vector< case_t > caseVec; typedef vector<case_t> caseVec;
caseVec obj_diff_cases; caseVec obj_diff_cases;
template < typename comparator > template <typename comparator>
case_t createCase (const sequence a, const sequence b, sesElemVec ses, string test_name) { case_t createCase(const sequence a, const sequence b, sesElemVec ses,
string test_name) {
case_t c; case_t c;
elemVec lcs_v; elemVec lcs_v;
string diff_name("objdiff"); string diff_name("objdiff");
Diff< elem, sequence, comparator > diff(a, b, true); Diff<elem, sequence, comparator> diff(a, b, true);
diff.compose(); diff.compose();
@ -41,13 +40,14 @@ protected :
sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0]))); sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0])));
sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0]))); sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0])));
dtl::Ses< elem > ses; dtl::Ses<elem> ses;
ses.addSequence("the", 1, 1, dtl::SES_COMMON); ses.addSequence("the", 1, 1, dtl::SES_COMMON);
ses.addSequence("quick", 2, 2, dtl::SES_COMMON); ses.addSequence("quick", 2, 2, dtl::SES_COMMON);
ses.addSequence("brown", 3, 0, dtl::SES_DELETE); ses.addSequence("brown", 3, 0, dtl::SES_DELETE);
ses.addSequence("Fox", 0, 3, dtl::SES_ADD); ses.addSequence("Fox", 0, 3, dtl::SES_ADD);
obj_diff_cases.push_back(createCase< StringCaseInsensitive >(A, B, ses.getSequence(), "objdiff_test0_pattern")); obj_diff_cases.push_back(createCase<StringCaseInsensitive>(
A, B, ses.getSequence(), "objdiff_test0_pattern"));
} }
{ {
@ -57,7 +57,7 @@ protected :
sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0]))); sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0])));
sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0]))); sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0])));
dtl::Ses< elem > ses; dtl::Ses<elem> ses;
ses.addSequence("b", 1, 0, dtl::SES_DELETE); ses.addSequence("b", 1, 0, dtl::SES_DELETE);
ses.addSequence("c", 2, 0, dtl::SES_DELETE); ses.addSequence("c", 2, 0, dtl::SES_DELETE);
ses.addSequence("a", 0, 1, dtl::SES_ADD); ses.addSequence("a", 0, 1, dtl::SES_ADD);
@ -67,7 +67,8 @@ protected :
ses.addSequence("f", 0, 4, dtl::SES_ADD); ses.addSequence("f", 0, 4, dtl::SES_ADD);
ses.addSequence("h", 0, 5, 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")); obj_diff_cases.push_back(createCase<StringCaseInsensitive>(
A, B, ses.getSequence(), "objdiff_test1_unswapped"));
} }
{ {
string array1[] = {"a", "d", "e", "f", "h"}; string array1[] = {"a", "d", "e", "f", "h"};
@ -76,7 +77,7 @@ protected :
sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0]))); sequence A(array1, array1 + (sizeof(array1) / sizeof(array1[0])));
sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0]))); sequence B(array2, array2 + (sizeof(array2) / sizeof(array2[0])));
dtl::Ses< elem > ses; dtl::Ses<elem> ses;
ses.addSequence("a", 1, 0, dtl::SES_DELETE); ses.addSequence("a", 1, 0, dtl::SES_DELETE);
ses.addSequence("d", 2, 0, dtl::SES_DELETE); ses.addSequence("d", 2, 0, dtl::SES_DELETE);
ses.addSequence("b", 0, 1, dtl::SES_ADD); ses.addSequence("b", 0, 1, dtl::SES_ADD);
@ -86,16 +87,17 @@ protected :
ses.addSequence("h", 5, 0, dtl::SES_DELETE); ses.addSequence("h", 5, 0, dtl::SES_DELETE);
ses.addSequence("g", 0, 4, dtl::SES_ADD); ses.addSequence("g", 0, 4, dtl::SES_ADD);
obj_diff_cases.push_back(createCase< StringCaseInsensitive >(A, B, ses.getSequence(), "objdiff_test2_swapped")); obj_diff_cases.push_back(createCase<StringCaseInsensitive>(
A, B, ses.getSequence(), "objdiff_test2_swapped"));
} }
} }
void TearDown () { void TearDown() {
//for_each(obj_diff_cases.begin(), obj_diff_cases.end(), Remover< case_t >()); // for_each(obj_diff_cases.begin(), obj_diff_cases.end(), Remover< case_t
// >());
} }
}; };
/** /**
* Objdifftest * Objdifftest
* check list: * check list:
@ -103,14 +105,14 @@ protected :
* - Indepence of results from swapping * - Indepence of results from swapping
*/ */
TEST_F (Objdifftest, objdiff_test0_pattern) { TEST_F(Objdifftest, objdiff_test0_pattern) {
EXPECT_EQ(obj_diff_cases[0].expected, obj_diff_cases[0].ses_seq); EXPECT_EQ(obj_diff_cases[0].expected, obj_diff_cases[0].ses_seq);
} }
TEST_F (Objdifftest, objdiff_test1_unswapped) { TEST_F(Objdifftest, objdiff_test1_unswapped) {
EXPECT_EQ(obj_diff_cases[1].expected, obj_diff_cases[1].ses_seq); EXPECT_EQ(obj_diff_cases[1].expected, obj_diff_cases[1].ses_seq);
} }
TEST_F (Objdifftest, objdiff_test2_swapped) { TEST_F(Objdifftest, objdiff_test2_swapped) {
EXPECT_EQ(obj_diff_cases[2].expected, obj_diff_cases[2].ses_seq); EXPECT_EQ(obj_diff_cases[2].expected, obj_diff_cases[2].ses_seq);
} }

101
test/Patchtest.cpp
View File

@ -1,23 +1,21 @@
#include "dtl_test_common.hpp" #include "dtl_test_common.hpp"
class Patchtest : public ::testing::Test class Patchtest : public ::testing::Test {
{ protected:
protected : dtl_test_typedefs(char, string) typedef struct case_t {
dtl_test_typedefs(char, string)
typedef struct case_t {
sequence A; sequence A;
sequence B; sequence B;
Diff< elem, sequence > diff; Diff<elem, sequence> diff;
} case_t; } case_t;
typedef vector< case_t > caseVec; typedef vector<case_t> caseVec;
caseVec cases; caseVec cases;
case_t createCase (sequence a, sequence b) { case_t createCase(sequence a, sequence b) {
case_t c; case_t c;
c.A = a; c.A = a;
c.B = b; c.B = b;
c.diff = Diff< elem, sequence >(a, b); c.diff = Diff<elem, sequence>(a, b);
c.diff.compose(); c.diff.compose();
c.diff.composeUnifiedHunks(); c.diff.composeUnifiedHunks();
return c; return c;
@ -32,14 +30,69 @@ protected :
cases.push_back(createCase("", "")); // 5 cases.push_back(createCase("", "")); // 5
cases.push_back(createCase("a", "")); // 6 cases.push_back(createCase("a", "")); // 6
cases.push_back(createCase("", "b")); // 7 cases.push_back(createCase("", "b")); // 7
cases.push_back(createCase("abcdefq3wefarhgorequgho4euhfteowauhfwehogfewrquhoi23hroewhoahfotrhguoiewahrgqqabcdef", cases.push_back(createCase(
"abcdefq3wefarhgorequgho4euhfteowauhfwehogfewrquhoi23hroewhoahfotrhguoi"
"ewahrgqqabcdef",
"3abcdef4976fd86ouofita67t85r876e5e746578tgliuhopoqqabcdef")); // 8 "3abcdef4976fd86ouofita67t85r876e5e746578tgliuhopoqqabcdef")); // 8
cases.push_back(createCase("abcqqqeqqqccc", "abdqqqeqqqddd")); // 9 cases.push_back(createCase("abcqqqeqqqccc", "abdqqqeqqqddd")); // 9
cases.push_back(createCase("aaaaaaaaaaaaa>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>aaaadsafabcaaaaaaaaaaaaaaaaaaewaaabdaaaaaabbb", "aaaaaaaaaaaaaaadasfdsafsadasdafbaaaaaaaaaaaaaaaaaeaaaaaaaaaae&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&saaabcaaaaaaccc")); // 10 cases.push_back(createCase(
"aaaaaaaaaaaaa>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
"aaaadsafabcaaaaaaaaaaaaaaaaaaewaaabdaaaaaabbb",
"aaaaaaaaaaaaaaadasfdsafsadasdafbaaaaaaaaaaaaaaaaaeaaaaaaaaaae&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&saaabcaaaaaaccc")); // 10
} }
void TearDown () {} void TearDown() {}
}; };
/** /**
@ -48,57 +101,57 @@ protected :
* - patch function * - patch function
* - uniPatch function * - uniPatch function
*/ */
TEST_F (Patchtest, patch_test0) { 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.patch(cases[0].A));
ASSERT_EQ(cases[0].B, cases[0].diff.uniPatch(cases[0].A)); ASSERT_EQ(cases[0].B, cases[0].diff.uniPatch(cases[0].A));
} }
TEST_F (Patchtest, patch_test1) { 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.patch(cases[1].A));
ASSERT_EQ(cases[1].B, cases[1].diff.uniPatch(cases[1].A)); ASSERT_EQ(cases[1].B, cases[1].diff.uniPatch(cases[1].A));
} }
TEST_F (Patchtest, patch_test2) { 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.patch(cases[2].A));
ASSERT_EQ(cases[2].B, cases[2].diff.uniPatch(cases[2].A)); ASSERT_EQ(cases[2].B, cases[2].diff.uniPatch(cases[2].A));
} }
TEST_F (Patchtest, patch_test3) { 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.patch(cases[3].A));
ASSERT_EQ(cases[3].B, cases[3].diff.uniPatch(cases[3].A)); ASSERT_EQ(cases[3].B, cases[3].diff.uniPatch(cases[3].A));
} }
TEST_F (Patchtest, patch_test4) { 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.patch(cases[4].A));
ASSERT_EQ(cases[4].B, cases[4].diff.uniPatch(cases[4].A)); ASSERT_EQ(cases[4].B, cases[4].diff.uniPatch(cases[4].A));
} }
TEST_F (Patchtest, patch_test5) { 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.patch(cases[5].A));
ASSERT_EQ(cases[5].B, cases[5].diff.uniPatch(cases[5].A)); ASSERT_EQ(cases[5].B, cases[5].diff.uniPatch(cases[5].A));
} }
TEST_F (Patchtest, patch_test6) { 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.patch(cases[6].A));
ASSERT_EQ(cases[6].B, cases[6].diff.uniPatch(cases[6].A)); ASSERT_EQ(cases[6].B, cases[6].diff.uniPatch(cases[6].A));
} }
TEST_F (Patchtest, patch_test7) { 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.patch(cases[7].A));
ASSERT_EQ(cases[7].B, cases[7].diff.uniPatch(cases[7].A)); ASSERT_EQ(cases[7].B, cases[7].diff.uniPatch(cases[7].A));
} }
TEST_F (Patchtest, patch_test8) { 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.patch(cases[8].A));
ASSERT_EQ(cases[8].B, cases[8].diff.uniPatch(cases[8].A)); ASSERT_EQ(cases[8].B, cases[8].diff.uniPatch(cases[8].A));
} }
TEST_F (Patchtest, patch_test9) { 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.patch(cases[9].A));
ASSERT_EQ(cases[9].B, cases[9].diff.uniPatch(cases[9].A)); ASSERT_EQ(cases[9].B, cases[9].diff.uniPatch(cases[9].A));
} }
TEST_F (Patchtest, patch_test10) { 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.patch(cases[10].A));
ASSERT_EQ(cases[10].B, cases[10].diff.uniPatch(cases[10].A)); ASSERT_EQ(cases[10].B, cases[10].diff.uniPatch(cases[10].A));
} }

10
test/SConstruct
View File

@ -3,18 +3,20 @@
import os import os
def path_chomp(path): def path_chomp(path):
if path[-1] == '/': if path[-1] == '/':
return path[:-1] return path[:-1]
return path return path
env = Environment( env = Environment(
CPPFLAGS=['-Wall', '-O2'], CPPFLAGS=['-Wall', '-O2'],
CPPPATH=['..'], CPPPATH=['..'],
CXXFLAGS="-std=c++11", CXXFLAGS="-std=c++11",
) )
conf = Configure(env); conf = Configure(env)
if not conf.CheckCXX(): if not conf.CheckCXX():
print("c++ compiler is not installed!") print("c++ compiler is not installed!")
@ -33,10 +35,6 @@ test = env.Program(
[Glob('*.cpp')], [Glob('*.cpp')],
) )
test_alias = env.Alias( test_alias = env.Alias('check', test, test[0].abspath)
'check',
test,
test[0].abspath
)
env.AlwaysBuild(test_alias) env.AlwaysBuild(test_alias)

160
test/Strdiff3test.cpp
View File

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

121
test/Strdifftest.cpp
View File

@ -1,11 +1,9 @@
#include "dtl_test_common.hpp"
#include "comparators.hpp" #include "comparators.hpp"
#include "dtl_test_common.hpp"
class Strdifftest : public ::testing::Test class Strdifftest : public ::testing::Test {
{ protected:
protected : dtl_test_typedefs(char, string) typedef struct case_t {
dtl_test_typedefs(char, string)
typedef struct case_t {
sequence A; sequence A;
sequence B; sequence B;
size_t editdis; size_t editdis;
@ -18,19 +16,20 @@ protected :
string path_rses; string path_rses;
string path_rhunks; string path_rhunks;
} case_t; } case_t;
typedef vector< case_t > caseVec; typedef vector<case_t> caseVec;
caseVec diff_cases; caseVec diff_cases;
caseVec only_editdis_cases; caseVec only_editdis_cases;
caseVec custom_cases; caseVec custom_cases;
template < typename comparator > template <typename comparator>
case_t createCase (const sequence a, const sequence b, string test_name, bool onlyEditdis = false) { case_t createCase(const sequence a, const sequence b, string test_name,
bool onlyEditdis = false) {
case_t c; case_t c;
elemVec lcs_v; elemVec lcs_v;
string diff_name("strdiff"); string diff_name("strdiff");
Diff< elem, sequence, comparator > diff(a, b); Diff<elem, sequence, comparator> diff(a, b);
if (onlyEditdis) { if (onlyEditdis) {
diff.onOnlyEditDistance(); diff.onOnlyEditDistance();
} }
@ -43,12 +42,13 @@ protected :
string path_lses = create_path(test_name, diff_name, TYPE_DIFF_SES); 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_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_lhunks = create_path(test_name, diff_name, TYPE_DIFF_UNI);
string path_rhunks = create_path(test_name, diff_name, TYPE_DIFF_UNI, true); string path_rhunks =
create_path(test_name, diff_name, TYPE_DIFF_UNI, true);
diff_resultset_exist_check(path_lses); diff_resultset_exist_check(path_lses);
diff_resultset_exist_check(path_lhunks); diff_resultset_exist_check(path_lhunks);
create_file< elem, sequence, comparator >(path_rses, diff, TYPE_DIFF_SES); create_file<elem, sequence, comparator>(path_rses, diff, TYPE_DIFF_SES);
create_file< elem, sequence, comparator >(path_rhunks, diff, TYPE_DIFF_UNI); create_file<elem, sequence, comparator>(path_rhunks, diff, TYPE_DIFF_UNI);
c.editdis_ses = cal_diff_uni(path_lses, path_rses); c.editdis_ses = cal_diff_uni(path_lses, path_rses);
c.editdis_uni = cal_diff_uni(path_lhunks, path_rhunks); c.editdis_uni = cal_diff_uni(path_lhunks, path_rhunks);
@ -67,36 +67,47 @@ protected :
} }
void SetUp(void) { void SetUp(void) {
diff_cases.push_back(createCase< Compare< elem > >("abc", "abd", "diff_test0")); 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(
diff_cases.push_back(createCase< Compare< elem > >("abcdef", "dacfea", "diff_test2")); createCase<Compare<elem>>("acbdeacbed", "acebdabbabed", "diff_test1"));
diff_cases.push_back(createCase< Compare< elem > >("abcbda", "bdcaba", "diff_test3")); diff_cases.push_back(
diff_cases.push_back(createCase< Compare< elem > >("bokko", "bokkko", "diff_test4")); createCase<Compare<elem>>("abcdef", "dacfea", "diff_test2"));
diff_cases.push_back(createCase< Compare< elem > >("", "", "diff_test5")); diff_cases.push_back(
diff_cases.push_back(createCase< Compare< elem > >("a", "", "diff_test6")); createCase<Compare<elem>>("abcbda", "bdcaba", "diff_test3"));
diff_cases.push_back(createCase< Compare< elem > >("", "b", "diff_test7")); diff_cases.push_back(
diff_cases.push_back(createCase< Compare< elem > >("acbdeaqqqqqqqcbed", "acebdabbqqqqqqqabed", "diff_test8")); 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(
only_editdis_cases.push_back(createCase< Compare< elem > >("acbdeacbed", "acebdabbabed", "", true)); createCase<Compare<elem>>("abc", "abd", "", true));
only_editdis_cases.push_back(createCase< Compare< elem > >("abcdef", "dacfea", "", true)); only_editdis_cases.push_back(
only_editdis_cases.push_back(createCase< Compare< elem > >("abcbda", "bdcaba", "", true)); createCase<Compare<elem>>("acbdeacbed", "acebdabbabed", "", true));
only_editdis_cases.push_back(createCase< Compare< elem > >("bokko", "bokkko", "", true)); only_editdis_cases.push_back(
only_editdis_cases.push_back(createCase< Compare< elem > >("", "", "", true)); createCase<Compare<elem>>("abcdef", "dacfea", "", true));
only_editdis_cases.push_back(createCase< Compare< elem > >("a", "", "", true)); only_editdis_cases.push_back(
only_editdis_cases.push_back(createCase< Compare< elem > >("", "b", "", true)); createCase<Compare<elem>>("abcbda", "bdcaba", "", true));
only_editdis_cases.push_back(createCase< Compare< elem > >("acbdeaqqqqqqqcbed", "acebdabbqqqqqqqabed", "", 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")); custom_cases.push_back(
createCase<CaseInsensitive>("abc", "Abc", "custom_test0"));
} }
void TearDown () { void TearDown() {
for_each(diff_cases.begin(), diff_cases.end(), Remover< case_t >()); for_each(diff_cases.begin(), diff_cases.end(), Remover<case_t>());
for_each(custom_cases.begin(), custom_cases.end(), Remover< case_t >()); for_each(custom_cases.begin(), custom_cases.end(), Remover<case_t>());
} }
}; };
/** /**
* Strdifftest * Strdifftest
* check list is following * check list is following
@ -107,7 +118,7 @@ protected :
* - onOnlyEditDistance * - onOnlyEditDistance
*/ */
TEST_F (Strdifftest, diff_test0) { TEST_F(Strdifftest, diff_test0) {
EXPECT_EQ(2, diff_cases[0].editdis); EXPECT_EQ(2, diff_cases[0].editdis);
@ -118,7 +129,7 @@ TEST_F (Strdifftest, diff_test0) {
ASSERT_EQ(0, diff_cases[0].editdis_uni); ASSERT_EQ(0, diff_cases[0].editdis_uni);
} }
TEST_F (Strdifftest, diff_test1) { TEST_F(Strdifftest, diff_test1) {
EXPECT_EQ(6, diff_cases[1].editdis); EXPECT_EQ(6, diff_cases[1].editdis);
EXPECT_EQ("acbdabed", diff_cases[1].lcs_s); EXPECT_EQ("acbdabed", diff_cases[1].lcs_s);
@ -128,7 +139,7 @@ TEST_F (Strdifftest, diff_test1) {
ASSERT_EQ(0, diff_cases[1].editdis_uni); ASSERT_EQ(0, diff_cases[1].editdis_uni);
} }
TEST_F (Strdifftest, diff_test2) { TEST_F(Strdifftest, diff_test2) {
EXPECT_EQ(6, diff_cases[2].editdis); EXPECT_EQ(6, diff_cases[2].editdis);
EXPECT_EQ("acf", diff_cases[2].lcs_s); EXPECT_EQ("acf", diff_cases[2].lcs_s);
@ -138,7 +149,7 @@ TEST_F (Strdifftest, diff_test2) {
ASSERT_EQ(0, diff_cases[2].editdis_uni); ASSERT_EQ(0, diff_cases[2].editdis_uni);
} }
TEST_F (Strdifftest, diff_test3) { TEST_F(Strdifftest, diff_test3) {
EXPECT_EQ(4, diff_cases[3].editdis); EXPECT_EQ(4, diff_cases[3].editdis);
EXPECT_EQ("bcba", diff_cases[3].lcs_s); EXPECT_EQ("bcba", diff_cases[3].lcs_s);
@ -148,7 +159,7 @@ TEST_F (Strdifftest, diff_test3) {
ASSERT_EQ(0, diff_cases[3].editdis_uni); ASSERT_EQ(0, diff_cases[3].editdis_uni);
} }
TEST_F (Strdifftest, diff_test4) { TEST_F(Strdifftest, diff_test4) {
EXPECT_EQ(1, diff_cases[4].editdis); EXPECT_EQ(1, diff_cases[4].editdis);
EXPECT_EQ("bokko", diff_cases[4].lcs_s); EXPECT_EQ("bokko", diff_cases[4].lcs_s);
@ -158,7 +169,7 @@ TEST_F (Strdifftest, diff_test4) {
ASSERT_EQ(0, diff_cases[4].editdis_uni); ASSERT_EQ(0, diff_cases[4].editdis_uni);
} }
TEST_F (Strdifftest, diff_test5) { TEST_F(Strdifftest, diff_test5) {
EXPECT_EQ(0, diff_cases[5].editdis); EXPECT_EQ(0, diff_cases[5].editdis);
EXPECT_EQ("", diff_cases[5].lcs_s); EXPECT_EQ("", diff_cases[5].lcs_s);
@ -168,7 +179,7 @@ TEST_F (Strdifftest, diff_test5) {
ASSERT_EQ(0, diff_cases[5].editdis_uni); ASSERT_EQ(0, diff_cases[5].editdis_uni);
} }
TEST_F (Strdifftest, diff_test6) { TEST_F(Strdifftest, diff_test6) {
EXPECT_EQ(1, diff_cases[6].editdis); EXPECT_EQ(1, diff_cases[6].editdis);
EXPECT_EQ("", diff_cases[6].lcs_s); EXPECT_EQ("", diff_cases[6].lcs_s);
@ -178,7 +189,7 @@ TEST_F (Strdifftest, diff_test6) {
ASSERT_EQ(0, diff_cases[6].editdis_uni); ASSERT_EQ(0, diff_cases[6].editdis_uni);
} }
TEST_F (Strdifftest, diff_test7) { TEST_F(Strdifftest, diff_test7) {
EXPECT_EQ(1, diff_cases[7].editdis); EXPECT_EQ(1, diff_cases[7].editdis);
EXPECT_EQ("", diff_cases[7].lcs_s); EXPECT_EQ("", diff_cases[7].lcs_s);
@ -188,7 +199,7 @@ TEST_F (Strdifftest, diff_test7) {
ASSERT_EQ(0, diff_cases[7].editdis_uni); ASSERT_EQ(0, diff_cases[7].editdis_uni);
} }
TEST_F (Strdifftest, diff_test8) { TEST_F(Strdifftest, diff_test8) {
EXPECT_EQ(6, diff_cases[8].editdis); EXPECT_EQ(6, diff_cases[8].editdis);
EXPECT_EQ("acbdaqqqqqqqbed", diff_cases[8].lcs_s); EXPECT_EQ("acbdaqqqqqqqbed", diff_cases[8].lcs_s);
@ -198,7 +209,7 @@ TEST_F (Strdifftest, diff_test8) {
ASSERT_EQ(0, diff_cases[8].editdis_uni); ASSERT_EQ(0, diff_cases[8].editdis_uni);
} }
TEST_F (Strdifftest, only_editdis_test0) { TEST_F(Strdifftest, only_editdis_test0) {
EXPECT_EQ(2, only_editdis_cases[0].editdis); EXPECT_EQ(2, only_editdis_cases[0].editdis);
EXPECT_EQ("", only_editdis_cases[0].lcs_s); EXPECT_EQ("", only_editdis_cases[0].lcs_s);
@ -208,7 +219,7 @@ TEST_F (Strdifftest, only_editdis_test0) {
ASSERT_TRUE(only_editdis_cases[0].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[0].hunk_v.empty());
} }
TEST_F (Strdifftest, only_editdis_test1) { TEST_F(Strdifftest, only_editdis_test1) {
EXPECT_EQ(6, only_editdis_cases[1].editdis); EXPECT_EQ(6, only_editdis_cases[1].editdis);
EXPECT_EQ("", only_editdis_cases[1].lcs_s); EXPECT_EQ("", only_editdis_cases[1].lcs_s);
@ -218,7 +229,7 @@ TEST_F (Strdifftest, only_editdis_test1) {
ASSERT_TRUE(only_editdis_cases[1].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[1].hunk_v.empty());
} }
TEST_F (Strdifftest, only_editdis_test2) { TEST_F(Strdifftest, only_editdis_test2) {
EXPECT_EQ(6, only_editdis_cases[2].editdis); EXPECT_EQ(6, only_editdis_cases[2].editdis);
EXPECT_EQ("", only_editdis_cases[2].lcs_s); EXPECT_EQ("", only_editdis_cases[2].lcs_s);
@ -228,7 +239,7 @@ TEST_F (Strdifftest, only_editdis_test2) {
ASSERT_TRUE(only_editdis_cases[2].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[2].hunk_v.empty());
} }
TEST_F (Strdifftest, only_editdis_test3) { TEST_F(Strdifftest, only_editdis_test3) {
EXPECT_EQ(4, only_editdis_cases[3].editdis); EXPECT_EQ(4, only_editdis_cases[3].editdis);
EXPECT_EQ("", only_editdis_cases[3].lcs_s); EXPECT_EQ("", only_editdis_cases[3].lcs_s);
@ -238,7 +249,7 @@ TEST_F (Strdifftest, only_editdis_test3) {
ASSERT_TRUE(only_editdis_cases[3].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[3].hunk_v.empty());
} }
TEST_F (Strdifftest, only_editdis_test4) { TEST_F(Strdifftest, only_editdis_test4) {
EXPECT_EQ(1, only_editdis_cases[4].editdis); EXPECT_EQ(1, only_editdis_cases[4].editdis);
EXPECT_EQ("", only_editdis_cases[4].lcs_s); EXPECT_EQ("", only_editdis_cases[4].lcs_s);
@ -248,7 +259,7 @@ TEST_F (Strdifftest, only_editdis_test4) {
ASSERT_TRUE(only_editdis_cases[4].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[4].hunk_v.empty());
} }
TEST_F (Strdifftest, only_editdis_test5) { TEST_F(Strdifftest, only_editdis_test5) {
EXPECT_EQ(0, only_editdis_cases[5].editdis); EXPECT_EQ(0, only_editdis_cases[5].editdis);
EXPECT_EQ("", only_editdis_cases[5].lcs_s); EXPECT_EQ("", only_editdis_cases[5].lcs_s);
@ -258,7 +269,7 @@ TEST_F (Strdifftest, only_editdis_test5) {
ASSERT_TRUE(only_editdis_cases[5].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[5].hunk_v.empty());
} }
TEST_F (Strdifftest, only_editdis_test6) { TEST_F(Strdifftest, only_editdis_test6) {
EXPECT_EQ(1, only_editdis_cases[6].editdis); EXPECT_EQ(1, only_editdis_cases[6].editdis);
EXPECT_EQ("", only_editdis_cases[6].lcs_s); EXPECT_EQ("", only_editdis_cases[6].lcs_s);
@ -268,7 +279,7 @@ TEST_F (Strdifftest, only_editdis_test6) {
ASSERT_TRUE(only_editdis_cases[6].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[6].hunk_v.empty());
} }
TEST_F (Strdifftest, only_editdis_test7) { TEST_F(Strdifftest, only_editdis_test7) {
EXPECT_EQ(1, only_editdis_cases[7].editdis); EXPECT_EQ(1, only_editdis_cases[7].editdis);
EXPECT_EQ("", only_editdis_cases[7].lcs_s); EXPECT_EQ("", only_editdis_cases[7].lcs_s);
@ -278,7 +289,7 @@ TEST_F (Strdifftest, only_editdis_test7) {
ASSERT_TRUE(only_editdis_cases[7].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[7].hunk_v.empty());
} }
TEST_F (Strdifftest, only_editdis_test8) { TEST_F(Strdifftest, only_editdis_test8) {
EXPECT_EQ(6, only_editdis_cases[8].editdis); EXPECT_EQ(6, only_editdis_cases[8].editdis);
EXPECT_EQ("", only_editdis_cases[8].lcs_s); EXPECT_EQ("", only_editdis_cases[8].lcs_s);
@ -288,7 +299,7 @@ TEST_F (Strdifftest, only_editdis_test8) {
ASSERT_TRUE(only_editdis_cases[8].hunk_v.empty()); ASSERT_TRUE(only_editdis_cases[8].hunk_v.empty());
} }
TEST_F (Strdifftest, custom_comparator_test0) { TEST_F(Strdifftest, custom_comparator_test0) {
EXPECT_EQ(0, custom_cases[0].editdis); EXPECT_EQ(0, custom_cases[0].editdis);
EXPECT_EQ("abc", custom_cases[0].lcs_s); EXPECT_EQ("abc", custom_cases[0].lcs_s);

11
test/comparators.hpp
View File

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

2
test/dtl_test.cpp
View File

@ -4,7 +4,7 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
int main (int argc, char *argv[]) { int main(int argc, char *argv[]) {
::testing::InitGoogleTest(&argc, argv); ::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS(); return RUN_ALL_TESTS();
} }

29
test/dtl_test_common.cpp
View File

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

55
test/dtl_test_common.hpp
View File

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