Example #1
0
 public static void main(String[] args) {
   LinkedList books = new LinkedList();
   // 将字符串元素加入队列的尾部
   books.offer("疯狂Java讲义");
   // 将一个字符串元素加入栈的顶部
   books.push("轻量级Java EE企业应用实战");
   // 将字符串元素添加到队列的头部(相当于栈的顶部)
   books.offerFirst("疯狂Android讲义");
   // 以List的方式(按索引访问的方式)来遍历集合元素
   for (int i = 0; i < books.size(); i++) {
     System.out.println("遍历中:" + books.get(i));
   }
   // 访问、并不删除栈顶的元素
   System.out.println(books.peekFirst());
   // 访问、并不删除队列的最后一个元素
   System.out.println(books.peekLast());
   // 将栈顶的元素弹出“栈”
   System.out.println(books.pop());
   // 下面输出将看到队列中第一个元素被删除
   System.out.println(books);
   // 访问、并删除队列的最后一个元素
   System.out.println(books.pollLast());
   // 下面输出:[轻量级Java EE企业应用实战]
   System.out.println(books);
 }
Example #2
0
    void startIdleState() {
      lock.lock();
      try {
        final Thread currentThread = Thread.currentThread();
        final Thread currentIdleThread = threadsRequestingIdle.peekFirst();
        if (currentIdleThread == currentThread) {
          assert idleStateCount > 0;
          ++idleStateCount;
          assert idleStateCount > 0;
          return;
        }

        threadsRequestingIdle.add(currentThread);

        while ((activitiyCount > 0) || (threadsRequestingIdle.getFirst() != currentThread))
          condition.awaitUninterruptibly();

        assert idleStateCount == 0;
        assert activitiyCount == 0;
        assert threadsRequestingIdle.getFirst() == currentThread;
        idleStateCount = 1;

      } finally {
        lock.unlock();
      }
    }
  /**
   * Replaces the entire stack with this fragment.
   *
   * @param args Arguments to be set on the fragment using {@link
   *     Fragment#setArguments(android.os.Bundle)}.
   */
  public void replace(Class<?> fragment, String tag, Bundle args) {
    Fragment first = stack.peekFirst();
    if (first != null && tag.equals(first.getTag())) {
      if (stack.size() > 1) {
        ensureTransaction();
        fragmentTransaction.setCustomAnimations(popStackEnterAnimation, popStackExitAnimation);
        while (stack.size() > 1) {
          removeFragment(stack.pollLast());
        }

        attachFragment(stack.peek(), tag);
      }
      return;
    }

    Fragment f = fragmentManager.findFragmentByTag(tag);
    if (f == null) {
      f = Fragment.instantiate(activity, fragment.getName(), args);
    }

    ensureTransaction();
    fragmentTransaction.setCustomAnimations(enterAnimation, exitAnimation);
    clear();
    attachFragment(f, tag);
    stack.add(f);

    topLevelTags.add(tag);
  }
Example #4
0
 public T pop() {
   if (!buf.isEmpty()) {
     T ret = buf.peekFirst();
     buf.clear();
     isBacktracking = true;
     return ret;
   }
   throw new IllegalStateException("Can't pop an empty ringbuffer");
 }
Example #5
0
 public Vertex(LinkedList<Character> entrada, ArrayList<Vertex> destiny) {
   consecutivo = destiny.size();
   destiny.add(this);
   value = entrada.pollFirst();
   if (entrada.isEmpty() || entrada.peekFirst() != '(') {
     sons = new DLL();
   } else {
     entrada.pollFirst();
     Vertex actual = new Vertex(entrada, destiny);
     actual.sons.add(this);
     sons = new DLL(actual);
     while (entrada.peekFirst() == ',') {
       entrada.pollFirst();
       actual = new Vertex(entrada, destiny);
       actual.sons.add(this);
       sons.add(actual);
     }
     entrada.pollFirst();
   }
 }
  public static void main(String a[]) {

    LinkedList<String> arrl = new LinkedList<String>();
    arrl.add("First");
    arrl.add("Second");
    arrl.add("Third");
    arrl.add("Random");
    System.out.println("First Element: " + arrl.element());
    System.out.println("First Element: " + arrl.getFirst());
    System.out.println("First Element: " + arrl.peek());
    System.out.println("First Element: " + arrl.peekFirst());
  }
  public void clear() {
    Fragment first = stack.peekFirst();
    for (Fragment f : stack) {
      if (f == first) {
        detachFragment(f);
      } else {
        removeFragment(f);
      }
    }

    stack.clear();
  }
