What does this report?
<http://java.sun.com/j2se/1.5.0/docs/api/java/io/File.html#listRoots()>

Once saw this FileSystemModel
<http://geosoft.no/software/filesystem/FileSystemModel.java.html>,
but I improved it, to traverse filesystem nodes correctly (I hope) and
show OS icons for each file and folder.

import java.awt.Component;
import java.io.File;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.filechooser.FileSystemView;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

public class FileSystemTreeModel implements TreeModel {

   public static void main(String[] args) {
      FileSystemTreeModel model = new FileSystemTreeModel();
      JTree tree = new JTree(model);
      tree.setCellRenderer(new FileSystemTreeRenderer(model.fsv));
      tree.setRootVisible(false);
      tree.setShowsRootHandles(true);
      JFrame app = new JFrame();
      app.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
      app.getContentPane().add(new JScrollPane(tree));
      app.setSize(300, 500);
      app.setLocationRelativeTo(null); // center on screen
      app.setVisible(true);
   }

   private final Object fakeRoot = new Object();

   private FileSystemView fsv;

   private boolean hiddenVisible;

   private HashMap lastModifiedTimes;

   private Collection listeners;

   private File[] roots;

   private Comparator sortComparator = new Comparator() {

      public int compare(File a, File b) {
         Collator collator = Collator.getInstance();

         if (a.isDirectory() && b.isFile())
            return -1;
         else if (a.isFile() && b.isDirectory())
            return +1;

         int result = collator.compare(a.getName(), b.getName());
         if (result != 0)
            return result;

         result = collator.compare(a.getAbsolutePath(),
               b.getAbsolutePath());
         return result;
      }

      public int compare(Object a, Object b) {
         return compare((File) a, (File) b);
      }
   };

   private HashMap sortedChildren;

   public FileSystemTreeModel() {
      this(FileSystemView.getFileSystemView());
   }

   public FileSystemTreeModel(FileSystemView fsv) {
      this(fsv, fsv.getRoots());
   }

   public FileSystemTreeModel(FileSystemView fsv, File[] roots) {
      this.fsv = fsv;
      this.roots = roots;

      listeners = new ArrayList();
      sortedChildren = new HashMap();
      lastModifiedTimes = new HashMap();
   }

   public void addTreeModelListener(TreeModelListener listener) {
      if (listener != null && !listeners.contains(listener))
         listeners.add(listener);
   }

   public void fireTreeNodesChanged(TreeModelEvent event) {
      for (Iterator i = listeners.iterator(); i.hasNext();) {
         TreeModelListener listener = (TreeModelListener) i.next();
         listener.treeNodesChanged(event);
      }
   }

   public void fireTreeNodesInserted(TreeModelEvent event) {
      for (Iterator i = listeners.iterator(); i.hasNext();) {
         TreeModelListener listener = (TreeModelListener) i.next();
         listener.treeNodesInserted(event);
      }
   }

   public void fireTreeNodesRemoved(TreeModelEvent event) {
      for (Iterator i = listeners.iterator(); i.hasNext();) {
         TreeModelListener listener = (TreeModelListener) i.next();
         listener.treeNodesRemoved(event);
      }
   }

   public void fireTreeStructureChanged(TreeModelEvent event) {
      for (Iterator i = listeners.iterator(); i.hasNext();) {
         TreeModelListener listener = (TreeModelListener) i.next();
         listener.treeStructureChanged(event);
      }
   }

   public Object getChild(Object parent, int index) {
      if (parent == fakeRoot) {
         return roots[index];
      } else {
         List children = (List) sortedChildren.get(parent);
         return children == null ? null : children.get(index);
      }
   }

