diff options
Diffstat (limited to 'org.eclipse.jgit.test')
5 files changed, 529 insertions, 2 deletions
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java index cb7cad8340..4c9c54f214 100644 --- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011, Dariusz Luksza <dariusz@luksza.org> + * Copyright (C) 2011, 2013 Dariusz Luksza <dariusz@luksza.org> * and other copyright owners as documented in the project's IP log. * * This program and the accompanying materials are made available @@ -47,6 +47,7 @@ import static org.eclipse.jgit.util.FileUtils.delete; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.notNullValue; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; @@ -65,6 +66,8 @@ import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.treewalk.EmptyTreeIterator; import org.eclipse.jgit.treewalk.FileTreeIterator; import org.eclipse.jgit.treewalk.TreeWalk; +import org.eclipse.jgit.treewalk.filter.PathFilterGroup; +import org.eclipse.jgit.treewalk.filter.TreeFilter; import org.eclipse.jgit.util.FileUtils; import org.junit.Test; @@ -265,6 +268,71 @@ public class DiffEntryTest extends RepositoryTestCase { assertThat(entry.getNewPath(), is("b.txt")); } + @Test + public void shouldMarkEntriesWhenGivenMarkTreeFilter() throws Exception { + // given + Git git = new Git(db); + RevCommit c1 = git.commit().setMessage("initial commit").call(); + FileUtils.mkdir(new File(db.getWorkTree(), "b")); + writeTrashFile("a.txt", "a"); + writeTrashFile("b/1.txt", "b1"); + writeTrashFile("b/2.txt", "b2"); + writeTrashFile("c.txt", "c"); + git.add().addFilepattern("a.txt").addFilepattern("b") + .addFilepattern("c.txt").call(); + RevCommit c2 = git.commit().setMessage("second commit").call(); + TreeFilter filterA = PathFilterGroup.createFromStrings("a.txt"); + TreeFilter filterB = PathFilterGroup.createFromStrings("b"); + TreeFilter filterB2 = PathFilterGroup.createFromStrings("b/2.txt"); + + // when + TreeWalk walk = new TreeWalk(db); + walk.addTree(c1.getTree()); + walk.addTree(c2.getTree()); + List<DiffEntry> result = DiffEntry.scan(walk, true, new TreeFilter[] { + filterA, filterB, filterB2 }); + + // then + assertThat(result, notNullValue()); + assertEquals(5, result.size()); + + DiffEntry entryA = result.get(0); + DiffEntry entryB = result.get(1); + DiffEntry entryB1 = result.get(2); + DiffEntry entryB2 = result.get(3); + DiffEntry entryC = result.get(4); + + assertThat(entryA.getNewPath(), is("a.txt")); + assertTrue(entryA.isMarked(0)); + assertFalse(entryA.isMarked(1)); + assertFalse(entryA.isMarked(2)); + assertEquals(1, entryA.getTreeFilterMarks()); + + assertThat(entryB.getNewPath(), is("b")); + assertFalse(entryB.isMarked(0)); + assertTrue(entryB.isMarked(1)); + assertTrue(entryB.isMarked(2)); + assertEquals(6, entryB.getTreeFilterMarks()); + + assertThat(entryB1.getNewPath(), is("b/1.txt")); + assertFalse(entryB1.isMarked(0)); + assertTrue(entryB1.isMarked(1)); + assertFalse(entryB1.isMarked(2)); + assertEquals(2, entryB1.getTreeFilterMarks()); + + assertThat(entryB2.getNewPath(), is("b/2.txt")); + assertFalse(entryB2.isMarked(0)); + assertTrue(entryB2.isMarked(1)); + assertTrue(entryB2.isMarked(2)); + assertEquals(6, entryB2.getTreeFilterMarks()); + + assertThat(entryC.getNewPath(), is("c.txt")); + assertFalse(entryC.isMarked(0)); + assertFalse(entryC.isMarked(1)); + assertFalse(entryC.isMarked(2)); + assertEquals(0, entryC.getTreeFilterMarks()); + } + @Test(expected = IllegalArgumentException.class) public void shouldThrowIAEWhenTreeWalkHasLessThanTwoTrees() throws Exception { diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/GCTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/GCTest.java index 8b6c003888..820a8ae07e 100644 --- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/GCTest.java +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/GCTest.java @@ -304,6 +304,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { public void nonReferencedExpiredObject_pruned() throws Exception { RevBlob a = tr.blob("a"); gc.setExpireAgeMillis(0); + fsTick(); gc.prune(Collections.<ObjectId> emptySet()); assertFalse(repo.hasObject(a)); } @@ -313,6 +314,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { RevBlob a = tr.blob("a"); RevTree t = tr.tree(tr.file("a", a)); gc.setExpireAgeMillis(0); + fsTick(); gc.prune(Collections.<ObjectId> emptySet()); assertFalse(repo.hasObject(t)); assertFalse(repo.hasObject(a)); @@ -336,6 +338,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { RevBlob a = tr.blob("a"); tr.lightweightTag("t", a); gc.setExpireAgeMillis(0); + fsTick(); gc.prune(Collections.<ObjectId> emptySet()); assertTrue(repo.hasObject(a)); } @@ -347,6 +350,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { tr.lightweightTag("t", t); gc.setExpireAgeMillis(0); + fsTick(); gc.prune(Collections.<ObjectId> emptySet()); assertTrue(repo.hasObject(t)); assertTrue(repo.hasObject(a)); @@ -357,6 +361,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { RevCommit tip = commitChain(10); tr.branch("b").update(tip); gc.setExpireAgeMillis(0); + fsTick(); gc.prune(Collections.<ObjectId> emptySet()); do { assertTrue(repo.hasObject(tip)); @@ -376,6 +381,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { update.setForceUpdate(true); update.delete(); gc.setExpireAgeMillis(0); + fsTick(); gc.prune(Collections.<ObjectId> emptySet()); assertTrue(gc.getStatistics().numberOfLooseObjects == 0); } @@ -404,6 +410,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { update.delete(); gc.setExpireAgeMillis(0); + fsTick(); gc.prune(Collections.<ObjectId> emptySet()); assertTrue(repo.hasObject(b2Tip)); } @@ -532,6 +539,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { assertEquals(0, stats.numberOfPackedObjects); gc.setExpireAgeMillis(0); + fsTick(); gc.gc(); stats = gc.getStatistics(); assertEquals(0, stats.numberOfLooseObjects); @@ -581,6 +589,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { assertEquals(8, stats.numberOfLooseObjects); assertEquals(0, stats.numberOfPackedObjects); gc.setExpireAgeMillis(0); + fsTick(); gc.gc(); stats = gc.getStatistics(); assertEquals(0, stats.numberOfLooseObjects); @@ -640,6 +649,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { assertEquals(9, stats.numberOfLooseObjects); assertEquals(0, stats.numberOfPackedObjects); gc.setExpireAgeMillis(0); + fsTick(); gc.gc(); stats = gc.getStatistics(); assertEquals(0, stats.numberOfLooseObjects); @@ -657,6 +667,7 @@ public class GCTest extends LocalDiskRepositoryTestCase { stats = gc.getStatistics(); assertEquals(8, stats.numberOfLooseObjects); gc.setExpireAgeMillis(0); + fsTick(); gc.prune(Collections.<ObjectId> emptySet()); stats = gc.getStatistics(); assertEquals(8, stats.numberOfLooseObjects); diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java index bf22569dfb..a416c742f8 100644 --- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/FileTreeIteratorTest.java @@ -253,14 +253,16 @@ public class FileTreeIteratorTest extends RepositoryTestCase { // Hopefully fsTick will make sure our entry gets smudged fsTick(f); writeTrashFile("file", "content"); + long lastModified = f.lastModified(); git.add().addFilepattern("file").call(); writeTrashFile("file", "conten2"); + f.setLastModified(lastModified); DirCacheEntry dce = db.readDirCache().getEntry("file"); FileTreeIterator fti = new FileTreeIterator(trash, db.getFS(), db .getConfig().get(WorkingTreeOptions.KEY)); while (!fti.getEntryPathString().equals("file")) fti.next(1); - // If the fsTick trick does not work we could skip the compareMetaData + // If the rounding trick does not work we could skip the compareMetaData // test and hope that we are usually testing the intended code path. assertEquals(MetadataDiff.SMUDGED, fti.compareMetadata(dce)); assertTrue(fti.isModified(dce, false)); diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest.java new file mode 100644 index 0000000000..5267e81a15 --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest.java @@ -0,0 +1,190 @@ +/* + * Copyright (C) 2013, Robin Rosenberg + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * - Neither the name of the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.eclipse.jgit.treewalk.filter; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.io.IOException; + +import org.eclipse.jgit.dircache.DirCache; +import org.eclipse.jgit.dircache.DirCacheEditor; +import org.eclipse.jgit.dircache.DirCacheEntry; +import org.eclipse.jgit.dircache.DirCacheIterator; +import org.eclipse.jgit.errors.IncorrectObjectTypeException; +import org.eclipse.jgit.errors.MissingObjectException; +import org.eclipse.jgit.errors.StopWalkException; +import org.eclipse.jgit.lib.FileMode; +import org.eclipse.jgit.lib.ObjectReader; +import org.eclipse.jgit.treewalk.TreeWalk; +import org.junit.Before; +import org.junit.Test; + +public class PathFilterGroupTest { + + private TreeFilter filter; + + @Before + public void setup() { + // @formatter:off + String[] paths = new String[] { + "/a", // never match + "/a/b", // never match + "a", + "b/c", + "c/d/e", + "c/d/f", + "d/e/f/g" + }; + // @formatter:on + filter = PathFilterGroup.createFromStrings(paths); + } + + @Test + public void testExact() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + assertTrue(filter.include(fakeWalk("a"))); + assertTrue(filter.include(fakeWalk("b/c"))); + assertTrue(filter.include(fakeWalk("c/d/e"))); + assertTrue(filter.include(fakeWalk("c/d/f"))); + assertTrue(filter.include(fakeWalk("d/e/f/g"))); + } + + @Test + public void testNoMatchButClose() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + assertFalse(filter.include(fakeWalk("a+"))); + assertFalse(filter.include(fakeWalk("b+/c"))); + assertFalse(filter.include(fakeWalk("c+/d/e"))); + assertFalse(filter.include(fakeWalk("c+/d/f"))); + assertFalse(filter.include(fakeWalk("c/d.a"))); + assertFalse(filter.include(fakeWalk("d+/e/f/g"))); + } + + @Test + public void testJustCommonPrefixIsNotMatch() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + assertFalse(filter.include(fakeWalk("b/a"))); + assertFalse(filter.include(fakeWalk("b/d"))); + assertFalse(filter.include(fakeWalk("c/d/a"))); + assertFalse(filter.include(fakeWalk("d/e/e"))); + } + + @Test + public void testKeyIsPrefixOfFilter() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + assertTrue(filter.include(fakeWalk("b"))); + assertTrue(filter.include(fakeWalk("c/d"))); + assertTrue(filter.include(fakeWalk("c/d"))); + assertTrue(filter.include(fakeWalk("c"))); + assertTrue(filter.include(fakeWalk("d/e/f"))); + assertTrue(filter.include(fakeWalk("d/e"))); + assertTrue(filter.include(fakeWalk("d"))); + } + + @Test + public void testFilterIsPrefixOfKey() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + assertTrue(filter.include(fakeWalk("a/b"))); + assertTrue(filter.include(fakeWalk("b/c/d"))); + assertTrue(filter.include(fakeWalk("c/d/e/f"))); + assertTrue(filter.include(fakeWalk("c/d/f/g"))); + assertTrue(filter.include(fakeWalk("d/e/f/g/h"))); + } + + @Test + public void testStopWalk() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + // Obvious + filter.include(fakeWalk("d/e/f/f")); + + // Obvious + try { + filter.include(fakeWalk("de")); + fail("StopWalkException expected"); + } catch (StopWalkException e) { + // good + } + + // less obvious due to git sorting order + filter.include(fakeWalk("d.")); + + // less obvious due to git sorting order + try { + filter.include(fakeWalk("d0")); + fail("StopWalkException expected"); + } catch (StopWalkException e) { + // good + } + + // non-ascii + try { + filter.include(fakeWalk("\u00C0")); + fail("StopWalkException expected"); + } catch (StopWalkException e) { + // good + } + } + + TreeWalk fakeWalk(final String path) throws IOException { + DirCache dc = DirCache.newInCore(); + DirCacheEditor dce = dc.editor(); + dce.add(new DirCacheEditor.PathEdit(path) { + + public void apply(DirCacheEntry ent) { + ent.setFileMode(FileMode.REGULAR_FILE); + } + }); + dce.finish(); + + TreeWalk ret = new TreeWalk((ObjectReader) null); + ret.reset(); + ret.setRecursive(true); + ret.addTree(new DirCacheIterator(dc)); + ret.next(); + return ret; + } + +} diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest2.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest2.java new file mode 100644 index 0000000000..6b9d934e4c --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest2.java @@ -0,0 +1,256 @@ +/* + * Copyright (C) 2013, Robin Rosenberg + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * - Neither the name of the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.eclipse.jgit.treewalk.filter; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.lessThan; +import static org.junit.Assert.assertEquals; + +import java.io.IOException; + +import org.eclipse.jgit.dircache.DirCache; +import org.eclipse.jgit.dircache.DirCacheEditor; +import org.eclipse.jgit.dircache.DirCacheEntry; +import org.eclipse.jgit.dircache.DirCacheIterator; +import org.eclipse.jgit.errors.IncorrectObjectTypeException; +import org.eclipse.jgit.errors.MissingObjectException; +import org.eclipse.jgit.lib.FileMode; +import org.eclipse.jgit.lib.ObjectReader; +import org.eclipse.jgit.treewalk.TreeWalk; +import org.junit.Test; + +/** + * Performance test suite for PathFilterGroup + */ +public class PathFilterGroupTest2 { + + private DirCache dc; + + private String[] paths = new String[100000]; + + private TreeFilter pf; + + private String data; + + private long tInit; + + public void setup(int pathsize, int filtersize, String[] filters) { + long t1 = System.nanoTime(); + String[] seed = { "abc", "def", "ghi", "jkl", "mno", "pqr", "stu", + "vwx", "xyz", "\u00e5\u00e4\u00f6" }; + dc = DirCache.newInCore(); + DirCacheEditor ed = dc.editor(); + int pi = 0; + B: for (String a : seed) { + for (String b : seed) { + for (String c : seed) { + for (String d : seed) { + for (String e : seed) { + if (pi >= pathsize) + break B; + String p1 = a + "/" + b + "/" + c + "/" + d + "/" + + e; + paths[pi] = p1; + ed.add(new DirCacheEditor.PathEdit(p1) { + + @Override + public void apply(DirCacheEntry ent) { + ent.setFileMode(FileMode.REGULAR_FILE); + } + }); + ++pi; + } + } + } + } + } + ed.finish(); + long t2 = System.nanoTime(); + if (filters != null) + pf = PathFilterGroup.createFromStrings(filters); + else { + // System.out.println(dc.getEntryCount()); + String[] filterPaths = new String[filtersize]; + System.arraycopy(paths, pathsize - filtersize, filterPaths, 0, + filtersize); + pf = PathFilterGroup.createFromStrings(filterPaths); + } + long t3 = System.nanoTime(); + data = "PX\t" + (t2 - t1) / 1E9 + "\t" + (t3 - t2) / 1E9 + "\t"; + tInit = t2-t1; + } + + public void test(int pathSize, int filterSize) + throws MissingObjectException, IncorrectObjectTypeException, + IOException { + setup(pathSize, filterSize, null); + data += pathSize + "\t" + filterSize + "\t"; + long t1 = System.nanoTime(); + TreeWalk tw = new TreeWalk((ObjectReader) null); + tw.reset(); + tw.addTree(new DirCacheIterator(dc)); + tw.setFilter(pf); + tw.setRecursive(true); + int n = 0; + while (tw.next()) + n++; + long t2 = System.nanoTime(); + data += (t2 - t1) / 1E9; + System.out.println(data); + assertEquals(filterSize, n); + } + + @SuppressWarnings("boxing") + public void test(int pathSize, int expectedWalkCount, String... filters) + throws MissingObjectException, IncorrectObjectTypeException, + IOException { + setup(pathSize, -1, filters); + data += pathSize + "\t" + filters.length + "\t"; + long t1 = System.nanoTime(); + TreeWalk tw = new TreeWalk((ObjectReader) null); + tw.reset(); + tw.addTree(new DirCacheIterator(dc)); + tw.setFilter(pf); + tw.setRecursive(true); + int n = 0; + while (tw.next()) + n++; + long t2 = System.nanoTime(); + data += (t2 - t1) / 1E9; + System.out.println(data); + assertEquals(expectedWalkCount, n); + + // Walk time should be (much) faster then setup time + assertThat(t2 - t1, lessThan(tInit / 2)); + } + + @Test + public void test1_1() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(1, 1); + } + + @Test + public void test2_2() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(2, 2); + } + + @Test + public void test10_10() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(10, 10); + } + + @Test + public void test100_100() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100, 100); + } + + @Test + public void test1000_1000() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(1000, 1000); + } + + @Test + public void test10000_10000() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(10000, 10000); + } + + @Test + public void test100000_100000() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 100000); + } + + @Test + public void test100000_10000() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 10000); + } + + @Test + public void test100000_1000() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 1000); + } + + @Test + public void test100000_100() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 100); + } + + @Test + public void test100000_10() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 10); + } + + @Test + public void test100000_1() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 1); + } + + @Test + public void test10000_1F() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 10000, "abc"); + } + + @Test + public void test10000_L2() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 20000, "abc", "def"); + } + + @Test + public void test10000_L10() throws MissingObjectException, + IncorrectObjectTypeException, IOException { + test(100000, 10000, "\u00e5\u00e4\u00f6"); + } +} |