protected void handleMessageData(byte[] aData) {
    // grab last fragment, use if not complete
    WebSocketFragment fragment = pendingFragments.peek();
    if (fragment == null || fragment.isValid()) {
      // assign web socket fragment since the last one was complete
      fragment = new WebSocketFragment(aData);

      pendingFragments.offer(fragment);
    } else if (fragment != null) {
      fragment.appendFragment(aData);
      if (fragment.canBeParsed()) {
        fragment.parseContent();
      }
    }

    // if we have a complete fragment, handle it
    if (fragment.isValid()) {
      // handle complete fragment
      handleCompleteFragment(fragment);

      // if we have extra data, handle it
      if (aData.length > fragment.getMessageLength()) {
        handleMessageData(
            WebSocketUtil.copySubArray(
                aData, fragment.getMessageLength(), aData.length - fragment.getMessageLength()));
      }
    }
  }
  private static PencilPosition findShortestRoute(int[][] maze) {
    // all found solutions to the maze
    PriorityQueue<PencilPosition> solutions =
        new PriorityQueue<PencilPosition>(5, new PencilPositionComparator());
    // bread-first search queue
    Queue<PencilPosition> routes = new LinkedList<PencilPosition>();
    // set of already visited positions
    Set<PencilPosition> visitedPositions = new HashSet<PencilPosition>();

    // add the starting positions, which is always (0,0)
    routes.add(new PencilPosition(0, 0, false, null));

    while (!routes.isEmpty()) {
      PencilPosition position = routes.poll();

      // if this is the destinations position then we've found a solution
      if (0 == maze[position.row][position.column]) {
        solutions.add(position);
        continue;
      }

      // if we haven't already visited this position
      if (!visitedPositions.contains(position)) {
        routes.addAll(findPossibleRoutes(position, maze));
        visitedPositions.add(position);
      }
    }

    return solutions.poll();
  }
 public PreloadTarget next(int width, int height) {
   final PreloadTarget result = queue.poll();
   queue.offer(result);
   result.photoWidth = width;
   result.photoHeight = height;
   return result;
 }
 public Object evaluate(EditorAdaptor vim, Queue<String> command) {
   String next = command.poll();
   int index = next.indexOf('=');
   if (index < 0) {
     noSuchOptionMessage(vim, next);
     return null;
   }
   String optName = next.substring(0, index).trim();
   String value = next.substring(index + 1);
   if (command.size() > 0) {
     // restore preceding space and spaces between tokens
     value += " " + StringUtils.join(" ", command);
   }
   Option<String> strOpt;
   Option<Integer> intOpt;
   try {
     if ((strOpt = find(Options.STRING_OPTIONS, optName)) != null) set(vim, strOpt, value);
     else if ((intOpt = find(Options.INT_OPTIONS, optName)) != null)
       set(vim, intOpt, Integer.valueOf(value));
     else noSuchOptionMessage(vim, optName);
   } catch (ValueException e) {
     invalidValueMessage(vim, value);
   } catch (NumberFormatException e) {
     invalidValueMessage(vim, value);
   }
   return null;
 }
