Java 类org.apache.commons.lang3.mutable.MutableBoolean 实例源码

@Override
protected ActivityResultContext execute() throws Exception {

    // on attend sur un lock, si nécessaire
    final String lockKey = getStringVariable(WAIT_LOCK_KEY);
    if (lockKey != null) {
        final MutableBoolean lock = (MutableBoolean) datastore.get(lockKey);
        if (lock != null) {
            //noinspection SynchronizationOnLocalVariableOrMethodParameter
            synchronized (lock) {
                while (lock.booleanValue()) {
                    lock.wait();
                }
            }
        }
    }

    // on stocke un pseudo-résultat dans le datastore global (pour simuler la database dans le cas ordinaire)
    final String key = getStringVariable(RESULTS_KEY);
    datastore.put(key, true);

    return new FinishedActivityResultContext();
}

@Test
public void testCallTwice() throws Exception {
    final MutableInt callCount = new MutableInt(0);
    final MutableBoolean called = new MutableBoolean(false);
    Polling p = new Polling() {
        @Override
        public Boolean call() throws Exception {
            callCount.increment();
            boolean b = called.booleanValue();
            called.setTrue();
            return b;
        }
    };
    p.poll(500, 10);

    assertEquals(2, callCount.intValue());
}

@Test
public void testCallableTwice() throws Exception {
    final MutableInt callCount = new MutableInt(0);
    final MutableBoolean called = new MutableBoolean(false);
    Polling p = new Polling(new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            callCount.increment();
            boolean b = called.booleanValue();
            called.setTrue();
            return b;
        }
    });
    p.poll(500, 10);

    assertEquals(2, callCount.intValue());
}

@Test
public void test() throws IOException {
    MutableBoolean parsed = new MutableBoolean(false);
    AsyncJsonParser parser = new AsyncJsonParser(root -> {
        parsed.setValue(true);
        try {
            Assert.assertEquals(mapper.treeToValue(root, Model.class), model);
        } catch (JsonProcessingException e) {
            Assert.fail(e.getMessage());
        }
    });

    for (byte b : new ObjectMapper().writeValueAsBytes(model)) {
        parser.consume(new byte[] { b }, 1);
    }

    Assert.assertTrue(parsed.booleanValue());
}

@Test
public void test_chunks() throws IOException {
    MutableBoolean parsed = new MutableBoolean(false);
    AsyncJsonParser parser = new AsyncJsonParser(root -> {
        parsed.setValue(true);
        try {
            Assert.assertEquals(mapper.treeToValue(root, Model.class), model);
        } catch (JsonProcessingException e) {
            Assert.fail(e.getMessage());
        }
    });

    final int CHUNK_SIZE = 20;
    byte[] bytes = new ObjectMapper().writeValueAsBytes(model);
    for (int i = 0; i < bytes.length; i += CHUNK_SIZE) {
        byte[] chunk = new byte[20];
        int start = Math.min(bytes.length, i);
        int len = Math.min(CHUNK_SIZE, bytes.length - i);
        System.arraycopy(bytes, start, chunk, 0, len);
        parser.consume(chunk, len);
    }

    Assert.assertTrue(parsed.booleanValue());
}

private boolean determineDeleteInBatchSupported(final Class<?> genericType) {
    final MutableBoolean deleteInBatchSupported = new MutableBoolean(true);
    Reflections.doWithFields(genericType, new FieldCallback() {
        @Override
        public void doWith(final Field field) {
            if (!deleteInBatchSupported.getValue()) {
                return;
            } else if (Reflections.getAnnotation(field, ElementCollection.class) != null) {
                //element collections are mapped as separate tables, thus the values would cause a foreign key constraint violation
                deleteInBatchSupported.setValue(false);
            } else if (Reflections.getAnnotation(field, Embedded.class) != null) {
                //check embedded types for the same constraints
                if (!determineDeleteInBatchSupported(field.getType())) {
                    deleteInBatchSupported.setValue(false);
                }
            }
        }
    });
    return deleteInBatchSupported.getValue();
}