Example #8
0
 void endAllowingFileScopeRequests() {
   lock.lock();
   try {
     final Thread currentThread = Thread.currentThread();
     final Thread currentIdleThread = threadsRequestingIdle.peekFirst();
     assert currentThread == currentIdleThread;
     assert allowFileScopeRequests;
     while (activitiyCount > 0) condition.awaitUninterruptibly();
     allowFileScopeRequests = false;
   } finally {
     lock.unlock();
   }
 }
Example #9
0
 void startAllowingFileScopeRequests() {
   lock.lock();
   try {
     final Thread currentThread = Thread.currentThread();
     final Thread currentIdleThread = threadsRequestingIdle.peekFirst();
     assert currentThread == currentIdleThread;
     assert !allowFileScopeRequests;
     allowFileScopeRequests = true;
     condition.signalAll();
   } finally {
     lock.unlock();
   }
 }
 /**
  * add
  *
  * @param historyList
  * @param maxHistoryLength max. length of history or HISTORY_LENGTH_INFINTE
  * @param direction history direction order
  * @param addEntry
  */
 private static void add(
     LinkedList<String> historyList, int maxHistoryLength, Directions direction, String addEntry) {
   switch (direction) {
     case ASCENDING:
       {
         String lastEntry = historyList.peekLast();
         if ((lastEntry == null) || !lastEntry.equals(addEntry)) {
           historyList.add(addEntry);
           while (historyList.size() > maxHistoryLength) {
             historyList.removeFirst();
           }
         }
       }
       break;
     case DESCENDING:
       {
         String firstEntry = historyList.peekFirst();
         if ((firstEntry == null) || !firstEntry.equals(addEntry)) {
           historyList.addFirst(firstEntry);
           while (historyList.size() > maxHistoryLength) {
             historyList.removeLast();
           }
         }
       }
       break;
     case SORTED:
       {
         boolean existsFlag = false;
         for (String entry : historyList) {
           if (entry.equals(addEntry)) {
             existsFlag = true;
             break;
           }
         }
         if (!existsFlag) {
           historyList.addFirst(addEntry);
           Collections.sort(
               historyList,
               new Comparator<String>() {
                 public int compare(String data0, String data1) {
                   return data0.compareTo(data1);
                 }
               });
           while (historyList.size() > maxHistoryLength) {
             historyList.removeLast();
           }
         }
       }
       break;
   }
 }
Example #11
0
 private static Map<IProjectStage, List<IProjectStageSkill>> extractStageToSkillMap(
     List<IProjectStage> stages, List<IProjectStageSkill> skillsList) {
   Map<IProjectStage, List<IProjectStageSkill>> stageToSkillListMap = Maps.newHashMap();
   LinkedList<IProjectStageSkill> skillListCopy = Lists.newLinkedList(skillsList);
   for (IProjectStage stage : stages) {
     Set<IProjectStageSkill> skillSet = stage.getProjectStageSkills();
     List<IProjectStageSkill> entryList = Lists.newLinkedList();
     while (skillSet.contains(skillListCopy.peekFirst())) {
       entryList.add(skillListCopy.pollFirst());
     }
     stageToSkillListMap.put(stage, entryList);
   }
   return stageToSkillListMap;
 }
Example #12
0
  /** 测试LinkedList以双向链表的使用方法 */
  private static void testLinkedListDeque() {

    System.out.println(
        "Test methods: addFirst(object), addLast(object), offerFirst(), offerLast(), getFirst(object), getLast(object), pollFirst(), pollLast(), peekFirst(), peekLast(), removeFirst(), removeLast()");

    // 将 “abcdefg”初始化到LinkedList中
    LinkedList<String> list = new LinkedList<String>();

    // addFirst/addLast 没有返回值、offerFirst/offerLast返回true、内部都是调用Entry.addBefore()来添加的
    list.addFirst("c");
    list.offerFirst("b");
    list.offerFirst("a");
    list.addLast("d");
    list.addLast("e");
    list.offerLast("f");
    printList(list);

    /*	相同:
     *			getFirst/getLast、peekFirst/peekLast方法都是获取第一个元素、
     *	不同:
     *			getXXX方法在list的size为0抛出异常、
     *			peekXX方法在list的size为0返回null、
     */
    printStr("list getFirst() obtains element: " + list.getFirst());
    printStr("list peekFirst() obtains element: " + list.peekFirst());
    printStr("list getLast() obtains element: " + list.getLast());
    printStr("list peekLast() obtains element: " + list.peekLast());
    printList(list);

    /*
     * 相同:
     * 			pollXXX、removeXXX都是获取第一个元素、并且将此元素从list中移除
     * 不同:
     * 			removeXXX方法在list的size为0抛出异常、
     * 			pollXXX方法在list的size为0返回null、
     */

    printStr(list.pollFirst());
    printStr(list.removeFirst());
    printList(list);

    printStr(list.pollLast());
    printStr(list.removeLast());
    printList(list);
  }
  /** Removes all added fragments and clears the stack. */
  public void destroy() {
    ensureTransaction();
    fragmentTransaction.setCustomAnimations(enterAnimation, exitAnimation);

    final Fragment topFragment = stack.peekFirst();
    for (Fragment f : stack) {
      if (f != topFragment) {
        removeFragment(f);
      }
    }
    stack.clear();

    for (String tag : topLevelTags) {
      removeFragment(fragmentManager.findFragmentByTag(tag));
    }

    fragmentTransaction.commitAllowingStateLoss();
    fragmentTransaction = null;
  }
