private TFileSystemProvider(final String scheme, final URI root) { assert null != scheme; this.scheme = scheme; this.root = FsPath.create(root); }
/** * Constructs a new {@code TFile} instance from the given {@code uri}. * This constructor is equivalent to * <code>new {@link #TFile(FsPath, TArchiveDetector) TFile(FsPath.create(uri, CANONICALIZE), null))}</code>, * * @param uri an absolute URI which has a scheme component which is * known by the * {@linkplain TConfig#getArchiveDetector default archive detector}. * @throws IllegalArgumentException if the given URI does not conform to * the syntax constraints for {@link FsPath}s or * {@link File#File(URI)}. * @see #toURI() * @see #TFile(FsPath) */ public TFile(URI uri) { this(FsPath.create(uri, CANONICALIZE), null); }
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { parse( FsPath.create((URI) in.readObject(), CANONICALIZE), TConfig.get().getArchiveDetector()); }
@Test public void testPathConstructor() { for (final String[] params : new String[][] { { "mok2:mok1:file:/foo.mok1!/bar.mok2!/META-INF/MANIFEST.MF", "/foo.mok1/bar.mok2/META-INF/MANIFEST.MF", "/foo.mok1/bar.mok2", "/foo.mok1/bar.mok2", "META-INF/MANIFEST.MF", }, { "mok2:mok1:file:/foo.mok1!/bar.mok2!/", "/foo.mok1/bar.mok2", "/foo.mok1/bar.mok2", "/foo.mok1", "bar.mok2", }, { "mok1:file:/foo.mok1!/META-INF/MANIFEST.MF", "/foo.mok1/META-INF/MANIFEST.MF", "/foo.mok1", "/foo.mok1", "META-INF/MANIFEST.MF", }, { "mok1:file:/foo.mok1!/", "/foo.mok1", "/foo.mok1", null, null, }, { "mok2:file:/foo.mok2!/META-INF/MANIFEST.MF", "/foo.mok2/META-INF/MANIFEST.MF", "/foo.mok2", "/foo.mok2", "META-INF/MANIFEST.MF", }, { "mok2:file:/foo.mok2!/", "/foo.mok2", "/foo.mok2", null, null, }, { "file:/foo", "/foo", null, null, null, }, { "file:/", "/", null, null, null, }, }) { assertPathConstructor( new TFile(FsPath.create(URI.create(params[0]))), params); assertPathConstructor( new TFile(FsPath.create(URI.create(params[0])), null), params); } }
private static void assertConstructorWithStrings(Object... params) { final String first = params[0].toString(); final String[] more = (String[]) params[1]; final String name = params[2].toString(); final FsPath address = FsPath.create(URI.create(params[3].toString())); final TPath path = new TPath(first, more); assertThat(path.toString(), equalTo(name.replace(SEPARATOR, path.getFileSystem().getSeparator()))); assertThat(path.getMountPoint(), equalTo(address.getMountPoint())); assertThat(path.getEntryName(), equalTo(address.getEntryName())); }
@Test public void testHierarchicalize() { for (final String[] params : new String[][] { { "foo:bar:baz:/x/bö%20m?plö%20k!/bä%20g?zö%20k!/", "baz:/x/bö%20m/bä%20g?zö%20k" }, { "bar:baz:/x/bö%20m?plö%20k!/bä%20g?zö%20k", "baz:/x/bö%20m/bä%20g?zö%20k" }, { "foo:bar:baz:/x/bööm?plönk!/bäng?zönk!/", "baz:/x/bööm/bäng?zönk" }, { "bar:baz:/x/bööm?plönk!/bäng?zönk", "baz:/x/bööm/bäng?zönk" }, { "foo:bar:baz:/boom?plonk!/bang?zonk!/", "baz:/boom/bang?zonk" }, { "bar:baz:/boom?plonk!/bang?zonk", "baz:/boom/bang?zonk" }, { "bar:baz:/boom?plonk!/?zonk", "baz:/boom/?zonk" }, { "bar:baz:/boom?plonk!/bang", "baz:/boom/bang" }, { "bar:baz:/boom?plonk!/", "baz:/boom?plonk" }, { "foo:bar:baz:/boom!/bang!/", "baz:/boom/bang" }, { "bar:baz:/boom!/bang", "baz:/boom/bang" }, { "foo:bar:/baz?boom!/", "bar:/baz?boom" }, { "bar:/baz?boom", "bar:/baz?boom" }, { "foo:bar:/baz!/", "bar:/baz" }, { "bar:/baz", "bar:/baz" }, { "foo:/bar/?boom", "foo:/bar/?boom" }, { "bar?boom", "bar?boom" }, { "foo:/bar/", "foo:/bar/" }, { "bar", "bar" }, }) { final FsPath path = FsPath.create(URI.create(params[0])); final URI hierarchical = path.toHierarchicalUri(); assertThat(hierarchical, equalTo(URI.create(params[1]))); } } }
private static void assertResolveSibling(Object... params) { final TPath parent = new TPath(params[0].toString()); final String first = params[1].toString(); final String name = params[2].toString(); final FsPath address = FsPath.create(URI.create(params[3].toString())); final TPath member = new TPath(first); final TPath path = parent.resolveSibling(member); assertThat(path.toString(), equalTo(name.replace(SEPARATOR, path.getFileSystem().getSeparator()))); assertThat(path.getMountPoint(), equalTo(address.getMountPoint())); assertThat(path.getEntryName(), equalTo(address.getEntryName())); }
private static void assertResolve(Object... params) { final TPath parent = new TPath(params[0].toString()); final String first = params[1].toString(); final String name = params[2].toString(); final FsPath address = FsPath.create(URI.create(params[3].toString())); final TPath member = new TPath(first); final TPath path = parent.resolve(member); assertThat(path.toString(), equalTo(name.replace(SEPARATOR, path.getFileSystem().getSeparator()))); assertThat(path.getMountPoint(), equalTo(address.getMountPoint())); assertThat(path.getEntryName(), equalTo(address.getEntryName())); }
private void assertPath(final FsPath path, final FsMountPoint mountPoint, final FsEntryName entryName) { if (null != mountPoint) assertThat(path.getMountPoint(), equalTo(mountPoint)); else assertThat(path.getMountPoint(), nullValue()); assertThat(path.getEntryName(), equalTo(entryName)); assertThat(path.toString(), equalTo(path.toUri().toString())); assertThat(FsPath.create(path.toUri()), equalTo(path)); assertThat(FsPath.create(path.toUri()).hashCode(), equalTo(path.hashCode())); }
@Test public void testSpaces() { for (final String[] params : new String[][] { { "foo:bar:baz:/%20!/%20/%20!/%20/%20", " ", " / ", " / ", }, { "foo:bar:baz:/%20a%20!/%20b%20!/%20c%20", " a ", " b ", " c ", }, }) { FsPath path = FsPath.create(URI.create(params[0])); for (int i = params.length; 0 < --i; ) { assertThat(path.getEntryName().getPath(), equalTo(params[i])); path = path.getMountPoint().getPath(); } } }
@Test public void testHierarchicalize() { for (final String[] params : new String[][] { { "foo:bar:baz:/x/bö%20m?plö%20k!/bä%20g?zö%20k!/", "baz:/x/bö%20m/bä%20g?zö%20k" }, { "foo:bar:baz:/x/bööm?plönk!/bäng?zönk!/", "baz:/x/bööm/bäng?zönk" }, { "foo:bar:baz:/boom?plonk!/bang?zonk!/", "baz:/boom/bang?zonk" }, { "foo:bar:baz:/boom!/bang!/", "baz:/boom/bang" }, { "foo:bar:/baz?boom!/", "bar:/baz?boom" }, { "foo:bar:/baz!/", "bar:/baz" }, { "foo:/bar/", "foo:/bar/" }, }) { final FsMountPoint mp = FsMountPoint.create(URI.create(params[0])); final URI hmp = mp.toHierarchicalUri(); final FsPath p = FsPath.create(URI.create(params[0])); final URI hp = p.toHierarchicalUri(); assertThat(hmp, equalTo(URI.create(params[1]))); assertThat(hmp, equalTo(hp)); } } }
/** * Tests issue #TRUEZIP-154. * * @see <a href="http://java.net/jira/browse/TRUEZIP-154">ServiceConfigurationError: Unknown file system scheme for path without a suffix</a> */ @Test public void testIssue154() { for (String param : new String[] { "mok:file:/foo!/", "mok:mok:file:/foo!/bar!/", }) { FsPath path = FsPath.create(URI.create(param)); try { assertIssue154(new TFile(path)); assertIssue154(new TFile(path.toUri())); } catch (ServiceConfigurationError error) { throw new AssertionError(param, error); } } }
{ "", }, }) { final FsPath original = FsPath.create(URI.create(params[0])); assertThat(original.toString(), equalTo(params[0]));
@Test public void testResolve() { for (final String[] params : new String[][] { { "foo:bar:/baz?plonk!/", "", "baz", "foo:bar:/baz?plonk!/" }, { "foo:bar:/bäz?bööm!/", "bäng?plönk", "bäz/bäng?plönk", "foo:bar:/bäz?bööm!/bäng?plönk" }, { "foo:bar:/baz!/", "bang?boom", "baz/bang?boom", "foo:bar:/baz!/bang?boom" }, { "foo:bar:/baz!/", "bang", "baz/bang", "foo:bar:/baz!/bang" }, { "foo:bar:/baz!/", "", "baz", "foo:bar:/baz!/" }, { "foo:bar:/baz?plonk!/", "bang?boom", "baz/bang?boom", "foo:bar:/baz?plonk!/bang?boom" }, { "foo:bar:/baz?plonk!/", "bang", "baz/bang", "foo:bar:/baz?plonk!/bang" }, { "foo:/bar/", "baz?bang", null, "foo:/bar/baz?bang" }, { "foo:/bar/", "baz", null, "foo:/bar/baz" }, { "foo:/bar/", "", null, "foo:/bar/" }, { "foo:/bar/", "baz", null, "foo:/bar/baz" }, }) { final FsMountPoint mountPoint = FsMountPoint.create(URI.create(params[0])); final FsEntryName entryName = FsEntryName.create(URI.create(params[1])); final FsEntryName parentEntryName = null == params[2] ? null : FsEntryName.create(URI.create(params[2])); final FsPath path = FsPath.create(URI.create(params[3])); if (null != parentEntryName) assertThat(mountPoint.getPath().resolve(entryName).getEntryName(), equalTo(parentEntryName)); assertThat(mountPoint.resolve(entryName), equalTo(path)); assertThat(mountPoint.resolve(entryName).toUri().isAbsolute(), is(true)); } }
{ "C%3A/", null, "C%3A" }, }) { FsPath path = FsPath.create(URI.create(params[0]), CANONICALIZE); final FsMountPoint mountPoint = null == params[1] ? null : FsMountPoint.create(URI.create(params[1])); final FsEntryName entryName = FsEntryName.create(URI.create(params[2]));
FsPath srcPath = FsPath.create(srcUri, FsUriModifier.CANONICALIZE); InputSocket<?> srcSocket = manager .getController( srcPath.getMountPoint(), driver) FsPath dstPath = FsPath.create(dstUri, FsUriModifier.CANONICALIZE); OutputSocket<?> dstSocket = manager .getController( dstPath.getMountPoint(), driver)
FsPath path = FsPath.create(uri, FsUriModifier.CANONICALIZE); InputSocket<?> socket = manager .getController( path.getMountPoint(), driver)
final FsEntryName entryName = FsEntryName.create(URI.create(params[2])); final FsEntryName parentEntryName = FsEntryName.create(URI.create(params[3])); final FsPath path = FsPath.create(URI.create(params[4])); FsModel parent = newModel(parentMountPoint); FsModel model = newModel(mountPoint, parent);
final FsMountPoint mountPoint = FsMountPoint.create(URI.create(params[0]), FsUriModifier.CANONICALIZE); final FsScheme scheme = FsScheme.create(params[1]); final FsPath path = FsPath.create(URI.create(params[2]));
@Test public void testUriAndFsPathConversion() { for (final String[] params : new String[][] { { "/file", "file:/file" }, { "/archive.mok", "mok:file:/archive.mok!/" }, { "/archive.mok/entry", "mok:file:/archive.mok!/entry" }, { "/foo.mok1/bar.mok2", "mok2:mok1:file:/foo.mok1!/bar.mok2!/" }, { "/dist.mok1/app.mok2/META-INF/MANIFEST.MF", "mok2:mok1:file:/dist.mok1!/app.mok2!/META-INF/MANIFEST.MF" }, }) { final String name = params[0]; final URI uri = URI.create(params[1]); final FsPath path = FsPath.create(URI.create(params[1])); final TFile file = new TFile(name); assertThat(new TFile(name), equalTo(file)); assertThat(new TFile(uri), equalTo(file)); assertThat(new TFile(path), equalTo(file)); assertThat(new TFile(name).toURI(), equalTo(file.toURI())); assertThat(new TFile(uri).toURI(), equalTo(file.toURI())); assertThat(new TFile(path).toURI(), equalTo(file.toURI())); assertThat(new TFile(name).toFsPath(), equalTo(file.toFsPath())); assertThat(new TFile(uri).toFsPath(), equalTo(file.toFsPath())); assertThat(new TFile(path).toFsPath(), equalTo(file.toFsPath())); assertThat(new TFile(new TFile(name).toURI()), equalTo(file.getAbsoluteFile())); assertThat(new TFile(new TFile(uri).toURI()), equalTo(file.getAbsoluteFile())); assertThat(new TFile(new TFile(path).toURI()), equalTo(file.getAbsoluteFile())); assertThat(new TFile(new TFile(name).toFsPath()), equalTo(file.getAbsoluteFile())); assertThat(new TFile(new TFile(uri).toFsPath()), equalTo(file.getAbsoluteFile())); assertThat(new TFile(new TFile(path).toFsPath()), equalTo(file.getAbsoluteFile())); } }