@Test
public void firstDoneTest()
{
  SimpleDoneQueueManager<Query, Void> sdqqm = new SimpleDoneQueueManager<Query, Void>();

  sdqqm.setup(null);
  sdqqm.beginWindow(0);

  Query query = new MockQuery("1");
  sdqqm.enqueue(query, null, new MutableBoolean(true));

  QueryBundle<Query, Void, MutableBoolean> qb = sdqqm.dequeue();
  Assert.assertEquals("Should return back null.", null, qb);

  sdqqm.endWindow();
  sdqqm.beginWindow(1);

  qb = sdqqm.dequeue();

  Assert.assertEquals("Should return back null.", null, qb);
  qb = sdqqm.dequeue();
  Assert.assertEquals("Should return back null.", null, qb);

  sdqqm.endWindow();
  sdqqm.teardown();
}

@Test
public void simpleEnqueueDequeueBlock()
{
  SimpleDoneQueueManager<Query, Void> sdqqm = new SimpleDoneQueueManager<Query, Void>();

  sdqqm.setup(null);
  sdqqm.beginWindow(0);

  Query query = new MockQuery("1");
  sdqqm.enqueue(query, null, new MutableBoolean(false));

  Assert.assertEquals(1, sdqqm.getNumLeft());
  Assert.assertEquals(sdqqm.getNumPermits(), sdqqm.getNumLeft());

  QueryBundle<Query, Void, MutableBoolean> qb = sdqqm.dequeueBlock();

  Assert.assertEquals(0, sdqqm.getNumLeft());
  Assert.assertEquals(sdqqm.getNumPermits(), sdqqm.getNumLeft());

  Assert.assertEquals("Should return same query.", query, qb.getQuery());

  sdqqm.endWindow();
  sdqqm.teardown();
}

@Test
public void simpleEnqueueDequeueThenBlock() throws Exception
{
  SimpleDoneQueueManager<Query, Void> sdqqm = new SimpleDoneQueueManager<Query, Void>();

  sdqqm.setup(null);
  sdqqm.beginWindow(0);

  Query query = new MockQuery("1");
  sdqqm.enqueue(query, null, new MutableBoolean(false));

  Assert.assertEquals(1, sdqqm.getNumLeft());
  Assert.assertEquals(sdqqm.getNumPermits(), sdqqm.getNumLeft());

  QueryBundle<Query, Void, MutableBoolean> qb = sdqqm.dequeueBlock();

  Assert.assertEquals(0, sdqqm.getNumLeft());
  Assert.assertEquals(sdqqm.getNumPermits(), sdqqm.getNumLeft());

  testBlocking(sdqqm);

  sdqqm.endWindow();
  sdqqm.teardown();
}

@Override
public boolean isBlank() {
  CsvGridSheetPane gridSheet = getGridSheet();
  MutableBoolean result = new MutableBoolean(true);
  forEachCell(new ICellConsumer() {
    @Override
    public boolean accept(int r, int c) {
      Object val = gridSheet.getValueAt(r, c);
      if (val != null && !val.toString().isEmpty()) {
        result.setFalse();
        return false;
      }
      return true;
    }
  });
  return result.booleanValue();
}

private String decodeString(ByteBuf in) throws ProtocolException {
    final StringBuilder buffer = new StringBuilder();
    final MutableBoolean reachCRLF = new MutableBoolean(false);
    setReaderIndex(in, in.forEachByte(new ByteBufProcessor() {

        @Override
        public boolean process(byte value) throws Exception {
            if (value == '\n') {
                if ((byte) buffer.charAt(buffer.length() - 1) != '\r') {
                    throw new ProtocolException("Response is not ended by CRLF");
                } else {
                    buffer.setLength(buffer.length() - 1);
                    reachCRLF.setTrue();
                    return false;
                }
            } else {
                buffer.append((char) value);
                return true;
            }
        }
    }));
    return reachCRLF.booleanValue() ? buffer.toString() : null;
}