Example #14
0
    void endIdleState() {
      lock.lock();
      try {
        final Thread currentThread = Thread.currentThread();
        assert currentThread == threadsRequestingIdle.getFirst();

        assert !allowFileScopeRequests;
        assert idleStateCount > 0;
        assert activitiyCount == 0;
        --idleStateCount;
        assert idleStateCount >= 0;
        if (idleStateCount == 0) {
          threadsRequestingIdle.remove();
          assert currentThread != threadsRequestingIdle.peekFirst();
          condition.signalAll();
        }
      } finally {
        lock.unlock();
      }
    }
Example #15
0
  /**
   * Updates the snake's position and size.
   *
   * @return Tile tile that the head moved into.
   */
  private TileType updateSnake() {

    /*
     * Here we peek at the next direction rather than polling it. While
     * not game breaking, polling the direction here causes a small bug
     * where the snake's direction will change after a game over (though
     * it will not move).
     */
    Direction direction = directions.peekFirst();

    /*
     * Here we calculate the new point that the snake's head will be at
     * after the update.
     */
    Point head = new Point(snake.peekFirst());
    switch (direction) {
      case North:
        head.y--;
        break;

      case South:
        head.y++;
        break;

      case West:
        head.x--;
        break;

      case East:
        head.x++;
        break;
    }

    /*
     * If the snake has moved out of bounds ('hit' a wall), we can just
     * return that it's collided with itself, as both cases are handled
     * identically.
     */
    if (head.x < 0
        || head.x >= BoardPanel.COL_COUNT
        || head.y < 0
        || head.y >= BoardPanel.ROW_COUNT) {
      return TileType.SnakeBody; // Pretend we collided with our body.
    }

    /*
     * Here we get the tile that was located at the new head position and
     * remove the tail from of the snake and the board if the snake is
     * long enough, and the tile it moved onto is not a fruit.
     *
     * If the tail was removed, we need to retrieve the old tile again
     * incase the tile we hit was the tail piece that was just removed
     * to prevent a false game over.
     */
    TileType old = board.getTile(head.x, head.y);
    if (old != TileType.Fruit && snake.size() > MIN_SNAKE_LENGTH) {
      Point tail = snake.removeLast();
      board.setTile(tail, null);
      old = board.getTile(head.x, head.y);
    }

    /*
     * Update the snake's position on the board if we didn't collide with
     * our tail:
     *
     * 1. Set the old head position to a body tile.
     * 2. Add the new head to the snake.
     * 3. Set the new head position to a head tile.
     *
     * If more than one direction is in the queue, poll it to read new
     * input.
     */
    if (old != TileType.SnakeBody) {
      board.setTile(snake.peekFirst(), TileType.SnakeBody);
      snake.push(head);
      board.setTile(head, TileType.SnakeHead);
      if (directions.size() > 1) {
        directions.poll();
      }
    }

    return old;
  }