Exemple #5
0
 private void pass() throws InterruptedException {
   if (!exitQueue.isEmpty()) {
     Visitor oldVisitor = exitQueue.poll();
     System.out.println(oldVisitor + " left the museum");
     // Thread.sleep(2000);
   }
 }
    @Setup
    public synchronized void setup() {
      for (int i = 0; i < MAX_THREAD_COUNT; i++) {
        responseQueues[i] = new OneToOneConcurrentArrayQueue<>(RESPONSE_QUEUE_CAPACITY);
      }

      values = new Integer[burstLength];
      for (int i = 0; i < burstLength; i++) {
        values[i] = -(burstLength - i);
      }

      consumerThread =
          new Thread(
              () -> {
                while (true) {
                  final Integer value = sendQueue.poll();
                  if (null == value) {
                    if (!running.get()) {
                      break;
                    }
                  } else {
                    final int intValue = value;
                    if (intValue >= 0) {
                      final Queue<Integer> responseQueue = responseQueues[value];
                      while (!responseQueue.offer(value)) {
                        // busy spin
                      }
                    }
                  }
                }
              });

      consumerThread.setName("consumer");
      consumerThread.start();
    }
 /**
  * 开始下载任务
  *
  * @param downloadId
  * @param callback
  */
 public void startTask(int downloadId, FileDownloaderCallback callback) {
   FileDownloaderModel model = getFileDownloaderModelById(downloadId);
   if (model != null) {
     BridgeListener bridgeListener = mListenerManager.getBridgeListener(downloadId);
     bridgeListener.addDownloadListener(callback);
     if (mDownloadingList.size() >= mConfiguration.getMaxDownloadingCount()) { // 下载中队列已满
       if (!mWaitQueue.contains(model)) {
         mWaitQueue.offer(model);
       }
       bridgeListener.wait(downloadId);
     } else {
       mDownloadingList.add(model);
       final BaseDownloadTask task =
           FileDownloader.getImpl()
               .create(model.getUrl())
               .setPath(model.getPath())
               .setCallbackProgressTimes(100)
               .setAutoRetryTimes(mAutoRetryTimes)
               .setListener(bridgeListener);
       for (int i = 0; i < mHeaders.size(); i++) {
         task.addHeader(mHeaders.name(i), mHeaders.value(i));
       }
       bridgeListener.setDownloadTask(task);
       task.start();
     }
   } else {
     ILogger.e("Task does not exist!");
   }
 }
  public static int nextImportantEvent(
      Queue<OTH> othQueue, List<Instance> instanceList, CPUList cpuList) {
    int nextImportantTime = Integer.MAX_VALUE;

    int nextCpuTime;
    int nextOthTime;
    int nextNewTime;

    if (othQueue.isEmpty()) {
      nextOthTime = Integer.MAX_VALUE;
    } else {
      nextOthTime = othQueue.peek().getExitTime();
    }

    nextCpuTime = cpuList.getNextFinishTime();

    if (instanceList.isEmpty()) {
      nextNewTime = Integer.MAX_VALUE;
    } else {
      nextNewTime = instanceList.get(0).getStartTime();
    }

    nextImportantTime = Math.min(nextOthTime, nextCpuTime);
    nextImportantTime = Math.min(nextImportantTime, nextNewTime);

    //		System.out.println("\n################## NEXT IMPORTANT TIME: " + nextImportantTime);

    return nextImportantTime;
  }
 static long maxFlow() {
   long totalFlow = 0;
   while (true) {
     Queue<Integer> q = new LinkedList<>();
     int[] parent = new int[cap.length];
     Arrays.fill(parent, -1);
     q.add(s);
     while (!q.isEmpty()) {
       int node = q.poll();
       for (int j = 1; j <= n; j++) {
         if (cap[node][j] - flow[node][j] > 0 && parent[j] == -1) {
           parent[j] = node;
           q.add(j);
         }
       }
     }
     if (parent[t] == -1) break;
     long cflow = Long.MAX_VALUE;
     int current = t;
     while (current != s) {
       cflow = Math.min(cflow, cap[parent[current]][current] - flow[parent[current]][current]);
       current = parent[current];
     }
     current = t;
     while (current != s) {
       flow[parent[current]][current] += cflow;
       flow[current][parent[current]] -= cflow;
       current = parent[current];
     }
     totalFlow += cflow;
   }
   return totalFlow;
 }
 /** @return true if there is still work to be processed. */
 public boolean isBusyOld() {
   return !(mCreateMarkerTasks.isEmpty()
       && mOnScreenCreateMarkerTasks.isEmpty()
       && mOnScreenRemoveMarkerTasks.isEmpty()
       && mRemoveMarkerTasks.isEmpty()
       && mAnimationTasks.isEmpty());
 }
  public static int checkTimes(
      Queue<OTH> othQueue, List<Instance> instanceList, CPUList cpuList, int importantTime) {

    int nextCpuTime;
    int nextOthTime;
    int nextNewTime;

    if (othQueue.isEmpty()) {
      nextOthTime = Integer.MAX_VALUE;
    } else {
      nextOthTime = othQueue.peek().getExitTime();
    }

    nextCpuTime = cpuList.getNextFinishTime();

    if (instanceList.isEmpty()) {
      nextNewTime = Integer.MAX_VALUE;
    } else {
      nextNewTime = instanceList.get(0).getStartTime();
    }

    if (importantTime == nextCpuTime) {
      return 0;
    }
    if (importantTime == nextOthTime) {
      return 1;
    }

    if (importantTime == nextNewTime) {
      return 2;
    }
    return -1;
  }