private String toRangeClause(SqlgGraph sqlgGraph, MutableBoolean mutableOrderBy) {
    if (this.sqlgRangeHolder != null && this.sqlgRangeHolder.isApplyOnDb()) {
        if (this.sqlgRangeHolder.hasRange()) {
            //This is MssqlServer, ugly but what to do???
            String sql = "";
            if (mutableOrderBy.isFalse() && sqlgGraph.getSqlDialect().isMssqlServer() && this.getDbComparators().isEmpty()) {
                sql = "\n\tORDER BY 1\n\t";
            }
            return sql + "\n" + sqlgGraph.getSqlDialect().getRangeClause(this.sqlgRangeHolder.getRange());
        } else {
            Preconditions.checkState(this.sqlgRangeHolder.hasSkip(), "If not a range query then it must be a skip.");
            return sqlgGraph.getSqlDialect().getSkipClause(this.sqlgRangeHolder.getSkip());
        }
    }
    return "";
}

private static void onPunish(Session session, String ... args) {
    if (args.length < 2) return;

    if (PlayerInfo.isModerator(session.getPlayerId())) {
        int targetId = CharacterUtils.getCharacterIdByName(args[1]);

        MutableBoolean targetFound = new MutableBoolean(false);

        ServerManager.getSession(targetId).ifPresent(target -> {
            ChatUtils.sendServerMessage(target, "You have been punished by a moderator.");
            target.close();

            ChatUtils.sendServerMessage(session, "Player punished: " + args[1]);

            targetFound.setTrue();
        });

        if (targetFound.isFalse()) {
            ChatUtils.sendServerMessage(session, "Player not found.");
        }
    }
}

@Test
public void clearFilters() {
    final List<Person> listOfPersons = getListOfPersons(100);
    FilterableListContainer<Person> container = new FilterableListContainer<>(
            listOfPersons);
    container.addContainerFilter(new SimpleStringFilter("firstName",
            "First1", true, true));
    Assert.assertNotSame(listOfPersons.size(), container.size());
    container.removeAllContainerFilters();
    Assert.assertEquals(listOfPersons.size(), container.size());
    container.addContainerFilter(new SimpleStringFilter("firstName",
            "foobar", true, true));
    Assert.assertEquals(0, container.size());

    final MutableBoolean fired = new MutableBoolean(false);
    container.addListener(new Container.ItemSetChangeListener() {
        @Override
        public void containerItemSetChange(
                Container.ItemSetChangeEvent event) {
            fired.setTrue();
        }
    });
    container.removeAllContainerFilters();
    Assert.assertTrue(fired.booleanValue());
    Assert.assertEquals(listOfPersons.size(), container.size());
}

private static <T> VlanAllocation of(Collection<T> ports, Function<T, Optional<Integer>> sVlanId, Function<T, Optional<Vlan>> vlan) {
  MutableBoolean overlappingVlan = new MutableBoolean(false);
  Map<Optional<Integer>, Vlan> allocationsPerSVlan = ports.stream().collect(Collectors.toMap(
      sVlanId,
      port -> vlan.apply(port).orElse(Vlan.none()),
      (a, b) -> {
        if (a.overlaps(b)) {
          overlappingVlan.setTrue();
        }
        return a.union(b);
      }));
  Vlan allocatedSVlans = ports.stream()
      .map(port -> sVlanId.apply(port).map(Vlan::singleton).orElse(Vlan.none()))
      .reduce(Vlan.none(), Vlan::union);
  if (!overlappingVlan.booleanValue() && allocatedSVlans.overlaps(allocationsPerSVlan.getOrDefault(Optional.empty(), Vlan.none()))) {
    overlappingVlan.setTrue();
  };
  return new VlanAllocation(overlappingVlan.booleanValue(), allocationsPerSVlan, allocatedSVlans);
}

private static boolean writeBytesForView(
        CountingOutputStream countingOutputStream, byte[] bytes, int maxLength, MutableBoolean truncated) {
    if (truncated.booleanValue()) {
        return false;
    }

    if (countingOutputStream.getTotalWrittenByteCount() + bytes.length > maxLength) {
        truncated.setTrue();
        return false;
    } else {
        try {
            countingOutputStream.write(bytes);
            return true;
        } catch (IOException ignored) {
            truncated.setTrue();
            return false;
        }
    }
}

