/**
* Retrieves the names of the files that should be used when testing the ldif-diff tool. Each
* element of the outer array should be an array containing the following elements:
*
* <OL>
* <LI>The path to the source LDIF file
* <LI>The path to the target LDIF file
* <LI>The path to the file with entries to be ignored
* <LI>The path to the diff file
* </OL>
*/
@DataProvider(name = "ignoreentriesdata")
public Object[][] getIETestData() {
String buildRoot = System.getProperty(TestCaseUtils.PROPERTY_BUILD_ROOT);
String ldifRoot =
buildRoot
+ File.separator
+ "tests"
+ File.separator
+ "unit-tests-testng"
+ File.separator
+ "resource"
+ File.separator
+ "ldif-diff"
+ File.separator;
return new Object[][] {
// Make changes to multiple entries in the target->source direction.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "ignore-entries",
ldifRoot + "diff-multipleentries-ignore-entries.ldif"
},
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "does-not-exist",
ldifRoot + "diff-multipleentries-ignore-entries.ldif"
}
};
}
/** A set of test cases for the LDIFDiff tool. */
public class LDIFDiffTestCase extends ToolsTestCase {
/**
* The path to the file that will be used if there are no differences between the source and
* target LDIF data sets.
*/
private String noDiffsFile =
System.getProperty(TestCaseUtils.PROPERTY_BUILD_ROOT)
+ File.separator
+ "tests"
+ File.separator
+ "unit-tests-testng"
+ File.separator
+ "resource"
+ File.separator
+ "ldif-diff"
+ File.separator
+ "diff-nochanges.ldif";
/**
* Make sure that the server is running, since we need it for schema handling.
*
* @throws Exception If an unexpected problem occurs.
*/
@BeforeClass
public void startServer() throws Exception {
TestCaseUtils.startServer();
}
/** Calculates the checksum of a file. */
private long calcChecksum(String filename) throws Exception {
return calcChecksum(new File(filename));
}
private long calcChecksum(File file) throws Exception {
long checksum = 0L;
BufferedReader reader = new BufferedReader(new FileReader(file));
String line = null;
while ((line = reader.readLine()) != null) {
checksum += line.hashCode();
}
reader.close();
return checksum;
}
/**
* Tests the LDIFDiff tool with an argument that will simply cause it to display usage
* information.
*/
@Test
public void testUsage() {
String[] args = {"--help"};
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
args = new String[] {"-H"};
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
args = new String[] {"-?"};
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
}
/** Tests the LDIFDiff tool with an invalid set of arguments. */
@Test
public void testInvalidArguments() {
String[] args = {"--invalid"};
assertFalse(LDIFDiff.mainDiff(args, true, System.out, System.err) == 0);
}
/**
* Retrieves the names of the files that should be used when testing the ldif-diff tool. Each
* element of the outer array should be an array containing the following elements:
*
* <OL>
* <LI>The path to the source LDIF file
* <LI>The path to the target LDIF file
* <LI>The path to the diff file, or {@code null} if the diff is supposed to fail
* </OL>
*/
@DataProvider(name = "testdata")
public Object[][] getTestData() {
String buildRoot = System.getProperty(TestCaseUtils.PROPERTY_BUILD_ROOT);
String ldifRoot =
buildRoot
+ File.separator
+ "tests"
+ File.separator
+ "unit-tests-testng"
+ File.separator
+ "resource"
+ File.separator
+ "ldif-diff"
+ File.separator;
return new Object[][] {
// Both files are empty.
new Object[] {
ldifRoot + "source-empty.ldif",
ldifRoot + "target-empty.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// Both files are the single-entry source.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "source-singleentry.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// Both files are the single-entry target.
new Object[] {
ldifRoot + "target-singleentry.ldif",
ldifRoot + "target-singleentry.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// Both files are the multiple-entry source.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "source-multipleentries.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// Both files are the multiple-entry target.
new Object[] {
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// The source is empty but the target has a single entry.
new Object[] {
ldifRoot + "source-empty.ldif",
ldifRoot + "target-singleentry.ldif",
ldifRoot + "diff-emptytosingle.ldif",
ldifRoot + "diff-emptytosingle.ldif",
COMPARE_FALSE
},
// The source has a single entry but the target is empty.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "target-empty.ldif",
ldifRoot + "diff-singletoempty.ldif",
ldifRoot + "diff-singletoempty.ldif",
COMPARE_FALSE
},
// Make a change to only a single entry in the source->target direction.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "target-singleentry.ldif",
ldifRoot + "diff-singleentry.ldif",
ldifRoot + "diff-singleentry.ldif",
COMPARE_FALSE
},
// Make a change to only a single entry in the target->source direction.
new Object[] {
ldifRoot + "target-singleentry.ldif",
ldifRoot + "source-singleentry.ldif",
ldifRoot + "diff-singleentry-reverse.ldif",
ldifRoot + "diff-singleentry-reverse.ldif",
COMPARE_FALSE
},
// Make changes to multiple entries in the source->target direction.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "diff-multipleentries.ldif",
ldifRoot + "diff-multipleentries-singlevalue.ldif",
COMPARE_FALSE
},
// Make changes to multiple entries in the target->source direction.
new Object[] {
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "diff-multipleentries-reverse.ldif",
ldifRoot + "diff-multipleentries-reverse-singlevalue.ldif",
COMPARE_FALSE
},
// Go from one entry to multiple in the source->target direction.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "diff-singletomultiple.ldif",
ldifRoot + "diff-singletomultiple-singlevalue.ldif",
COMPARE_FALSE
},
// Go from one entry to multiple in the target->source direction.
new Object[] {
ldifRoot + "target-singleentry.ldif",
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "diff-singletomultiple-reverse.ldif",
ldifRoot + "diff-singletomultiple-reverse.ldif",
COMPARE_FALSE
},
// Go from multiple entries to one in the source->target direction.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-singleentry.ldif",
ldifRoot + "diff-multipletosingle.ldif",
ldifRoot + "diff-multipletosingle.ldif",
COMPARE_FALSE
},
// Go from multiple entries to one in the target->source direction.
new Object[] {
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "source-singleentry.ldif",
ldifRoot + "diff-multipletosingle-reverse.ldif",
ldifRoot + "diff-multipletosingle-reverse-singlevalue.ldif",
COMPARE_FALSE
},
// The source file doesn't exist.
new Object[] {
ldifRoot + "source-notfound.ldif",
ldifRoot + "target-singleentry.ldif",
null,
null,
COMPARE_FALSE
},
// The target file doesn't exist.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "target-notfound.ldif",
null,
null,
COMPARE_FALSE
}
};
}
/**
* Tests the LDIFDiff tool with the provided information to ensure that the normal mode of
* operation works as expected. This is a bit tricky because the attributes and values will be
* written in an indeterminate order, so we can't just use string equality. We'll have to use a
* crude checksum mechanism to test whether they are equal. Combined with other methods in this
* class, this should be good enough.
*
* @param sourceFile The path to the file containing the source data set.
* @param targetFile The path to the file containing the target data set.
* @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
* most one record per entry), or {@code null} if the diff is supposed to fail.
* @param singleValueDiffFile The path to the file containing the expected diff in "single-value"
* form, where each attribute-level change results in a separate entry per attribute value.
* @param resultCode The result code that should be returned with --useCompareResultCode flag
* @throws Exception If an unexpected problem occurs.
*/
@Test(dataProvider = "testdata")
public void testVerifyNormal(
String sourceFile,
String targetFile,
String normalDiffFile,
String singleValueDiffFile,
int resultCode)
throws Exception {
File outputFile = File.createTempFile("difftest", "ldif");
outputFile.deleteOnExit();
String[] args = {"-s", sourceFile, "-t", targetFile, "-o", outputFile.getAbsolutePath(), "-O"};
String[] argsUseCompare = {
"-s", sourceFile,
"-t", targetFile,
// No need to write to the outputFile
"--useCompareResultCode"
};
if (normalDiffFile == null) {
// We expect this to fail, so just make sure that it does.
assertFalse(LDIFDiff.mainDiff(args, true, System.out, System.err) == 0);
outputFile.delete();
return;
}
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
assertEquals(calcChecksum(outputFile), calcChecksum(normalDiffFile));
assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), resultCode);
outputFile.delete();
}
/**
* Tests the LDIFDiff tool with the provided information to ensure that the single value changes
* mode of operation works as expected. This is a bit tricky because the attributes and values
* will be written in an indeterminate order, so we can't just use string equality. We'll have to
* use a crude checksum mechanism to test whether they are equal. Combined with other methods in
* this class, this should be good enough.
*
* @param sourceFile The path to the file containing the source data set.
* @param targetFile The path to the file containing the target data set.
* @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
* most one record per entry), or {@code null} if the diff is supposed to fail.
* @param singleValueDiffFile The path to the file containing the expected diff in "single-value"
* form, where each attribute-level change results in a separate entry per attribute value.
* @param resultCode The result code that should be returned with --useCompareResultCode flag
* @throws Exception If an unexpected problem occurs.
*/
@Test(dataProvider = "testdata")
public void testVerifySingleValue(
String sourceFile,
String targetFile,
String normalDiffFile,
String singleValueDiffFile,
int resultCode)
throws Exception {
File outputFile = File.createTempFile("difftest", "ldif");
outputFile.deleteOnExit();
String[] args = {
"-s", sourceFile, "-t", targetFile, "-o", outputFile.getAbsolutePath(), "-O", "-S"
};
String[] argsUseCompare = {
"-s", sourceFile,
"-t", targetFile,
// No need to write to the outputFile
"--useCompareResultCode"
};
if (singleValueDiffFile == null) {
// We expect this to fail, so just make sure that it does.
assertFalse(LDIFDiff.mainDiff(args, true, System.out, System.err) == 0);
outputFile.delete();
return;
}
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
assertEquals(calcChecksum(outputFile), calcChecksum(singleValueDiffFile));
assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), resultCode);
outputFile.delete();
}
/**
* Tests the LDIFDiff tool by first identifying the differences between the source and the target
* and then using the LDIFModify tool to apply the identified changes to the source LDIF and
* verify that it matches the target.
*
* @param sourceFile The path to the file containing the source data set.
* @param targetFile The path to the file containing the target data set.
* @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
* most one record per entry), or {@code null} if the diff is supposed to fail.
* @param singleValueDiffFile The path to the file containing the expected diff in "single-value"
* form, where each attribute-level change results in a separate entry per attribute value.
* @param resultCode The result code that should be returned with --useCompareResultCode flag
* @throws Exception If an unexpected problem occurs.
*/
@Test(dataProvider = "testdata")
public void testReconstructNormal(
String sourceFile,
String targetFile,
String normalDiffFile,
String singleValueDiffFile,
int resultCode)
throws Exception {
// If the command is expected to fail, or if there aren't any differences,
// then bail out now.
if (normalDiffFile == null || normalDiffFile.equals(noDiffsFile)) {
return;
}
// Generate the diff file.
File diffOutputFile = File.createTempFile("difftest", "ldif");
diffOutputFile.deleteOnExit();
String[] args = {
"-s", sourceFile,
"-t", targetFile,
"-o", diffOutputFile.getAbsolutePath()
};
String[] argsUseCompare = {
"-s", sourceFile,
"-t", targetFile,
// No need to write to the outputFile
"--useCompareResultCode"
};
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), resultCode);
// Use LDIFModify to generate a new target file.
File newTargetFile = File.createTempFile("difftest", "newtarget.ldif");
newTargetFile.deleteOnExit();
DirectoryServer.getInstance();
args =
new String[] {
"-c", DirectoryServer.getConfigFile(),
"-s", sourceFile,
"-m", diffOutputFile.getAbsolutePath(),
"-t", newTargetFile.getAbsolutePath()
};
assertEquals(LDIFModify.ldifModifyMain(args, true, System.out, System.err), 0);
// Use LDIFDiff again to verify that there are effectively no differences
// between the original target and the new target.
File newDiffFile = File.createTempFile("difftest", "newdiff.ldif");
newDiffFile.deleteOnExit();
args =
new String[] {
"-s", targetFile,
"-t", newTargetFile.getAbsolutePath(),
"-o", newDiffFile.getAbsolutePath()
};
argsUseCompare =
new String[] {
"-s",
targetFile,
"-t",
newTargetFile.getAbsolutePath(),
// No need to write to the outputFile
"--useCompareResultCode"
};
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
assertEquals(calcChecksum(newDiffFile), calcChecksum(noDiffsFile));
assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), COMPARE_TRUE);
diffOutputFile.delete();
newTargetFile.delete();
newDiffFile.delete();
}
/**
* Tests the LDIFDiff tool by first identifying the differences between the source and the target
* (using the single-value format) and then using the LDIFModify tool to apply the identified
* changes to the source LDIF and verify that it matches the target.
*
* @param sourceFile The path to the file containing the source data set.
* @param targetFile The path to the file containing the target data set.
* @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
* most one record per entry), or {@code null} if the diff is supposed to fail.
* @param singleValueDiffFile The path to the file containing the expected diff in "single-value"
* form, where each attribute-level change results in a separate entry per attribute value.
* @param resultCode The result code that should be returned with --useCompareResultCode flag
* @throws Exception If an unexpected problem occurs.
*/
@Test(dataProvider = "testdata")
public void testReconstructSingleValue(
String sourceFile,
String targetFile,
String normalDiffFile,
String singleValueDiffFile,
int resultCode)
throws Exception {
// If the command is expected to fail, or if there aren't any differences,
// then bail out now.
if (normalDiffFile == null || singleValueDiffFile.equals(noDiffsFile)) {
return;
}
// Generate the diff file.
File diffOutputFile = File.createTempFile("difftest", "ldif");
diffOutputFile.deleteOnExit();
String[] args = {
"-s", sourceFile, "-t", targetFile, "-o", diffOutputFile.getAbsolutePath(), "-S"
};
String[] argsUseCompare = {
"-s", sourceFile,
"-t", targetFile,
// No need to write to the outputFile
"--useCompareResultCode"
};
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), resultCode);
// Use LDIFModify to generate a new target file.
File newTargetFile = File.createTempFile("difftest", "newtarget.ldif");
newTargetFile.deleteOnExit();
DirectoryServer.getInstance();
args =
new String[] {
"-c", DirectoryServer.getConfigFile(),
"-s", sourceFile,
"-m", diffOutputFile.getAbsolutePath(),
"-t", newTargetFile.getAbsolutePath()
};
assertEquals(LDIFModify.ldifModifyMain(args, true, System.out, System.err), 0);
// Use LDIFDiff again to verify that there are effectively no differences
// between the original target and the new target.
File newDiffFile = File.createTempFile("difftest", "newdiff.ldif");
newDiffFile.deleteOnExit();
args =
new String[] {
"-s", targetFile,
"-t", newTargetFile.getAbsolutePath(),
"-o", newDiffFile.getAbsolutePath()
};
argsUseCompare =
new String[] {
"-s",
targetFile,
"-t",
newTargetFile.getAbsolutePath(),
// No need to write to the outputFile
"--useCompareResultCode"
};
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
assertEquals(calcChecksum(newDiffFile), calcChecksum(noDiffsFile));
assertEquals(LDIFDiff.mainDiff(argsUseCompare, true, System.out, System.err), COMPARE_TRUE);
diffOutputFile.delete();
newTargetFile.delete();
newDiffFile.delete();
}
/**
* Retrieves the names of the files that should be used when testing the ldif-diff tool. Each
* element of the outer array should be an array containing the following elements:
*
* <OL>
* <LI>The path to the source LDIF file
* <LI>The path to the target LDIF file
* <LI>The path to the file with attributes to be ignored
* <LI>The path to the diff file
* </OL>
*/
@DataProvider(name = "ignoreattributesdata")
public Object[][] getIATestData() {
String buildRoot = System.getProperty(TestCaseUtils.PROPERTY_BUILD_ROOT);
String ldifRoot =
buildRoot
+ File.separator
+ "tests"
+ File.separator
+ "unit-tests-testng"
+ File.separator
+ "resource"
+ File.separator
+ "ldif-diff"
+ File.separator;
return new Object[][] {
// Make changes to multiple entries in the target->source direction.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "ignore-attributes",
ldifRoot + "diff-multipleentries-ignore-attributes.ldif"
},
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "does-not-exist",
ldifRoot + "diff-multipleentries-ignore-attributes.ldif"
}
};
}
/**
* Tests the LDIFDiff tool with the provided information to ensure that the normal mode of
* operation works as expected. This is a bit tricky because the attributes and values will be
* written in an indeterminate order, so we can't just use string equality. We'll have to use a
* crude checksum mechanism to test whether they are equal. Combined with other methods in this
* class, this should be good enough.
*
* @param sourceFile The path to the file containing the source data set.
* @param targetFile The path to the file containing the target data set.
* @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
* most one record per entry), or {@code null} if the diff is supposed to fail.
* @throws Exception If an unexpected problem occurs.
*/
@Test(dataProvider = "ignoreattributesdata")
public void testVerifyIgnoreAttributes(
String sourceFile, String targetFile, String ignoreAttributesFile, String normalDiffFile)
throws Exception {
File outputFile = File.createTempFile("difftest", "ldif");
outputFile.deleteOnExit();
String[] args = {
"-s", sourceFile,
"-t", targetFile,
"-a", ignoreAttributesFile,
"-o", outputFile.getAbsolutePath(),
"-O"
};
if (ignoreAttributesFile.endsWith("does-not-exist")) {
// We expect this to fail, so just make sure that it does.
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 1);
return;
}
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
assertEquals(calcChecksum(outputFile), calcChecksum(normalDiffFile));
outputFile.delete();
}
/**
* Retrieves the names of the files that should be used when testing the ldif-diff tool. Each
* element of the outer array should be an array containing the following elements:
*
* <OL>
* <LI>The path to the source LDIF file
* <LI>The path to the target LDIF file
* <LI>The path to the file with entries to be ignored
* <LI>The path to the diff file
* </OL>
*/
@DataProvider(name = "ignoreentriesdata")
public Object[][] getIETestData() {
String buildRoot = System.getProperty(TestCaseUtils.PROPERTY_BUILD_ROOT);
String ldifRoot =
buildRoot
+ File.separator
+ "tests"
+ File.separator
+ "unit-tests-testng"
+ File.separator
+ "resource"
+ File.separator
+ "ldif-diff"
+ File.separator;
return new Object[][] {
// Make changes to multiple entries in the target->source direction.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "ignore-entries",
ldifRoot + "diff-multipleentries-ignore-entries.ldif"
},
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "does-not-exist",
ldifRoot + "diff-multipleentries-ignore-entries.ldif"
}
};
}
/**
* Tests the LDIFDiff tool with the provided information to ensure that the normal mode of
* operation works as expected. This is a bit tricky because the attributes and values will be
* written in an indeterminate order, so we can't just use string equality. We'll have to use a
* crude checksum mechanism to test whether they are equal. Combined with other methods in this
* class, this should be good enough.
*
* @param sourceFile The path to the file containing the source data set.
* @param targetFile The path to the file containing the target data set.
* @param normalDiffFile The path to the file containing the expected diff in "normal" form (at
* most one record per entry), or {@code null} if the diff is supposed to fail.
* @throws Exception If an unexpected problem occurs.
*/
@Test(dataProvider = "ignoreentriesdata")
public void testVerifyIgnoreEntries(
String sourceFile, String targetFile, String ignoreEntriesFile, String normalDiffFile)
throws Exception {
File outputFile = File.createTempFile("difftest", "ldif");
outputFile.deleteOnExit();
String[] args = {
"-s", sourceFile,
"-t", targetFile,
"-e", ignoreEntriesFile,
"-o", outputFile.getAbsolutePath(),
"-O"
};
if (ignoreEntriesFile.endsWith("does-not-exist")) {
// We expect this to fail, so just make sure that it does.
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 1);
return;
}
assertEquals(LDIFDiff.mainDiff(args, true, System.out, System.err), 0);
assertEquals(calcChecksum(outputFile), calcChecksum(normalDiffFile));
outputFile.delete();
}
}
/**
* Retrieves the names of the files that should be used when testing the ldif-diff tool. Each
* element of the outer array should be an array containing the following elements:
*
* <OL>
* <LI>The path to the source LDIF file
* <LI>The path to the target LDIF file
* <LI>The path to the diff file, or {@code null} if the diff is supposed to fail
* </OL>
*/
@DataProvider(name = "testdata")
public Object[][] getTestData() {
String buildRoot = System.getProperty(TestCaseUtils.PROPERTY_BUILD_ROOT);
String ldifRoot =
buildRoot
+ File.separator
+ "tests"
+ File.separator
+ "unit-tests-testng"
+ File.separator
+ "resource"
+ File.separator
+ "ldif-diff"
+ File.separator;
return new Object[][] {
// Both files are empty.
new Object[] {
ldifRoot + "source-empty.ldif",
ldifRoot + "target-empty.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// Both files are the single-entry source.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "source-singleentry.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// Both files are the single-entry target.
new Object[] {
ldifRoot + "target-singleentry.ldif",
ldifRoot + "target-singleentry.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// Both files are the multiple-entry source.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "source-multipleentries.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// Both files are the multiple-entry target.
new Object[] {
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
noDiffsFile,
noDiffsFile,
COMPARE_TRUE
},
// The source is empty but the target has a single entry.
new Object[] {
ldifRoot + "source-empty.ldif",
ldifRoot + "target-singleentry.ldif",
ldifRoot + "diff-emptytosingle.ldif",
ldifRoot + "diff-emptytosingle.ldif",
COMPARE_FALSE
},
// The source has a single entry but the target is empty.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "target-empty.ldif",
ldifRoot + "diff-singletoempty.ldif",
ldifRoot + "diff-singletoempty.ldif",
COMPARE_FALSE
},
// Make a change to only a single entry in the source->target direction.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "target-singleentry.ldif",
ldifRoot + "diff-singleentry.ldif",
ldifRoot + "diff-singleentry.ldif",
COMPARE_FALSE
},
// Make a change to only a single entry in the target->source direction.
new Object[] {
ldifRoot + "target-singleentry.ldif",
ldifRoot + "source-singleentry.ldif",
ldifRoot + "diff-singleentry-reverse.ldif",
ldifRoot + "diff-singleentry-reverse.ldif",
COMPARE_FALSE
},
// Make changes to multiple entries in the source->target direction.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "diff-multipleentries.ldif",
ldifRoot + "diff-multipleentries-singlevalue.ldif",
COMPARE_FALSE
},
// Make changes to multiple entries in the target->source direction.
new Object[] {
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "diff-multipleentries-reverse.ldif",
ldifRoot + "diff-multipleentries-reverse-singlevalue.ldif",
COMPARE_FALSE
},
// Go from one entry to multiple in the source->target direction.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "diff-singletomultiple.ldif",
ldifRoot + "diff-singletomultiple-singlevalue.ldif",
COMPARE_FALSE
},
// Go from one entry to multiple in the target->source direction.
new Object[] {
ldifRoot + "target-singleentry.ldif",
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "diff-singletomultiple-reverse.ldif",
ldifRoot + "diff-singletomultiple-reverse.ldif",
COMPARE_FALSE
},
// Go from multiple entries to one in the source->target direction.
new Object[] {
ldifRoot + "source-multipleentries.ldif",
ldifRoot + "target-singleentry.ldif",
ldifRoot + "diff-multipletosingle.ldif",
ldifRoot + "diff-multipletosingle.ldif",
COMPARE_FALSE
},
// Go from multiple entries to one in the target->source direction.
new Object[] {
ldifRoot + "target-multipleentries.ldif",
ldifRoot + "source-singleentry.ldif",
ldifRoot + "diff-multipletosingle-reverse.ldif",
ldifRoot + "diff-multipletosingle-reverse-singlevalue.ldif",
COMPARE_FALSE
},
// The source file doesn't exist.
new Object[] {
ldifRoot + "source-notfound.ldif",
ldifRoot + "target-singleentry.ldif",
null,
null,
COMPARE_FALSE
},
// The target file doesn't exist.
new Object[] {
ldifRoot + "source-singleentry.ldif",
ldifRoot + "target-notfound.ldif",
null,
null,
COMPARE_FALSE
}
};
}