Exemple #12
0
 /** Sorts the index in the order of the date of publication of the posts. */
 protected void sortIndexes() {
   for (SingleIndex s : indexList) {
     for (int i = 0; i < postsPerIndex && !queue.isEmpty(); i++) {
       s.getPosts().add(queue.remove());
     }
   }
 }
Exemple #13
0
  /**
   * Using a serialized list of tree nodes to generate a binary tree. There is detail information:
   * https://leetcode.com/problems/binary-tree-inorder-traversal/
   *
   * @param serializedTreeNode a serialized list of tree nodes
   * @return the node of tree root
   */
  public static TreeNode generateTree(String serializedTreeNode) {
    String[] tokens = serializedTreeNode.split(",");
    if (tokens.length <= 0) return null;
    TreeNode root = new TreeNode(Integer.parseInt(tokens[0]));
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    int pos = 1;
    while (pos < tokens.length) {

      TreeNode temp = queue.remove();
      if (!tokens[pos].equals("#")) {
        TreeNode left = new TreeNode(Integer.parseInt(tokens[pos]));
        temp.left = left;
        queue.add(left);
      }
      pos++;

      if (pos >= tokens.length) break;
      if (!tokens[pos].equals("#")) {
        TreeNode right = new TreeNode(Integer.parseInt(tokens[pos]));
        temp.right = right;
        queue.add(right);
      }
      pos++;
    }
    return root;
  }
  public void process(String queueName) {
    XtrTask xtrTask;
    Queue gaeQueue = QueueFactory.getDefaultQueue();

    log.info("Processing queue " + queueName);

    java.util.Queue<XtrTask> taskQueue = queues.get(queueName);
    if (taskQueue == null) {
      log.warning("Queue " + queueName + " does not exist");
      return;
    }

    TaskHandle taskHandle = null;

    while ((xtrTask = taskQueue.poll()) != null) {
      taskHandle =
          gaeQueue.add(
              url("/webxtractor/task/".concat(queueName))
                  .param("payload", xtrTask.getPayload())
                  .method(TaskOptions.Method.GET));
      log.info(
          "GA queue "
              + taskHandle.getQueueName()
              + " accepted task "
              + xtrTask.getName()
              + " as "
              + taskHandle.getName()
              + " estimated to run at "
              + taskHandle.getEtaMillis());
    }
  }
  @Test
  public void testBug58232() throws Exception {
    Tomcat tomcat = getTomcatInstance();
    // No file system docBase required
    Context ctx = tomcat.addContext("", null);
    ctx.addApplicationListener(Bug54807Config.class.getName());
    Tomcat.addServlet(ctx, "default", new DefaultServlet());
    ctx.addServletMapping("/", "default");

    WebSocketContainer wsContainer = ContainerProvider.getWebSocketContainer();

    tomcat.start();

    Assert.assertEquals(LifecycleState.STARTED, ctx.getState());

    SimpleClient client = new SimpleClient();
    URI uri = new URI("ws://localhost:" + getPort() + "/echoBasic");

    try (Session session = wsContainer.connectToServer(client, uri); ) {
      CountDownLatch latch = new CountDownLatch(1);
      BasicText handler = new BasicText(latch);
      session.addMessageHandler(handler);
      session.getBasicRemote().sendText("echoBasic");

      boolean latchResult = handler.getLatch().await(10, TimeUnit.SECONDS);
      Assert.assertTrue(latchResult);

      Queue<String> messages = handler.getMessages();
      Assert.assertEquals(1, messages.size());
      for (String message : messages) {
        Assert.assertEquals("echoBasic", message);
      }
    }
  }
  /**
   * Locate each unexpanded Structure|Sequence and: 1. check that none of its fields is referenced
   * => do not expand 2. add all of its fields as leaves Note that #2 may end up adding additional
   * leaf structs &/or seqs
   */
  public void expand() {
    // Create a queue of unprocessed leaf compounds
    Queue<DapVariable> queue = new ArrayDeque<DapVariable>();

    for (int i = 0; i < variables.size(); i++) {
      DapVariable var = variables.get(i);
      if (!var.isTopLevel()) continue;
      // prime the queue
      if (var.getSort() == DapSort.STRUCTURE || var.getSort() == DapSort.SEQUENCE) {
        DapStructure struct = (DapStructure) var; // remember Sequence subclass Structure
        if (expansionCount(struct) == 0) queue.add(var);
      }
    }
    // Process the queue in prefix order
    while (queue.size() > 0) {
      DapVariable vvstruct = queue.remove();
      DapStructure dstruct = (DapStructure) vvstruct;
      for (DapVariable field : dstruct.getFields()) {
        if (findVariableIndex(field) < 0) {
          // Add field as leaf
          this.segments.add(new Segment(field));
          this.variables.add(field);
        }
        if (field.getSort() == DapSort.STRUCTURE || field.getSort() == DapSort.SEQUENCE) {
          if (expansionCount((DapStructure) field) == 0) queue.add(field);
        }
      }
    }
    this.expansion = Expand.EXPANDED;
  }