@Test
public void testCallableOnce() throws Exception {
    final MutableInt callCount = new MutableInt(0);
    final MutableBoolean called = new MutableBoolean(false);
    Polling p = new Polling(new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            callCount.increment();
            return true;
        }
    });
    p.poll(500, 10);

    assertEquals(1, callCount.intValue());
}

private boolean categoriseSequences(BDD bdd, SortedSet<IOBehaviour> sequences, List<IOBehaviour> falling, List<IOBehaviour> rising, List<IOBehaviour> constant) {
    for(IOBehaviour beh : sequences) {
        BDD startBDD = bdd;
        MutableBoolean resultStart = new MutableBoolean();
        if(!evaluateBDD(resultStart, startBDD, beh.getStart())) {
            logger.error("Something went wrong");
            return false;
        }
        BDD endBDD = bdd;
        MutableBoolean resultEnd = new MutableBoolean();
        if(!evaluateBDD(resultEnd, endBDD, beh.getEnd())) {
            logger.error("Something went wrong");
            return false;
        }

        if(resultStart.isTrue() && resultEnd.isFalse()) {
            falling.add(beh);
            //System.out.println("uups? falling?");
        } else if(resultStart.isFalse() && resultEnd.isTrue()) {
            rising.add(beh);
        } else if(resultStart.isFalse() && resultEnd.isFalse()) {
            constant.add(beh);
        } else {
            logger.error("Const 1 should not happen");
            return false;
        }
        //System.out.println(resultStart.booleanValue() + "=>" + resultEnd.booleanValue() + " : " + beh);
    }
    return true;
}

public boolean createOrAssociate(final Changeset changeset, final Set<String> extractedIssues)
{
    final MutableBoolean wasCreated = new MutableBoolean(false);
    ChangesetMapping changesetMapping = activeObjects.executeInTransaction(new TransactionCallback<ChangesetMapping>()
    {
        @Override
        public ChangesetMapping doInTransaction()
        {
            ChangesetMapping chm = getChangesetMapping(changeset);
            if (chm == null)
            {
                chm = activeObjects.create(ChangesetMapping.class);
                fillProperties(changeset, chm);
                chm.save();
                wasCreated.setValue(true);
            }

            associateRepositoryToChangeset(chm, changeset.getRepositoryId());
            if (extractedIssues != null)
            {
                associateIssuesToChangeset(chm, extractedIssues);
            }

            return chm;
        }
    });

    changeset.setId(changesetMapping.getID());
    return wasCreated.booleanValue();
}

@Test
public void simpleEnqueueDequeue()
{
  SimpleDoneQueueManager<Query, Void> sdqqm = new SimpleDoneQueueManager<Query, Void>();

  sdqqm.setup(null);
  sdqqm.beginWindow(0);

  Query query = new MockQuery("1");
  sdqqm.enqueue(query, null, new MutableBoolean(false));

  QueryBundle<Query, Void, MutableBoolean> qb = sdqqm.dequeue();

  Assert.assertEquals("Should return same query.", query, qb.getQuery());
  qb = sdqqm.dequeue();
  Assert.assertEquals("Should return back null.", null, qb);

  sdqqm.endWindow();
  sdqqm.beginWindow(1);

  qb = sdqqm.dequeue();
  Assert.assertEquals("Should return same query.", query, qb.getQuery());
  qb = sdqqm.dequeue();
  Assert.assertEquals("Should return back null.", null, qb);

  sdqqm.endWindow();
  sdqqm.teardown();
}

@Test
public void simpleExpire1()
{
  SimpleDoneQueueManager<Query, Void> sdqqm = new SimpleDoneQueueManager<Query, Void>();

  sdqqm.setup(null);
  sdqqm.beginWindow(0);

  Query query = new MockQuery("1");
  sdqqm.enqueue(query, null, new MutableBoolean(false));

  QueryBundle<Query, Void, MutableBoolean> qb = sdqqm.dequeue();

  Assert.assertEquals("Should return same query.", query, qb.getQuery());
  qb.getQueueContext().setValue(true);

  qb = sdqqm.dequeue();
  Assert.assertEquals("Should return back null.", null, qb);

  sdqqm.endWindow();
  sdqqm.beginWindow(1);

  qb = sdqqm.dequeue();
  Assert.assertEquals("Should return back null.", null, qb);

  sdqqm.endWindow();
  sdqqm.teardown();
}