Example #16
0
  /**
   * Finally, synchronize our history with the Leader.
   *
   * @param newLeaderZxid
   * @throws IOException
   * @throws InterruptedException
   */
  protected void syncWithLeader(long newLeaderZxid) throws IOException, InterruptedException {
    QuorumPacket ack = new QuorumPacket(Leader.ACK, 0, null);
    QuorumPacket qp = new QuorumPacket();
    long newEpoch = ZxidUtils.getEpochFromZxid(newLeaderZxid);

    readPacket(qp);
    LinkedList<Long> packetsCommitted = new LinkedList<Long>();
    LinkedList<PacketInFlight> packetsNotCommitted = new LinkedList<PacketInFlight>();
    synchronized (zk) {
      if (qp.getType() == Leader.DIFF) {
        LOG.info("Getting a diff from the leader 0x" + Long.toHexString(qp.getZxid()));
      } else if (qp.getType() == Leader.SNAP) {
        LOG.info("Getting a snapshot from leader");
        // The leader is going to dump the database
        // clear our own database and read
        zk.getZKDatabase().clear();
        zk.getZKDatabase().deserializeSnapshot(leaderIs);
        String signature = leaderIs.readString("signature");
        if (!signature.equals("BenWasHere")) {
          LOG.error("Missing signature. Got " + signature);
          throw new IOException("Missing signature");
        }
        zk.getZKDatabase().commit();
        zk.getZKDatabase().getM2mData().clear();
      } else if (qp.getType() == Leader.TRUNC) {
        // we need to truncate the log to the lastzxid of the leader
        LOG.warn(
            "Truncating log to get in sync with the leader 0x" + Long.toHexString(qp.getZxid()));
        boolean truncated = zk.getZKDatabase().truncateLog(qp.getZxid());
        if (!truncated) {
          // not able to truncate the log
          LOG.error("Not able to truncate the log " + Long.toHexString(qp.getZxid()));
          System.exit(13);
        }

      } else {
        LOG.error("Got unexpected packet from leader " + qp.getType() + " exiting ... ");
        System.exit(13);
      }
      zk.getZKDatabase().setlastProcessedZxid(qp.getZxid());
      zk.createSessionTracker();

      long lastQueued = 0;

      // in V1.0 we take a snapshot when we get the NEWLEADER message, but
      // in pre V1.0
      // we take the snapshot at the UPDATE, since V1.0 also gets the
      // UPDATE (after the NEWLEADER)
      // we need to make sure that we don't take the snapshot twice.
      boolean snapshotTaken = false;
      // we are now going to start getting transactions to apply followed
      // by an UPTODATE
      outerLoop:
      while (self.isRunning()) {
        readPacket(qp);
        switch (qp.getType()) {
          case Leader.PROPOSAL:
            PacketInFlight pif = new PacketInFlight();
            pif.hdr = new M2mTxnHeader();
            pif.rec = M2mSerializeUtils.deserializeTxn(qp.getData(), pif.hdr);
            if (pif.hdr.getZxid() != lastQueued + 1) {
              LOG.warn(
                  "Got zxid 0x"
                      + Long.toHexString(pif.hdr.getZxid())
                      + " expected 0x"
                      + Long.toHexString(lastQueued + 1));
            }
            lastQueued = pif.hdr.getZxid();
            packetsNotCommitted.add(pif);
            break;
          case Leader.COMMIT:
            if (!snapshotTaken) {
              pif = packetsNotCommitted.peekFirst();
              if (pif.hdr.getZxid() != qp.getZxid()) {
                LOG.warn(
                    "Committing " + qp.getZxid() + ", but next proposal is " + pif.hdr.getZxid());
              } else {
                zk.processTxn(pif.hdr, pif.rec);
                packetsNotCommitted.remove();
              }
            } else {
              packetsCommitted.add(qp.getZxid());
            }
            break;
          case Leader.INFORM:
            /*
             * Only observer get this type of packet. We treat this as
             * receiving PROPOSAL and COMMMIT.
             */
            PacketInFlight packet = new PacketInFlight();
            packet.hdr = new M2mTxnHeader();
            packet.rec = M2mSerializeUtils.deserializeTxn(qp.getData(), packet.hdr);
            // Log warning message if txn comes out-of-order
            if (packet.hdr.getZxid() != lastQueued + 1) {
              LOG.warn(
                  "Got zxid 0x"
                      + Long.toHexString(packet.hdr.getZxid())
                      + " expected 0x"
                      + Long.toHexString(lastQueued + 1));
            }
            lastQueued = packet.hdr.getZxid();
            if (!snapshotTaken) {
              // Apply to db directly if we haven't taken the snapshot
              zk.processTxn(packet.hdr, packet.rec);
            } else {
              packetsNotCommitted.add(packet);
              packetsCommitted.add(qp.getZxid());
            }
            break;
          case Leader.UPTODATE:
            if (!snapshotTaken) { // true for the pre v1.0 case
              zk.takeSnapshot();
              self.setCurrentEpoch(newEpoch);
            }
            self.cnxnFactory.addZooKeeperServer(self.getHandleIp(), zk);
            break outerLoop;
          case Leader.NEWLEADER: // it will be NEWLEADER in v1.0
            // Create updatingEpoch file and remove it after current
            // epoch is set. QuorumPeer.loadDataBase() uses this file to
            // detect the case where the server was terminated after
            // taking a snapshot but before setting the current epoch.
            // File updating = new
            // File(self.getTxnFactory().getSnapDir(),
            // QuorumPeer.UPDATING_EPOCH_FILENAME);
            // if (!updating.exists() && !updating.createNewFile()) {
            // throw new IOException("Failed to create "
            // + updating.toString());
            // }
            // zk.takeSnapshot();
            // self.setCurrentEpoch(newEpoch);
            // if (!updating.delete()) {
            // throw new IOException("Failed to delete "
            // + updating.toString());
            // }
            snapshotTaken = true;
            writePacket(new QuorumPacket(Leader.ACK, newLeaderZxid, null), true);
            break;
        }
      }
    }
    ack.setZxid(ZxidUtils.makeZxid(newEpoch, 0));
    writePacket(ack, true);
    sock.setSoTimeout(self.tickTime * self.syncLimit);
    zk.startup();
    /*
     * Update the election vote here to ensure that all members of the
     * ensemble report the same vote to new servers that start up and send
     * leader election notifications to the ensemble.
     *
     * @see https://issues.apache.org/jira/browse/ZOOKEEPER-1732
     */
    self.updateElectionVote(newEpoch);

    // We need to log the stuff that came in between the snapshot and the
    // uptodate
    if (zk instanceof FollowerZooKeeperServer) {
      FollowerZooKeeperServer fzk = (FollowerZooKeeperServer) zk;
      for (PacketInFlight p : packetsNotCommitted) {
        fzk.logRequest(p.hdr, p.rec);
      }
      for (Long zxid : packetsCommitted) {
        fzk.commit(zxid);
      }
    } else {
      // New server type need to handle in-flight packets
      throw new UnsupportedOperationException("Unknown server type");
    }
  }