Exemple #17
0
  public void remove(MUFModule module) {
    if (playing) {
      delayRemove.offer(module);
      return;
    }

    // set to true
    playing = true;
    adding = false;
    moduleToBeRemoved = module;

    // exclude from layout
    modules.remove(module.getId());
    GridData data = (GridData) module.self.getLayoutData();
    data.exclude = true;
    module.self.setLayoutData(data);
    module.self.setVisible(false);

    if (content.isVisible()) {
      // get destination size
      frame = 1;
      Point newSize = content.computeSize(SWT.DEFAULT, SWT.DEFAULT);
      dx = Math.min(0, (newSize.x - oldSize.x) / FRAMES);
      dy = Math.min(0, (newSize.y - oldSize.y) / FRAMES);
      Display.getCurrent().timerExec(0, runnable);
    } else {
      oldSize = content.computeSize(SWT.DEFAULT, SWT.DEFAULT);
      playing = false;
      delayDispose.offer(module.self);
    }
    module.dispose();
  }
 public static void main(String[] args) throws IOException {
   int n = readInt();
   int m = readInt();
   ArrayList<ArrayList<Integer>> adj = new ArrayList<ArrayList<Integer>>();
   for (int x = 0; x < n; x++) adj.add(new ArrayList<Integer>());
   for (int x = 0; x < m; x++) {
     int a = readInt() - 1;
     int b = readInt() - 1;
     adj.get(a).add(b);
     adj.get(b).add(a);
   }
   int k = readInt();
   Queue<State> q = new LinkedList<State>();
   boolean[] v = new boolean[n];
   for (int x = 0; x < k; x++) {
     int a = readInt() - 1;
     v[a] = true;
     q.offer(new State(a, 0));
   }
   int max = 0;
   while (!q.isEmpty()) {
     State curr = q.poll();
     max = Math.max(max, curr.moves);
     for (Integer next : adj.get(curr.index)) {
       if (v[next]) continue;
       v[next] = true;
       q.offer(new State(next, curr.moves + 1));
     }
   }
   System.out.println(max);
 }
    public Map<Field, Object> next() {
      if (!hasNext()) {
        throw new NoSuchElementException();
      }

      Map<Field, Object> pass = new HashMap<Field, Object>();

      for (Entry<Field, Queue<? extends Object>> entry : queues.entrySet()) {
        final Field field = entry.getKey();
        final Queue<? extends Object> queue = entry.getValue();

        pass.put(field, queue.peek());
      }

      for (Entry<Field, Queue<? extends Object>> entry : queues.entrySet()) {
        final Field field = entry.getKey();
        final Queue<? extends Object> queue = entry.getValue();

        queue.poll();

        if (queue.isEmpty() && hasNext()) {
          List<? extends Object> parameter = parameters.get(field);
          queues.put(field, new LinkedList<Object>(parameter));
        } else {
          break;
        }
      }

      return pass;
    }
  /* Fill the bipartite graph if possible. */
  boolean[] solve() {
    Map<Integer, List<Integer>> gr = makeGraph();

    boolean[] truthTable = new boolean[count];
    // keep track of which ones we've visited
    boolean[] visited = new boolean[count];
    Queue<Integer> queue = new LinkedList<Integer>();
    truthTable[0] = true; // assume the first person tells the truth
    queue.add(0);

    // Breadth first search on graph
    while (!queue.isEmpty()) {
      int next = queue.remove();
      boolean truth = truthTable[next];
      List<Integer> list = gr.get(next);

      // Go through list and toggle when needed
      for (int i = 0; i < list.size(); i++) {
        int node = list.get(i);
        if (!visited[node]) {
          visited[node] = true;
          truthTable[node] = !truth;
          queue.add(node);
        }
      }
    }

    return truthTable;
  }
  /**
   * It is synchronized as it does merging of adjacent blocks. An easiest way to somewhat address
   * fragmentation problem.
   *
   * @param pointer2free
   */
  private void freeAndMerge(Pointer pointer2free) {
    synchronized (pointers) {
      pointers.remove(pointer2free);
      // merge adjacent blocks
      if (null != pointer2free.getPrev() && pointer2free.getPrev().isFree()) {
        // Merge previous
        pointers.remove(pointer2free.getPrev());
        pointer2free.setStart(pointer2free.getPrev().getStart());
        pointer2free.setPrev(pointer2free.getPrev().getPrev());
        // Recursive call
        freeAndMerge(pointer2free);
      }

      if (null != pointer2free.getNext() && pointer2free.getNext().isFree()) {
        // Merge Next
        pointers.remove(pointer2free.getNext());
        pointer2free.setEnd(pointer2free.getNext().getEnd());
        pointer2free.setNext(pointer2free.getNext().getNext());
        // Recursive call
        freeAndMerge(pointer2free);
      }
      if (!pointer2free.isFree()) {
        pointer2free.setFree(true);
        pointer2free.setClazz(null);
        pointers.add(pointer2free);
      }
    }
  }
  @Override
  public void update(GameContainer gc, int delta) throws SlickException {
    rand.nextDouble();
    if (System.currentTimeMillis() - lastUpdate > simulationDelay) {
      lastUpdate = System.currentTimeMillis();
      runSimulation();
    }

    Airplane airplaneHandle;
    Iterator<Airplane> it;
    it = airQueue.iterator();
    while (it.hasNext()) {
      airplaneHandle = it.next();

      airplaneHandle.update(delta);
    }
    it = groundQueue.iterator();
    while (it.hasNext()) {
      airplaneHandle = it.next();

      airplaneHandle.update(delta);
    }
    airplaneHandle = runway.getCurrentAirplane();
    if (airplaneHandle != null) airplaneHandle.update(delta);
  }
 private void adjustIncomingPosition(Queue<PositionElement> longs, Queue<PositionElement> shorts) {
   if (mIncomingPosition.signum() == 1) {
     longs.add(new PositionElement(mIncomingPosition, mClosingPrice));
   } else if (mIncomingPosition.signum() == -1) {
     shorts.add(new PositionElement(mIncomingPosition.negate(), mClosingPrice));
   }
 }
  @Override
  public void render(GameContainer gc, Graphics g) throws SlickException {
    backgroundImage.draw();

    Airplane airplaneHandle;
    Iterator<Airplane> it;
    it = airQueue.iterator();
    while (it.hasNext()) {
      airplaneHandle = it.next();

      airplaneHandle.render(g, airplaneImage);
    }
    it = groundQueue.iterator();
    while (it.hasNext()) {
      airplaneHandle = it.next();

      airplaneHandle.render(g, airplaneImage);
    }
    airplaneHandle = runway.getCurrentAirplane();
    if (airplaneHandle != null) airplaneHandle.render(g, airplaneImage);

    g.setColor(Color.white);
    g.drawString("Airport Simulator", gc.getWidth() - 170, 10);
    g.drawString("Update: " + currentUpdate, gc.getWidth() - 130, gc.getHeight() - 30);
  }