@Test
public void expiredTestBlocking() throws Exception
{
  SimpleDoneQueueManager<Query, Void> sdqqm = new SimpleDoneQueueManager<Query, Void>();

  sdqqm.setup(null);
  sdqqm.beginWindow(0);

  Query query = new MockQuery("1");
  MutableBoolean queueContext = new MutableBoolean(false);
  sdqqm.enqueue(query, null, queueContext);

  Assert.assertEquals(1, sdqqm.getNumLeft());
  Assert.assertEquals(sdqqm.getNumPermits(), sdqqm.getNumLeft());
  QueryBundle<Query, Void, MutableBoolean> qb = sdqqm.dequeueBlock();
  Assert.assertEquals(0, sdqqm.getNumLeft());
  Assert.assertEquals(sdqqm.getNumPermits(), sdqqm.getNumLeft());

  sdqqm.endWindow();

  sdqqm.beginWindow(1);

  Assert.assertEquals(1, sdqqm.getNumLeft());
  Assert.assertEquals(sdqqm.getNumPermits(), sdqqm.getNumLeft());

  queueContext.setValue(true);
  testBlocking(sdqqm);

  Assert.assertEquals(0, sdqqm.getNumLeft());
  Assert.assertEquals(sdqqm.getNumPermits(), sdqqm.getNumLeft());

  sdqqm.endWindow();
  sdqqm.teardown();
}

@Test
public void simpleExpire1ThenBlock()
{
  SimpleDoneQueueManager<Query, Void> sdqqm = new SimpleDoneQueueManager<Query, Void>();

  sdqqm.setup(null);
  sdqqm.beginWindow(0);

  Query query = new MockQuery("1");
  sdqqm.enqueue(query, null, new MutableBoolean(false));

  QueryBundle<Query, Void, MutableBoolean> qb = sdqqm.dequeue();

  Assert.assertEquals("Should return same query.", query, qb.getQuery());
  qb.getQueueContext().setValue(true);

  qb = sdqqm.dequeue();
  Assert.assertEquals("Should return back null.", null, qb);

  sdqqm.endWindow();
  sdqqm.beginWindow(1);

  qb = sdqqm.dequeue();
  Assert.assertEquals("Should return back null.", null, qb);

  sdqqm.endWindow();
  sdqqm.teardown();
}

@Test
public void simpleExpireBlockThenUnblock() throws Exception
{
  SimpleDoneQueueManager<Query, Void> sdqqm = new SimpleDoneQueueManager<Query, Void>();

  sdqqm.setup(null);
  sdqqm.beginWindow(0);

  Query query = new MockQuery("1");
  MutableBoolean expire = new MutableBoolean(false);
  sdqqm.enqueue(query, null, expire);

  sdqqm.endWindow();
  sdqqm.beginWindow(1);

  //Expire
  expire.setValue(true);

  ExceptionSaverExceptionHandler eseh = new ExceptionSaverExceptionHandler();
  testBlockingNoStop(sdqqm, eseh);

  query = new MockQuery("2");
  sdqqm.enqueue(query, null, new MutableBoolean(false));

  Thread.sleep(1000);

  Assert.assertNull(eseh.getCaughtThrowable());

  sdqqm.endWindow();
  sdqqm.teardown();
}

@SuppressWarnings({"deprecation", "CallToThreadStopSuspendOrResumeManager"})
private void testBlocking(SimpleDoneQueueManager<Query, Void> sdqqm) throws InterruptedException
{
  Thread thread = new Thread(new BlockedThread<Query, Void, MutableBoolean>(sdqqm));
  //thread.setUncaughtExceptionHandler(new RethrowExceptionHandler(Thread.currentThread()));
  thread.start();
  Thread.sleep(100);

  Assert.assertEquals(Thread.State.WAITING, thread.getState());

  thread.stop();
}

