Changeset 15408


Ignore:
Timestamp:
10/14/20 07:07:14 (2 years ago)
Author:
Mark Evenson
Message:

Refactor pathname java hierarchy to reflect lisp hierarchy

JarPathname? instead of PathnameJar?, usw. correcting for my dyslexia.

Location:
trunk/abcl
Files:
4 added
4 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/JavaClassLoader.java

    r15400 r15408  
    338338            LispObject list = NIL;
    339339            for(URL u : ((URLClassLoader) o).getURLs()) {
    340                 list = list.push(PathnameURL.create(u));
     340                list = list.push(URLPathname.create(u));
    341341            }
    342342            return new Cons(new JavaObject(o), list.nreverse());
  • trunk/abcl/src/org/armedbear/lisp/Load.java

    r15406 r15408  
    171171
    172172        if (ZipCache.checkZipFile(truename)) {
    173           if (truename instanceof PathnameJar) {
    174             truename = PathnameJar.createFromEntry((PathnameJar)truename);
     173          if (truename instanceof JarPathname) {
     174            truename = JarPathname.createFromEntry((JarPathname)truename);
    175175          } else {
    176             truename = PathnameJar.createFromPathname(truename);
     176            truename = JarPathname.createFromPathname(truename);
    177177          }
    178178          Pathname loader = Pathname.create("__loader__._"); // FIXME use constants
     
    323323            }               
    324324            if (!bootPath.equals(NIL)) {
    325               Pathname urlPathname = (Pathname)PathnameURL.create(url);
     325              Pathname urlPathname = (Pathname)URLPathname.create(url);
    326326              loadableFile = findLoadableFile(urlPathname);
    327327              truename = (Pathname)Symbol.PROBE_FILE.execute(loadableFile);
  • trunk/abcl/src/org/armedbear/lisp/Pathname.java

    r15406 r15408  
    5454
    5555  protected static Pathname create(Pathname p) {
    56     if (p instanceof PathnameJar) {
    57       return (PathnameJar)PathnameJar.create(p.getNamestring());
    58     } else if (p instanceof PathnameURL) {
    59       return (PathnameURL)PathnameURL.create(((PathnameURL)p).getNamestringAsURI());
     56    if (p instanceof JarPathname) {
     57      return (JarPathname)JarPathname.create(p.getNamestring());
     58    } else if (p instanceof URLPathname) {
     59      return (URLPathname)URLPathname.create(((URLPathname)p).getNamestringAsURI());
    6060    } else {
    6161      return new Pathname(p);
     
    6767    // which we can meaningfully parse.
    6868
    69     if (s.startsWith(PathnameJar.JAR_URI_PREFIX)) {
    70         return PathnameJar.create(s);
     69    if (s.startsWith(JarPathname.JAR_URI_PREFIX)) {
     70        return JarPathname.create(s);
    7171    }
    7272    if (isValidURL(s)) {
    73       return PathnameURL.create(s);
     73      return URLPathname.create(s);
    7474    } else {
    7575      if (LogicalPathname.isValidLogicalPathname(s)) {
     
    187187              LispObject jars = p.getDevice();
    188188              setDevice(NIL);
    189               PathnameURL root = PathnameURL.create((Pathname)jars.car());
     189              URLPathname root = URLPathname.create((Pathname)jars.car());
    190190              device = device.push(root);
    191191              jars = jars.cdr();
     
    318318       
    319319        // A JAR file
    320         if (s.startsWith(PathnameJar.JAR_URI_PREFIX)
    321             && s.endsWith(PathnameJar.JAR_URI_SUFFIX)) {
    322           return (PathnameJar)PathnameJar.create(s);
     320        if (s.startsWith(JarPathname.JAR_URI_PREFIX)
     321            && s.endsWith(JarPathname.JAR_URI_SUFFIX)) {
     322          return (JarPathname)JarPathname.create(s);
    323323        }
    324324
    325325        // An entry in a JAR file
    326         final int separatorIndex = s.lastIndexOf(PathnameJar.JAR_URI_SUFFIX);
    327         if (separatorIndex > 0 && s.startsWith(PathnameJar.JAR_URI_PREFIX)) {
    328           return (PathnameJar)PathnameJar.create(s);
     326        final int separatorIndex = s.lastIndexOf(JarPathname.JAR_URI_SUFFIX);
     327        if (separatorIndex > 0 && s.startsWith(JarPathname.JAR_URI_PREFIX)) {
     328          return (JarPathname)JarPathname.create(s);
    329329        }
    330330
     
    332332        // pathname, and not a JAR file or an entry in a JAR file)
    333333        if (isValidURL(s)) {
    334           return (PathnameURL)PathnameURL.create(s);
     334          return (URLPathname)URLPathname.create(s);
    335335        }
    336336
     
    507507                             || isURL());
    508508            if (isURL()) {
    509                 LispObject scheme = Symbol.GETF.execute(getHost(), PathnameURL.SCHEME, NIL);
    510                 LispObject authority = Symbol.GETF.execute(getHost(), PathnameURL.AUTHORITY, NIL);
     509                LispObject scheme = Symbol.GETF.execute(getHost(), URLPathname.SCHEME, NIL);
     510                LispObject authority = Symbol.GETF.execute(getHost(), URLPathname.AUTHORITY, NIL);
    511511                Debug.assertTrue(scheme != NIL);
    512512                sb.append(scheme.getStringValue());
     
    12261226        p.validateDirectory(true);
    12271227
    1228         // ???  need to check for downcast to PathnameURL as well?
    1229         // Possibly downcast type to PathnameJar
     1228        // ???  need to check for downcast to URLPathname as well?
     1229        // Possibly downcast type to JarPathname
    12301230        if (p.getDevice() instanceof Cons) {
    1231           PathnameJar result = new PathnameJar();
     1231          JarPathname result = new JarPathname();
    12321232          result
    12331233            .copyFrom(p)
    1234             .setDevice(PathnameJar.makeJarDeviceFrom(p));
     1234            .setDevice(JarPathname.makeJarDeviceFrom(p));
    12351235         
    12361236          // sanity check that the pathname has been constructed correctly
     
    13751375          LispObject result = NIL;
    13761376          if (pathname.isJar()) {
    1377             return PathnameJar.listDirectory((PathnameJar)pathname);
     1377            return JarPathname.listDirectory((JarPathname)pathname);
    13781378          }
    13791379
     
    16321632      d = Pathname.create(defaultPathname);
    16331633    } else {
    1634       if (pathname instanceof PathnameJar
     1634      if (pathname instanceof JarPathname
    16351635          // If the defaults contain a JAR-PATHNAME, and the pathname
    16361636          // to be be merged is not a JAR-PATHNAME, does not have a
    16371637          // specified DEVICE or a specified HOST and has a NIL or
    16381638          // relative directory then the result will be a JAR-PATHNAME.
    1639           || (defaultPathname instanceof PathnameJar
    1640               && !(pathname instanceof PathnameJar)
     1639          || (defaultPathname instanceof JarPathname
     1640              && !(pathname instanceof JarPathname)
    16411641              && pathname.getHost().equals(NIL)
    16421642              && pathname.getDevice().equals(NIL)
    16431643              && (pathname.getDirectory().equals(NIL)
    16441644                  || pathname.getDirectory().car().equals(Keyword.RELATIVE)))) {
    1645         result = PathnameJar.create();
    1646       } else if (pathname instanceof PathnameURL) {
    1647         result = PathnameURL.create();
     1645        result = JarPathname.create();
     1646      } else if (pathname instanceof URLPathname) {
     1647        result = URLPathname.create();
    16481648      } else {
    16491649        result = Pathname.create();
     
    16531653        d = LogicalPathname.translateLogicalPathname((LogicalPathname) defaultPathname);
    16541654      } else {
    1655         if (defaultPathname instanceof PathnameJar) {
    1656           d = PathnameJar.create((PathnameJar)defaultPathname);
    1657         } else if (defaultPathname instanceof PathnameURL) {
    1658           d = PathnameURL.create(defaultPathname);
     1655        if (defaultPathname instanceof JarPathname) {
     1656          d = JarPathname.create((JarPathname)defaultPathname);
     1657        } else if (defaultPathname instanceof URLPathname) {
     1658          d = URLPathname.create(defaultPathname);
    16591659        } else {
    16601660          d = Pathname.create(defaultPathname);
     
    16731673          result.setDevice(p.getDevice());
    16741674        } else {
    1675           if (d instanceof PathnameJar
    1676         && p instanceof PathnameJar) {
     1675          if (d instanceof JarPathname
     1676        && p instanceof JarPathname) {
    16771677            result.setDevice(d.getDevice());
    16781678          } else {
     
    16861686        // relative DIRECTORY, then on non-MSDOG, set its device to
    16871687        // :UNSPECIFIC.
    1688         if ((d instanceof PathnameJar)
    1689             && !(result instanceof PathnameJar)) {
     1688        if ((d instanceof JarPathname)
     1689            && !(result instanceof JarPathname)) {
    16901690          if (!Utilities.isPlatformWindows) {
    16911691            result.setDevice(Keyword.UNSPECIFIC);
     
    17011701      // default directory. 
    17021702      // if (pathname.isJar()) {
    1703       //   Pathname root = ((PathnameJar)result).getRootJar();
     1703      //   Pathname root = ((JarPathname)result).getRootJar();
    17041704       
    17051705
     
    21342134  public boolean isLocalFile() {
    21352135    if (getHost().equals(NIL)
    2136         || Symbol.GETF.execute(getHost(), PathnameURL.SCHEME, NIL).equals("file")) {
     2136        || Symbol.GETF.execute(getHost(), URLPathname.SCHEME, NIL).equals("file")) {
    21372137      return true;
    21382138    }
     
    21692169
    21702170  boolean isRemote() {
    2171     if (this instanceof PathnameURL) {
    2172       PathnameURL p = (PathnameURL) this;
    2173       LispObject scheme = Symbol.GETF.execute(p.getHost(), PathnameURL.SCHEME, NIL);
     2171    if (this instanceof URLPathname) {
     2172      URLPathname p = (URLPathname) this;
     2173      LispObject scheme = Symbol.GETF.execute(p.getHost(), URLPathname.SCHEME, NIL);
    21742174      if (scheme.equals(NIL)
    21752175          || p.getHost().getStringValue().equals("file")) {
     
    21772177      }
    21782178      return true;
    2179     } else if (this instanceof PathnameJar) {
    2180       Pathname root = (Pathname) ((PathnameJar)this).getRootJar();
     2179    } else if (this instanceof JarPathname) {
     2180      Pathname root = (Pathname) ((JarPathname)this).getRootJar();
    21812181      return root.isRemote();
    21822182    } else {
  • trunk/abcl/src/org/armedbear/lisp/Site.java

    r15400 r15408  
    5858                LISP_HOME = NIL;
    5959            } else {
    60               Pathname p = (Pathname)PathnameURL.create(url);
     60              Pathname p = (Pathname)URLPathname.create(url);
    6161              p.setName(NIL).setType(NIL);
    6262              LISP_HOME = p;
  • trunk/abcl/src/org/armedbear/lisp/ZipCache.java

    r15406 r15408  
    165165  }
    166166
    167   public static InputStream getEntryAsInputStream(PathnameJar archiveEntry) {
    168     PathnameJar archiveJar = archiveEntry.getArchive();
     167  public static InputStream getEntryAsInputStream(JarPathname archiveEntry) {
     168    JarPathname archiveJar = archiveEntry.getArchive();
    169169    Archive archive = ZipCache.getArchive(archiveJar);
    170170    InputStream result = archive.getEntryAsInputStream(archiveEntry);
     
    182182  // ZipFile via a CachedZipFile does not work because there is not
    183183  // a null arg constructor for ZipFile.
    184   static HashMap<PathnameJar, Archive> cache = new HashMap<PathnameJar, Archive>();
     184  static HashMap<JarPathname, Archive> cache = new HashMap<JarPathname, Archive>();
    185185
    186186  abstract static public class Archive {
    187     PathnameJar root;
    188     LinkedHashMap<PathnameJar, ZipEntry> entries
    189       = new LinkedHashMap<PathnameJar, ZipEntry>();
     187    JarPathname root;
     188    LinkedHashMap<JarPathname, ZipEntry> entries
     189      = new LinkedHashMap<JarPathname, ZipEntry>();
    190190    long lastModified;
    191191
    192     abstract InputStream getEntryAsInputStream(PathnameJar entry);
    193     abstract ZipEntry getEntry(PathnameJar entry);
     192    abstract InputStream getEntryAsInputStream(JarPathname entry);
     193    abstract ZipEntry getEntry(JarPathname entry);
    194194    abstract void populateAllEntries();
    195195    abstract void close();
     
    202202
    203203    // TODO wrap in a weak reference to allow JVM to possibly reclaim memory
    204     LinkedHashMap<PathnameJar, ByteArrayOutputStream> contents
    205       = new LinkedHashMap<PathnameJar, ByteArrayOutputStream>();
    206 
    207     public InputStream getEntryAsInputStream(PathnameJar entry) {
     204    LinkedHashMap<JarPathname, ByteArrayOutputStream> contents
     205      = new LinkedHashMap<JarPathname, ByteArrayOutputStream>();
     206
     207    public InputStream getEntryAsInputStream(JarPathname entry) {
    208208      ByteArrayOutputStream bytes = contents.get(entry);
    209209      if (bytes != null) {
     
    215215    boolean populated = false;
    216216
    217     public ZipEntry getEntry(PathnameJar entry) {
     217    public ZipEntry getEntry(JarPathname entry) {
    218218      if (!populated) {
    219219        populateAllEntries();
     
    231231        while ((entry = source.getNextEntry()) != null) {
    232232          String name = entry.getName();
    233           PathnameJar entryPathname
    234             = (PathnameJar)PathnameJar.createEntryFromJar(root, name);
     233          JarPathname entryPathname
     234            = (JarPathname)JarPathname.createEntryFromJar(root, name);
    235235          entries.put(entryPathname, entry);
    236236          ByteArrayOutputStream bytes
     
    260260    JarURLConnection connection;
    261261
    262     public ArchiveURL(PathnameJar jar)
     262    public ArchiveURL(JarPathname jar)
    263263      throws java.io.IOException
    264264    {
     
    289289    ArchiveFile() {}
    290290
    291     public ArchiveFile(PathnameJar jar)
     291    public ArchiveFile(JarPathname jar)
    292292      throws ZipException, IOException
    293293    {
     
    298298    }
    299299
    300     public ZipEntry getEntry(PathnameJar entryPathname) {
     300    public ZipEntry getEntry(JarPathname entryPathname) {
    301301      ZipEntry result = entries.get(entryPathname);
    302302      if (result != null) {
     
    332332        ZipEntry entry = e.nextElement();
    333333        String name = entry.getName();
    334         PathnameJar entryPathname
    335           = (PathnameJar)PathnameJar.createEntryFromJar(root, name);
     334        JarPathname entryPathname
     335          = (JarPathname)JarPathname.createEntryFromJar(root, name);
    336336        entries.put(entryPathname, entry);
    337337      }
    338338    }
    339339
    340     InputStream getEntryAsInputStream(PathnameJar entry) {
     340    InputStream getEntryAsInputStream(JarPathname entry) {
    341341      InputStream result = null;
    342342      ZipEntry zipEntry = getEntry(entry);
     
    376376  }
    377377
    378   synchronized public static LinkedHashMap<PathnameJar,ZipEntry> getEntries(PathnameJar jar) {
     378  synchronized public static LinkedHashMap<JarPathname,ZipEntry> getEntries(JarPathname jar) {
    379379    Archive archive = getArchive(jar);
    380380    archive.populateAllEntries(); // Very expensive for jars with large number of entries
     
    382382  }
    383383
    384   synchronized public static Iterator<Map.Entry<PathnameJar,ZipEntry>> getEntriesIterator(PathnameJar jar) {
    385     LinkedHashMap<PathnameJar,ZipEntry> entries = getEntries(jar);
    386     Set<Map.Entry<PathnameJar,ZipEntry>> set = entries.entrySet();
     384  synchronized public static Iterator<Map.Entry<JarPathname,ZipEntry>> getEntriesIterator(JarPathname jar) {
     385    LinkedHashMap<JarPathname,ZipEntry> entries = getEntries(jar);
     386    Set<Map.Entry<JarPathname,ZipEntry>> set = entries.entrySet();
    387387    return set.iterator();
    388388  }
    389389
    390   static ZipEntry getZipEntry(PathnameJar archiveEntry) {
    391     PathnameJar archiveJar = archiveEntry.getArchive();
     390  static ZipEntry getZipEntry(JarPathname archiveEntry) {
     391    JarPathname archiveJar = archiveEntry.getArchive();
    392392    Archive zip = getArchive(archiveJar);
    393393    ZipEntry entry = zip.getEntry(archiveEntry);
     
    396396
    397397  // ??? we assume that DIRECTORY, NAME, and TYPE components are NIL
    398   synchronized public static Archive getArchive(PathnameJar jar) {
     398  synchronized public static Archive getArchive(JarPathname jar) {
    399399    Archive result = cache.get(jar);
    400400    if (result != null) {
     
    412412      return getArchiveFile(jar);
    413413    } else {
    414       PathnameJar root = new PathnameJar();
     414      JarPathname root = new JarPathname();
    415415      root.setDevice(new Cons(rootJar, NIL));
    416416      ArchiveFile rootArchiveFile = (ArchiveFile)getArchiveFile(root);
    417417
    418       PathnameJar innerArchive = new PathnameJar();
     418      JarPathname innerArchive = new JarPathname();
    419419      Pathname nextJar = (Pathname)innerJars.car();
    420420      LispObject jars = list(rootJar, nextJar);
    421421      innerArchive.setDevice(jars);
    422422
    423       PathnameJar innerArchiveAsEntry = new PathnameJar();
     423      JarPathname innerArchiveAsEntry = new JarPathname();
    424424      innerArchiveAsEntry
    425425        .setDevice(new Cons(rootJar, NIL))
     
    453453  }
    454454
    455   public static Archive getArchiveURL(PathnameJar jar) {
     455  public static Archive getArchiveURL(JarPathname jar) {
    456456    Pathname rootJar = (Pathname) jar.getRootJar();
    457457
     
    470470  }
    471471
    472   static public Archive getArchiveFile(PathnameJar jar) {
     472  static public Archive getArchiveFile(JarPathname jar) {
    473473    try {
    474474      ArchiveFile result = new ArchiveFile(jar);
     
    528528    // Replace older item in cache
    529529    if (date == null || date.getTime() > archive.lastModified) {
    530       PathnameJar root = archive.root;
     530      JarPathname root = archive.root;
    531531      Archive entry = getArchiveURL(root);
    532532      cache.put(root, entry);
     
    553553      Pathname p = coerceToPathname(arg);
    554554      boolean result = false;
    555       if (p instanceof PathnameJar) {
    556         result = ZipCache.remove((PathnameJar)p);
     555      if (p instanceof JarPathname) {
     556        result = ZipCache.remove((JarPathname)p);
    557557      }
    558558      return result ? T : NIL;
     
    560560  }
    561561     
    562   synchronized public static boolean remove(PathnameJar p) {
     562  synchronized public static boolean remove(JarPathname p) {
    563563    Archive archive = cache.get(p.getNamestring());
    564564    if (archive != null) {
  • trunk/abcl/src/org/armedbear/lisp/delete_file.java

    r15406 r15408  
    6868      if (defaultedPathname.isRemote()) {
    6969        return error(new FileError("Unable to delete remote pathnames", defaultedPathname));
    70       } else if (defaultedPathname instanceof PathnameJar) {
    71         PathnameJar jar = (PathnameJar)defaultedPathname;
     70      } else if (defaultedPathname instanceof JarPathname) {
     71        JarPathname jar = (JarPathname)defaultedPathname;
    7272        Pathname root = (Pathname)jar.getRootJar();
    7373        Cons jars = (Cons)jar.getJars();
  • trunk/abcl/src/org/armedbear/lisp/probe_file.java

    r15406 r15408  
    6161          }
    6262          // TODO: refactor Pathname{,Jar,URL}.truename() to be non-static?
    63           if (p instanceof PathnameJar) {
    64             return PathnameJar.truename(p, false);
    65           } else if (p instanceof PathnameURL) {
    66             return PathnameURL.truename((PathnameURL)p, false);
     63          if (p instanceof JarPathname) {
     64            return JarPathname.truename(p, false);
     65          } else if (p instanceof URLPathname) {
     66            return URLPathname.truename((URLPathname)p, false);
    6767          } else {
    6868            return Pathname.truename(p, false);
     
    9090
    9191          // TODO: refactor Pathname{,Jar,URL}.truename() to be non-static?
    92           if (p instanceof PathnameJar) {
    93             return PathnameJar.truename(p, true);
    94           } else if (p instanceof PathnameURL) {
    95             return PathnameURL.truename((PathnameURL)p, true);
     92          if (p instanceof JarPathname) {
     93            return JarPathname.truename(p, true);
     94          } else if (p instanceof URLPathname) {
     95            return URLPathname.truename((URLPathname)p, true);
    9696          } else {
    9797            return Pathname.truename(p, true);
  • trunk/abcl/test/src/org/armedbear/lisp/PathnameTest.java

    r15400 r15408  
    2929        System.out.println(e.getMessage());
    3030    }
    31     Pathname pathname = (Pathname)PathnameURL.create(url);
     31    Pathname pathname = (Pathname)URLPathname.create(url);
    3232    assertNotNull(pathname);
    3333    assertNotNull(pathname.getNamestring());
     
    132132    assertTrue("Java equals() for Pathname", result);
    133133
    134     PathnameJar p3 = (PathnameJar)Pathname.create("jar:file:///abcl.jar!/tmp/");
    135     PathnameJar p4 = (PathnameJar)Pathname.create("jar:file:///abcl.jar!/tmp/");
     134    JarPathname p3 = (JarPathname)Pathname.create("jar:file:///abcl.jar!/tmp/");
     135    JarPathname p4 = (JarPathname)Pathname.create("jar:file:///abcl.jar!/tmp/");
    136136    result = p3.equals(p4);
    137137    assertTrue("Java equals() for PathnameJar", result);
  • trunk/abcl/test/src/org/armedbear/lisp/ZipTest.java

    r15405 r15408  
    2525  //   (asdf-jar:package :cl-ppcre)
    2626  String nestedJarFile = "/var/tmp/cl-ppcre-all-2.1.1.jar";
    27   PathnameJar zip;
    28   PathnameJar nestedJar;
     27  JarPathname zip;
     28  JarPathname nestedJar;
    2929
    3030  @Before
    3131  public void setup() {
    32     zip = (PathnameJar) PathnameJar.createFromFile(zipFile);
    33     nestedJar = (PathnameJar) PathnameJar.createFromFile(nestedJarFile);
     32    zip = (JarPathname) JarPathname.createFromFile(zipFile);
     33    nestedJar = (JarPathname) JarPathname.createFromFile(nestedJarFile);
    3434  }
    3535
     
    4040               archive1 instanceof ZipCache.ArchiveFile
    4141               && ((ZipCache.ArchiveFile)archive1).file != null);
    42     PathnameJar zip2
    43       = (PathnameJar) PathnameJar.createFromFile(zipFile);
     42    JarPathname zip2
     43      = (JarPathname) JarPathname.createFromFile(zipFile);
    4444    ZipCache.Archive archive2 = ZipCache.getArchive(zip2);
    4545    assertTrue("Get cached ZipArchive from pathname",
     
    5353  public void getEntry() {
    5454    String entryPath = "abcl-asdf/abcl-asdf-tests.asd";
    55     PathnameJar entryPathname
    56       = (PathnameJar) PathnameJar.createEntryFromFile(zipFile, entryPath);
     55    JarPathname entryPathname
     56      = (JarPathname) JarPathname.createEntryFromFile(zipFile, entryPath);
    5757    ZipEntry entry = ZipCache.getZipEntry(entryPathname);
    5858    assertTrue("Getting entry from jar",
    5959               entry.getName().equals(entryPath));
    60     PathnameJar entryPathname2
    61       = (PathnameJar) PathnameJar.createEntryFromFile(zipFile, entryPath);
     60    JarPathname entryPathname2
     61      = (JarPathname) JarPathname.createEntryFromFile(zipFile, entryPath);
    6262    ZipEntry entry2 = ZipCache.getZipEntry(entryPathname2);
    6363    assertTrue("Cached ZipEntry returns same object",
     
    6868  public void getNestedJar() {
    6969    String nestedNamestring = "jar:jar:file:/var/tmp/cl-ppcre-all-2.1.1.jar!/cl-ppcre/packages.abcl!/";
    70     PathnameJar nested = (PathnameJar)PathnameJar.create(nestedNamestring);
     70    JarPathname nested = (JarPathname)JarPathname.create(nestedNamestring);
    7171    ZipCache.Archive archive = ZipCache.getArchive(nested);
    7272    assertTrue("Able to retrieve nested jar archive",
Note: See TracChangeset for help on using the changeset viewer.