Exemple #25
0
  public int[] findOrder(int numCourses, int[][] prerequisites) {
    Map<Integer, Set<Integer>> graph = new HashMap<>();
    Queue<Integer> queue = new LinkedList<>();
    int[] visited = new int[numCourses];

    for (int i = 0; i < numCourses; ++i) {
      graph.put(i, new HashSet<>());
    }

    // build the graph first
    for (int i = 0; i < prerequisites.length; ++i) {
      graph.get(prerequisites[i][0]).add(prerequisites[i][1]);
    }

    boolean hasCycle = false;
    for (int i = 0; i < numCourses; ++i) {
      if (!dfs(graph, i, visited, queue)) {
        hasCycle = true;
        break;
      }
    }

    if (hasCycle) {
      return new int[0];
    } else {
      int[] result = new int[numCourses];

      for (int i = 0; i < numCourses; ++i) {
        result[i] = queue.poll();
      }

      return result;
    }
  }
  private void handleHTTP(OutPacketMessage msg, ChannelHandlerContext ctx, ChannelPromise promise)
      throws IOException {
    Channel channel = ctx.channel();
    Attribute<Boolean> attr = channel.attr(WRITE_ONCE);

    Queue<Packet> queue = msg.getClientHead().getPacketsQueue(msg.getTransport());

    if (!channel.isActive() || queue.isEmpty() || !attr.compareAndSet(null, true)) {
      promise.setSuccess();
      return;
    }

    ByteBuf out = encoder.allocateBuffer(ctx.alloc());
    Boolean b64 = ctx.channel().attr(EncoderHandler.B64).get();
    if (b64 != null && b64) {
      Integer jsonpIndex = ctx.channel().attr(EncoderHandler.JSONP_INDEX).get();
      encoder.encodeJsonP(jsonpIndex, queue, out, ctx.alloc(), 50);
      String type = "application/javascript";
      if (jsonpIndex == null) {
        type = "text/plain";
      }
      sendMessage(msg, channel, out, type, promise);
    } else {
      encoder.encodePackets(queue, out, ctx.alloc(), 50);
      sendMessage(msg, channel, out, "application/octet-stream", promise);
    }
  }
  @Override
  public String[] findFiles(final String folderName) {

    File folder = new File(folderName);
    if (!folder.exists()) {
      throw new IllegalArgumentException();
    }

    List<String> foundFiles = new ArrayList<String>();
    Queue<File> folders = new LinkedList<File>();

    folders.add(folder);

    while (!folders.isEmpty()) {

      File currentFolder = folders.remove();
      File[] currentFiles = currentFolder.listFiles();

      for (File f : currentFiles) {
        if (f.isDirectory()) {
          folders.add(f);
        } else if (f.isFile()) {
          foundFiles.add(f.getAbsolutePath());
        } else {
          throw new RuntimeException("It isn't file or folder");
        }
      }
    }

    return foundFiles.toArray(new String[foundFiles.size()]);
  }
  /** This is synchronized to ensure that we process the queue serially. */
  private synchronized void complete(String message) {
    // This is a weird problem with writing stuff while idling. Need to investigate it more, but
    // for now just ignore it.
    if (MESSAGE_COULDNT_BE_FETCHED_REGEX.matcher(message).matches()) {
      log.warn(
          "Some messages in the batch could not be fetched for {}\n"
              + "---cmd---\n{}\n---wire---\n{}\n---end---\n",
          new Object[] {config.getUsername(), getCommandTrace(), getWireTrace()});
      errorStack.push(new Error(completions.peek(), message, wireTrace.list()));
      throw new RuntimeException(
          "Some messages in the batch could not be fetched for user " + config.getUsername());
    }

    CommandCompletion completion = completions.peek();
    if (completion == null) {
      if ("+ idling".equalsIgnoreCase(message)) {
        synchronized (idleMutex) {
          idler.idleStart();
          log.trace("IDLE entered.");
          idleAcknowledged.set(true);
        }
      } else {
        log.error("Could not find the completion for message {} (Was it ever issued?)", message);
        errorStack.push(new Error(null, "No completion found!", wireTrace.list()));
      }
      return;
    }

    if (completion.complete(message)) {
      completions.poll();
    }
  }
  /**
   * Dequeues all previously enqueued wrappers and writes them to the stream.
   *
   * @throws IOException If failed.
   */
  void delayedWrite() throws IOException {
    if (wrappers != null)
      for (GridOptimizedWrapper w = wrappers.poll(); w != null; w = wrappers.poll())
        w.delayedWriteExternal(this);

    wrappers = null; // GC.
  }
 void checkIterationSanity(Queue q) {
   if (rnd.nextBoolean()) return;
   int size = q.size();
   Object[] a = q.toArray();
   Object[] b = new Object[size + 2];
   Arrays.fill(b, Boolean.TRUE);
   Object[] c = q.toArray(b);
   equal(a.length, size);
   check(b == c);
   check(b[size] == null);
   check(b[size + 1] == Boolean.TRUE);
   equal(q.toString(), Arrays.toString(a));
   Integer[] xx = null, yy = null;
   if (size > 0) {
     xx = new Integer[size - 1];
     Arrays.fill(xx, 42);
     yy = ((Queue<Integer>) q).toArray(xx);
     for (Integer zz : xx) equal(42, zz);
   }
   Iterator it = q.iterator();
   for (int i = 0; i < size; i++) {
     check(it.hasNext());
     Object x = it.next();
     check(x == a[i]);
     check(x == b[i]);
     if (xx != null) check(x == yy[i]);
   }
   check(!it.hasNext());
 }