private boolean putInternal(K key, V value, Timestamp timestamp) {
    counter.incrementCount();
    Timestamp removed = removedItems.get(key);
    if (removed != null && removed.isNewerThan(timestamp)) {
        log.debug("ecmap - removed was newer {}", value);
        return false;
    }

    final MutableBoolean updated = new MutableBoolean(false);

    items.compute(key, (k, existing) -> {
        if (existing != null && existing.isNewerThan(timestamp)) {
            updated.setFalse();
            return existing;
        } else {
            updated.setTrue();
            return new Timestamped<>(value, timestamp);
        }
        });

    boolean success = updated.booleanValue();
    if (!success) {
        log.debug("ecmap - existing was newer {}", value);
    }

    if (success && removed != null) {
        removedItems.remove(key, removed);
    }

    if (success && persistent) {
        persistentStore.put(key, value, timestamp);
    }

    return success;
}

private void putInternal(K key, V value, Timestamp timestamp) {
    byte[] keyBytes = serializer.encode(key);
    byte[] removedBytes = tombstones.get(keyBytes);

    Timestamp removed = removedBytes == null ? null :
                        serializer.decode(removedBytes);
    if (removed != null && removed.isNewerThan(timestamp)) {
        return;
    }

    final MutableBoolean updated = new MutableBoolean(false);

    items.compute(keyBytes, (k, existingBytes) -> {
        Timestamped<V> existing = existingBytes == null ? null :
                                  serializer.decode(existingBytes);
        if (existing != null && existing.isNewerThan(timestamp)) {
            updated.setFalse();
            return existingBytes;
        } else {
            updated.setTrue();
            return serializer.encode(new Timestamped<>(value, timestamp));
        }
    });

    boolean success = updated.booleanValue();

    if (success && removed != null) {
        tombstones.remove(keyBytes, removedBytes);
    }

    database.commit();
}

private void removeInternal(K key, Timestamp timestamp) {
    byte[] keyBytes = serializer.encode(key);

    final MutableBoolean updated = new MutableBoolean(false);

    items.compute(keyBytes, (k, existingBytes) -> {
        Timestamp existing = existingBytes == null ? null :
                             serializer.decode(existingBytes);
        if (existing != null && existing.isNewerThan(timestamp)) {
            updated.setFalse();
            return existingBytes;
        } else {
            updated.setTrue();
            // remove from items map
            return null;
        }
    });

    if (!updated.booleanValue()) {
        return;
    }

    byte[] timestampBytes = serializer.encode(timestamp);
    byte[] removedBytes = tombstones.get(keyBytes);

    Timestamp removedTimestamp = removedBytes == null ? null :
                                 serializer.decode(removedBytes);
    if (removedTimestamp == null) {
        tombstones.putIfAbsent(keyBytes, timestampBytes);
    } else if (timestamp.isNewerThan(removedTimestamp)) {
        tombstones.replace(keyBytes, removedBytes, timestampBytes);
    }

    database.commit();
}

@Test
public void testHandlerShouldBeCalledIfUnspecificEvent() {
  final MutableBoolean handled = new MutableBoolean(false);
  Consumer<IAmAnEvent> handler = new Consumer<IAmAnEvent>() {
    @Override
    public void accept(IAmAnEvent event) {
      handled.setTrue();
    }
  };
  cut.registerHandler(handler);
  cut.send(new MockEvent());
  assertThat(handled.getValue(), is(true));
}

public void handleThrowable(Throwable t1, ServerName serverName,
    MutableBoolean couldNotCommunicateWithServer,
    MutableBoolean guaranteedClientSideOnly) throws IOException {
  Throwable t2 = ClientExceptionsUtil.translatePFFE(t1);
  boolean isLocalException = !(t2 instanceof RemoteException);

  if ((isLocalException && ClientExceptionsUtil.isConnectionException(t2))) {
    couldNotCommunicateWithServer.setValue(true);
    guaranteedClientSideOnly.setValue(!(t2 instanceof CallTimeoutException));
    handleFailureToServer(serverName, t2);
  }
}