   public int getChildCount(Object parent) {
      if (parent == fakeRoot) {
         return roots.length;
      } else {
         File file = (File) parent;
         if (!fsv.isTraversable(file).booleanValue())
            return 0;

         File[] children = fsv.getFiles(file, !hiddenVisible);
         int nChildren = children == null ? 0 : children.length;

         long lastModified = file.lastModified();

         boolean isFirstTime = lastModifiedTimes.get(file) == null;
         boolean isChanged = false;

         if (!isFirstTime) {
            Long modified = (Long) lastModifiedTimes.get(file);
            long diff = Math.abs(modified.longValue() - lastModified);

            // MS/Win or Samba HACK. Check this!
            isChanged = diff > 4000;
         }

         // Sort and register children info
         if (isFirstTime || isChanged) {
            lastModifiedTimes.put(file, new Long(lastModified));

            TreeSet sorted = new TreeSet(sortComparator);
            for (int i = 0; i < nChildren; i++) {
               sorted.add(children[i]);
            }

            sortedChildren.put(file, new ArrayList(sorted));
         }

         // Notify listeners (visual tree typically) if changes
         if (isChanged) {
            TreeModelEvent event = new TreeModelEvent(this,
                getTreePath(file));
            fireTreeStructureChanged(event);
         }

         return nChildren;
      }
   }

   public int getIndexOfChild(Object parent, Object child) {
      List children = (List) sortedChildren.get(parent);
      return children.indexOf(child);
   }

   public Object getRoot() {
      return fakeRoot;
   }

   private Object[] getTreePath(Object obj) {
      List path = new ArrayList();
      while (obj != fakeRoot) {
         path.add(obj);
         obj = fsv.getParentDirectory((File) obj);
      }

      path.add(fakeRoot);

      int nElements = path.size();
      Object[] treePath = new Object[nElements];

      for (int i = 0; i < nElements; i++) {
         treePath[i] = path.get(nElements - i - 1);
      }

      return treePath;
   }

   public boolean isLeaf(Object node) {
      if (node == fakeRoot)
         return false;
      else
         return !fsv.isTraversable((File) node).booleanValue();
   }

   public void removeTreeModelListener(TreeModelListener listener) {
      if (listener != null)
         listeners.remove(listener);
   }

   public void valueForPathChanged(TreePath path, Object newValue) {
   }
}

class FileSystemTreeRenderer extends DefaultTreeCellRenderer {
   private FileSystemView fsv;

   public FileSystemTreeRenderer() {
      this(FileSystemView.getFileSystemView());
   }

   public FileSystemTreeRenderer(FileSystemView fsv) {
      this.fsv = fsv;
   }

   public Component getTreeCellRendererComponent(JTree tree,
         Object value, boolean sel, boolean expanded, boolean leaf,
          int row, boolean hasFocus) {
      if (!(value instanceof File)) {
         return super.getTreeCellRendererComponent(tree,
               value, sel, expanded, leaf, row, hasFocus);
      }

      super.getTreeCellRendererComponent(tree,
            value, sel, expanded, leaf, row, hasFocus);

      setText(fsv.getSystemDisplayName((File) value));
      setIcon(fsv.getSystemIcon((File) value));

      return this;
   }
}

Listing Desktop as the only root is correct behavior.  That's the way
the Windows logical filesystem looks.  The problem is that you're only
getting back 'test' as a child of that root.

Can you post the code you are using for doing this?  Something makes me
suspect that you're getting the children of that directory using
File.listFiles instead of using FileSystemView.getFiles.  That would
have exactly the effect you describe.  Remember that when you're using
the logical filesystem a la FileSystemView, you have to stick with it.  
The physical filesystem looks different, and in the physical filesystem,
'test' IS the only child of 'Desktop'.

I'm using FileSystemView#getRoots() without modifications,
and with the Windows file system view I get the tree you want.
See the directory chooser in JDiskReport; it has Desktop as
root and the tree expanded.

To actually see this in JDiskReport, make sure you have
the Windows Look&Feel activated in the tool's preferences.

You can download the tool from
http://www.jgoodies.com/freeware/jdiskreport/
Then click "Analyse a fire tree" in the launch screen.

Regards,
Karsten