Example #17
0
 @Override
 public Solution getBest() {
   return solutions.peekFirst();
 }
Example #18
0
  public MockCatalogBuilder commit() {
    if (!featureTypes.isEmpty() || !coverages.isEmpty()) {
      if (!featureTypes.isEmpty()) {
        DataStoreInfo ds = dataStores.peekLast();

        expect(catalog.getResourcesByStore(ds, FeatureTypeInfo.class))
            .andReturn(featureTypes)
            .anyTimes();
        expect(catalog.getResourcesByStore(ds, ResourceInfo.class))
            .andReturn((List) featureTypes)
            .anyTimes();
        expect(catalog.getFeatureTypesByDataStore(ds)).andReturn(featureTypes).anyTimes();
      }

      if (!coverages.isEmpty()) {
        CoverageStoreInfo cs = coverageStores.peekLast();

        expect(catalog.getResourcesByStore(cs, CoverageInfo.class)).andReturn(coverages).anyTimes();
        expect(catalog.getResourcesByStore(cs, ResourceInfo.class))
            .andReturn((List) coverages)
            .anyTimes();
        expect(catalog.getCoveragesByCoverageStore(cs)).andReturn(coverages).anyTimes();
      }

      // clear out local lists but push up to be included when this workspace is complete
      featureTypesByNamespace.addAll(featureTypes);
      featureTypes = new LinkedList<FeatureTypeInfo>();

      coveragesByNamespace.addAll(coverages);
      coverages = new LinkedList<CoverageInfo>();

    } else if (!dataStores.isEmpty() || !coverageStores.isEmpty()) {
      WorkspaceInfo ws = workspaces.peekLast();
      NamespaceInfo ns = namespaces.peekLast();

      expect(catalog.getStoresByWorkspace(ws.getName(), DataStoreInfo.class))
          .andReturn(dataStores)
          .anyTimes();
      expect(catalog.getStoresByWorkspace(ws, DataStoreInfo.class))
          .andReturn(dataStores)
          .anyTimes();
      expect(catalog.getDataStoresByWorkspace(ws.getName())).andReturn(dataStores).anyTimes();
      expect(catalog.getDataStoresByWorkspace(ws)).andReturn(dataStores).anyTimes();

      expect(catalog.getStoresByWorkspace(ws.getName(), CoverageStoreInfo.class))
          .andReturn(coverageStores)
          .anyTimes();
      expect(catalog.getStoresByWorkspace(ws, CoverageStoreInfo.class))
          .andReturn(coverageStores)
          .anyTimes();
      expect(catalog.getCoverageStoresByWorkspace(ws.getName()))
          .andReturn(coverageStores)
          .anyTimes();
      expect(catalog.getCoverageStoresByWorkspace(ws)).andReturn(coverageStores).anyTimes();

      List<StoreInfo> l = new LinkedList<StoreInfo>(dataStores);
      l.addAll(coverageStores);

      expect(catalog.getStoresByWorkspace(ws.getName(), StoreInfo.class)).andReturn(l).anyTimes();
      expect(catalog.getStoresByWorkspace(ws, StoreInfo.class)).andReturn(l).anyTimes();

      // add all the resources for this workspace
      List<ResourceInfo> m = new LinkedList(featureTypesByNamespace);
      m.addAll(coveragesByNamespace);
      expect(catalog.getResourcesByNamespace(ns, ResourceInfo.class)).andReturn(m).anyTimes();
      // expect(catalog.getResourcesByNamespace(ns.getPrefix(),
      // ResourceInfo.class)).andReturn(m).anyTimes();
      expect(catalog.getResourcesByNamespace(ns, FeatureTypeInfo.class))
          .andReturn(featureTypesByNamespace)
          .anyTimes();
      // expect(catalog.getResourcesByNamespace(ns.getPrefix(), FeatureTypeInfo.class))
      //    .andReturn(featureTypesByNamespace).anyTimes();
      expect(catalog.getResourcesByNamespace(ns, CoverageInfo.class))
          .andReturn(coveragesByNamespace)
          .anyTimes();
      // expect(catalog.getResourcesByNamespace(ns.getPrefix(), CoverageInfo.class))
      //    .andReturn(coveragesByNamespace).anyTimes();

      dataStoresAll.addAll(dataStores);
      dataStores = new LinkedList();

      coverageStoresAll.addAll(coverageStores);
      coverageStores = new LinkedList();

      featureTypesAll.addAll(featureTypesByNamespace);
      featureTypesByNamespace = new LinkedList();

      coveragesAll.addAll(coveragesByNamespace);
      coveragesByNamespace = new LinkedList();
    } else if (!workspaces.isEmpty()) {

      // all the resources
      List<ResourceInfo> l = new LinkedList<ResourceInfo>(featureTypesAll);
      l.addAll(coveragesAll);
      expect(catalog.getResources(ResourceInfo.class)).andReturn(l).anyTimes();
      expect(catalog.getResources(FeatureTypeInfo.class)).andReturn(featureTypesAll).anyTimes();
      expect(catalog.getResources(CoverageInfo.class)).andReturn(coverages).anyTimes();
      expect(catalog.getFeatureTypes()).andReturn(featureTypesAll).anyTimes();
      expect(catalog.getCoverages()).andReturn(coveragesAll).anyTimes();

      // add all the stores
      List<StoreInfo> m = new LinkedList<StoreInfo>(dataStoresAll);
      m.addAll(coverageStoresAll);
      expect(catalog.getStores(StoreInfo.class)).andReturn(m).anyTimes();
      expect(catalog.getStores(DataStoreInfo.class)).andReturn(dataStoresAll).anyTimes();
      expect(catalog.getStores(CoverageStoreInfo.class)).andReturn(coverageStoresAll).anyTimes();

      // add all the styles
      expect(catalog.getStyles()).andReturn(styles).anyTimes();

      // add all the layer groups
      expect(catalog.getLayerGroups()).andReturn(layerGroups).anyTimes();

      // add all the workspaces/namespaces
      expect(catalog.getWorkspaces()).andReturn(workspaces).anyTimes();
      expect(catalog.getNamespaces()).andReturn(namespaces).anyTimes();

      // default workspace/namespace
      expect(catalog.getDefaultWorkspace()).andReturn(workspaces.peekFirst()).anyTimes();
      expect(catalog.getDefaultNamespace()).andReturn(namespaces.peekFirst()).anyTimes();

      replay(catalog);

      featureTypesAll = new LinkedList();
      coveragesAll = new LinkedList();
      dataStoresAll = new LinkedList();
      coverageStoresAll = new LinkedList();
      styles = new LinkedList();
      workspaces = new LinkedList();
      namespaces = new LinkedList();
    }

    return this;
  }