private void doAfterResultUpdates() {
    getResult().getPlayers().forEach(playerResult -> {
        int playerId = playerResult.getPlayerId();
        Session session = room.getPlayer(playerId);

        // If match was not in training mode
        if (getRoom().trainingFactorAllowsRewards()) {
            updatePlayerHistory(playerResult);

            if (playerResult.hasReward()) {
                MutableBoolean mustNotifyExpiration = new MutableBoolean(false);

                // Decrease by 1 the remain usages of usage based items
                session.getCache().getItems(connection).values().stream()
                        .filter(Item::isSelectedUsageItem)
                        .forEach(item -> {
                            item.sumUsages((short) -1);

                            // Update the item in the database
                            PlayerInfo.setInventoryItem(item, playerId, getConnection());

                            // If the item expired
                            if (item.getUsages() <= 0) {
                                mustNotifyExpiration.setTrue();
                            }
                        });

                if (mustNotifyExpiration.isTrue()) {
                    CharacterManager.sendItemList(getRoom().getPlayer(playerId));
                }
            }
        }
    });
}

public static void playerReady(Session session, ClientMessage msg) {
    int roomId = msg.readShort();
    int playerId = session.getPlayerId();

    if (session.getRoomId() == roomId) {
        MutableBoolean roomLoading = new MutableBoolean(false);

        RoomManager.getRoomById(roomId)
                .filter(Room::isLoading)
                .ifPresent(room -> {
                    if (!room.getConfirmedPlayers().contains(playerId)) {
                        room.getConfirmedPlayers().add(playerId);

                        // Instead of waiting 5 seconds (or not), we send an udp ping immediately to
                        // the client so we can update his udp port (if changed) before match starts
                        UdpPing.sendUdpPing(session);
                    }

                    if (room.getConfirmedPlayers().size() >= room.getCurrentSize()) {
                        room.setState(RoomState.PLAYING);
                        room.setTimeStart(DateUtils.currentTimeMillis());
                        room.broadcast(MessageBuilder.playerReady((short) 0));

                        if (room.getLoadingTimeoutFuture().isCancellable()) {
                            room.getLoadingTimeoutFuture().cancel(true);
                        }
                    }

                    roomLoading.setTrue();
                });

        if (roomLoading.isFalse()) {
            session.send(MessageBuilder.playerReady((short) 0));
        }
    }
}

public static void playerReady(Session session, ClientMessage msg) {
    int roomId = msg.readShort();
    int playerId = session.getPlayerId();

    MutableBoolean roomFound = new MutableBoolean(false);

    getRoomById(roomId).filter(room -> room.isLoading() && room.isPlayerIn(playerId))
            .ifPresent(room -> {
                if (!room.getConfirmedPlayers().contains(playerId)) {
                    room.getConfirmedPlayers().add(playerId);

                    // Instead of waiting 5 seconds (or not), we send an udp ping immediately to
                    // the client so we can update his udp port (if changed) before match starts
                    UdpPing.sendUdpPing(session);
                }

                if (room.getConfirmedPlayers().size() >= room.getCurrentSize()) {
                    room.setState(RoomState.PLAYING);
                    room.setTimeStart(DateUtils.currentTimeMillis());
                    room.broadcast(MessageBuilder.playerReady((short) 0));

                    if (room.getLoadingTimeoutFuture().isCancellable()) {
                        room.getLoadingTimeoutFuture().cancel(true);
                    }
                }

                roomFound.setTrue();
            });

    if (roomFound.isFalse()) {
        session.send(MessageBuilder.playerReady((short) 0));
    }
}

public static <T> Iterable<T> iterable(Iterator<T> seq) {
    final MutableBoolean used = new MutableBoolean(false);
    return new Iterable<T>() {

        @Override
        public Iterator<T> iterator() {
            if (!used.booleanValue()) {
                used.setValue(true);
                return seq;
            } else {
                throw new IllegalStateException("only allowed to iterate this iterable once");
            }
        }
    };
}

@Nullable
private static String fieldToString(@Nonnull Object value, @Nonnull String fieldName, ToStringOptions options) {
    if (value.getClass() == Boolean.class || value.getClass() == boolean.class) {
        return (boolean) value ? fieldName : '!' + fieldName;
    }

    MutableBoolean quoted = new MutableBoolean();
    String stringValue = valueToString(value, quoted);

    if (shouldSkipField(stringValue, options, quoted)) {
        return null;
    }

    return fieldName + '=' + stringValue;
}

