import java.util.concurrent.Semaphore;

public class SemaphoreDemo {

	Semaphore	pool	= new Semaphore(10);

	public static void main(String args[]) {
		final SemaphoreDemo demo = new SemaphoreDemo();

		for (int i = 0; i < 30; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					demo.mutualExclusion();
				}

			}, "Thread" + i).start();

		}
	}

	private void mutualExclusion() {
		try {
			pool.acquire();

			System.out.println(Thread.currentThread().getName() + " inside mutual exclusive region");
			Thread.sleep(1000);

		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
		finally {
			pool.release();
			System.out.println(Thread.currentThread().getName() + " outside of mutual exclusive region");
		}
	}

}

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;

public class FindMedian<E> {
	private Queue<E>		queue;
	private Queue<E>		maxHeap;
	private Queue<E>		minHeap;
	private Comparator<E>	comparator;

	public FindMedian(Comparator<E> comparator) {
		queue = new LinkedList<>();
		maxHeap = new PriorityQueue<>(Collections.reverseOrder(comparator));
		minHeap = new PriorityQueue<>(comparator);
		this.comparator = comparator;
	}

	public void enqueue(E e) {
		if (e == null)
			throw new IllegalArgumentException();

		this.queue.add(e);

		addElementToHeap(e);

		rebalance();
	}

	public E dequeue() {
		E removeObject = this.queue.remove();
		this.maxHeap.remove(removeObject);
		this.minHeap.remove(removeObject);

		return removeObject;
	}

	public E peekMedian() {
		if (maxHeap.size() == minHeap.size()) {
			// Depends on definition
			return maxHeap.peek();
		}
		else if (maxHeap.size() > minHeap.size()) {
			return maxHeap.peek();
		}
		else {
			return minHeap.peek();
		}
	}

	private void addElementToHeap(E e) {
		E tmp = maxHeap.peek();
		if (tmp == null) {
			minHeap.add(e);
		}
		else if (comparator.compare(tmp, e) > 0) {
			maxHeap.add(e);
		}
		else {
			minHeap.add(e);
		}
	}

	private void rebalance() {
		int sizeDiff = maxHeap.size() - minHeap.size();
		if (sizeDiff > 1) {
			minHeap.add(maxHeap.remove());
		}
		else if (sizeDiff < -1) {
			maxHeap.add(minHeap.remove());
		}
	}
}

public class MailSenderTest {

    private GreenMail greenMail;
    private MimeMessage message;

    @Before
    public void setUp() throws Exception {
        greenMail = new GreenMail(ServerSetupTest.SMTP);
        greenMail.start();

        Properties properties = System.getProperties();
        properties.put("mail.smtp.host", "localhost");
        properties.put("mail.smtp.port", ServerSetupTest.SMTP.getPort());
        Session session = Session.getInstance(properties);
        message = new MimeMessage(session);
        message.setFrom(new InternetAddress("test@test.com"));
        message.setRecipients(Message.RecipientType.TO,
                InternetAddress.parse("test1@test.com", false));
        message.setSubject("subject");
        message.setText("text");
        message.setSentDate(new Date());
    }

    @After
    public void tearDown() throws Exception {
        greenMail.stop();
    }

    @Test
    public void testSend() throws Exception {
        // [Start] Replace this with your send code        
        // Sender.send(message);
        // [End]
        
        MimeMessage[] messages = greenMail.getReceivedMessages();
        Assert.assertNotNull(messages);
        Assert.assertEquals(1, messages.length);
        MimeMessage m = messages[0];
        Assert.assertEquals("subject", m.getSubject());
        Assert.assertTrue(String.valueOf(m.getContent()).contains("text"));
        Assert.assertEquals("test@test.com", m.getFrom()[0].toString());
    }
}

public class MailReceiverTest {

    private GreenMail greenMail;
    private String subject;
    private String body;

    @Before
    public void setUp() throws Exception {
        greenMail = new GreenMail(ServerSetupTest.SMTP);
        greenMail.start();

        subject = GreenMailUtil.random();
		body = GreenMailUtil.random();
		GreenMailUtil.sendTextEmailTest("test@localhost.com", "test1@localhost.com", subject, body);
    }

    @After
    public void tearDown() throws Exception {
        greenMail.stop();
    }

    @Test
    public void testReceiver() throws Exception {
        // [Start] Replace this with your receive code
        // Message message = Receiver.receive();
        // [End]
        
		Assert.assertNotNull(message);
		Assert.assertEquals(message.getTo(), "test@localhost.com");
		Assert.assertEquals(message.getFrom(), "test1@localhost.com");
		Assert.assertEquals(message.getSubject(), subject);
		Assert.assertEquals(message.getBody(), body);
    }
}

logger.debug("The new entry is "+entry+".");

logger.debug("The new entry is {}.", entry);

Object[] paramArray = {newVal, below, above};
logger.debug("Value {} was inserted between {} and {}.", paramArray);

@Provider
public class GenericExceptionMapper implements ExceptionMapper<Throwable> {

  @Override
  public Response toResponse(Throwable exception) {
    return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                   .entity(exception.getMessage())
                   .type(MediaType.APPLICATION_JSON)
                   .build();
  }
}