@SuppressWarnings({"AccessingNonPublicFieldOfAnotherObject", "OverlyComplexMethod"})
private static boolean shouldSkipField(
        @Nullable String stringValue, ToStringOptions options, MutableBoolean quoted) {
    if (options.skipNulls && stringValue == null) {
        return true;
    }

    if (options.skipEmptyStrings) {
        if (quoted != null && quoted.booleanValue()) {
            if ("''".equals(stringValue) || "\"\"".equals(stringValue)) {
                return true;
            }
        } else {
            if (isEmpty(stringValue)) {
                return true;
            }
        }
    }

    if (options.skipBlankStrings) {
        if (quoted != null && quoted.booleanValue()) {
            return isBlank(stringValue) || isBlank(stringValue.substring(1, stringValue.length() - 1));
        } else {
            return isBlank(stringValue);
        }
    }

    return false;
}

public void assertTaskCompletes(String commandLine) {
    final MutableBoolean taskCompleted = new MutableBoolean(false);
    GlobalNotificationContext.getContext().addListener(new EventListener<TaskExecutionCompletedEvent>() {

        @Override
        public void onEvent(TaskExecutionCompletedEvent event) {
            taskCompleted.setValue(true);
        }

    });

    String consoleOutput = invokeConsoleAndReturnSystemOut(commandLine);
    assertThat("Task did not complete. Console output was:\n" + consoleOutput, taskCompleted.toBoolean(), is(true));
}

/**
 * Ce test vérifie qu'il n'est pas possible de démarrer deux top-process avec maxTopConcurrent=1 de manière concurrente (= tipi va sérializer leurs exécutions)
 */
@Test
public void testLaunchTwoTopProcessesConcurrently() throws Exception {

    final MutableBoolean process1Lock = new MutableBoolean(true);
    datastore.put("process1Lock", process1Lock);

    // on démarre le premier process
    final long id1 = tipiFacade.launch(MaxTopOneJob.class, new VariableMap(
            RESULTS_KEY, "testLaunchTwoTopProcessesSequentially1",
            WAIT_LOCK_KEY, "process1Lock"));

    // on démarre le second process
    final long id2 = tipiFacade.launch(MaxTopOneJob.class, new VariableMap(
            RESULTS_KEY, "testLaunchTwoTopProcessesSequentially2"));

    // on laisse un peu de temps à Tipi pour tenter de démarrer le second process
    Thread.sleep(2000);
    Assert.assertTrue(tipiFacade.isRunning(id1)); // le premier process doit être démarré
    Assert.assertTrue(tipiFacade.isRunning(id2)); // le second process doit aussi être démarré (dans le sens : une demande de démarrage a été faite)
    Assert.assertTrue(tipiFacade.isProcessScheduled(id1)); // le premier process doit être en cours d'exécution
    Assert.assertFalse(tipiFacade.isProcessScheduled(id2)); // le second process ne doit pas être en cours d'exécution

    // on libère le lock du premier process
    //noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (process1Lock) {
        process1Lock.setValue(false);
        process1Lock.notifyAll();
    }

    // on attend le fin d'exécution du premier process
    waitWhileRunning(id1, 5000);

    // on attend le fin d'exécution du second process
    waitWhileRunning(id2, 5000);

    // on vérifie que tout s'est bien passé pour le premier process
    final Boolean runned1 = (Boolean) datastore.get("testLaunchTwoTopProcessesSequentially1");
    Assert.assertTrue(runned1);

    // on vérifie que tout s'est bien passé pour le second process
    final Boolean runned2 = (Boolean) datastore.get("testLaunchTwoTopProcessesSequentially2");
    Assert.assertTrue(runned2);
}

@Override
public boolean removeBundle(QueryBundle<QUERY_TYPE, META_QUERY, MutableBoolean> queryQueueable)
{
  return queryQueueable.getQueueContext().booleanValue();
}

@Override
public void addedNode(QueueListNode<QueryBundle<QUERY_TYPE, META_QUERY, MutableBoolean>> queryQueueable)
{
  semaphore.release();
}