/*
* Copyright (C) 2010 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.util.concurrent;
import static com.google.common.truth.Truth.assertThat;
import com.google.common.testing.NullPointerTester;
import junit.framework.TestCase;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
/**
* Tests for ThreadFactoryBuilder.
*
* @author Kurt Alfred Kluever
* @author Martin Buchholz
*/
public class ThreadFactoryBuilderTest extends TestCase {
private final Runnable monitoredRunnable = new Runnable() {
@Override public void run() {
completed = true;
}
};
private static final UncaughtExceptionHandler UNCAUGHT_EXCEPTION_HANDLER =
new UncaughtExceptionHandler() {
@Override public void uncaughtException(Thread t, Throwable e) {
// No-op
}
};
private ThreadFactoryBuilder builder;
private volatile boolean completed = false;
@Override public void setUp() {
builder = new ThreadFactoryBuilder();
}
public void testThreadFactoryBuilder_defaults() throws InterruptedException {
ThreadFactory threadFactory = builder.build();
Thread thread = threadFactory.newThread(monitoredRunnable);
checkThreadPoolName(thread, 1);
Thread defaultThread =
Executors.defaultThreadFactory().newThread(monitoredRunnable);
assertEquals(defaultThread.isDaemon(), thread.isDaemon());
assertEquals(defaultThread.getPriority(), thread.getPriority());
assertSame(defaultThread.getThreadGroup(), thread.getThreadGroup());
assertSame(defaultThread.getUncaughtExceptionHandler(),
thread.getUncaughtExceptionHandler());
assertFalse(completed);
thread.start();
thread.join();
assertTrue(completed);
// Creating a new thread from the same ThreadFactory will have the same
// pool ID but a thread ID of 2.
Thread thread2 = threadFactory.newThread(monitoredRunnable);
checkThreadPoolName(thread2, 2);
assertEquals(
thread.getName().substring(0, thread.getName().lastIndexOf('-')),
thread2.getName().substring(0, thread.getName().lastIndexOf('-')));
// Building again should give us a different pool ID.
ThreadFactory threadFactory2 = builder.build();
Thread thread3 = threadFactory2.newThread(monitoredRunnable);
checkThreadPoolName(thread3, 1);
assertThat(
thread2.getName().substring(0, thread.getName().lastIndexOf('-')))
.isNotEqualTo(
thread3.getName().substring(0, thread.getName().lastIndexOf('-')));
}
private static void checkThreadPoolName(Thread thread, int threadId) {
assertTrue(thread.getName().matches("^pool-\\d+-thread-" + threadId + "$"));
}
public void testNameFormatWithPercentS_custom() {
String format = "super-duper-thread-%s";
ThreadFactory factory = builder.setNameFormat(format).build();
for (int i = 0; i < 11; i++) {
assertEquals(String.format(format, i),
factory.newThread(monitoredRunnable).getName());
}
}
public void testNameFormatWithPercentD_custom() {
String format = "super-duper-thread-%d";
ThreadFactory factory = builder.setNameFormat(format).build();
for (int i = 0; i < 11; i++) {
assertEquals(String.format(format, i),
factory.newThread(monitoredRunnable).getName());
}
}
public void testDaemon_false() {
ThreadFactory factory = builder.setDaemon(false).build();
Thread thread = factory.newThread(monitoredRunnable);
assertFalse(thread.isDaemon());
}
public void testDaemon_true() {
ThreadFactory factory = builder.setDaemon(true).build();
Thread thread = factory.newThread(monitoredRunnable);
assertTrue(thread.isDaemon());
}
public void testPriority_custom() {
for (int i = Thread.MIN_PRIORITY; i <= Thread.MAX_PRIORITY; i++) {
ThreadFactory factory = builder.setPriority(i).build();
Thread thread = factory.newThread(monitoredRunnable);
assertEquals(i, thread.getPriority());
}
}
public void testPriority_tooLow() {
try {
builder.setPriority(Thread.MIN_PRIORITY - 1);
fail();
} catch (IllegalArgumentException expected) {
}
}
public void testPriority_tooHigh() {
try {
builder.setPriority(Thread.MAX_PRIORITY + 1);
fail();
} catch (IllegalArgumentException expected) {
}
}
public void testUncaughtExceptionHandler_custom() {
assertEquals(UNCAUGHT_EXCEPTION_HANDLER,
builder.setUncaughtExceptionHandler(UNCAUGHT_EXCEPTION_HANDLER).build()
.newThread(monitoredRunnable).getUncaughtExceptionHandler());
}
public void testBuildMutateBuild() {
ThreadFactory factory1 = builder.setPriority(1).build();
assertEquals(1, factory1.newThread(monitoredRunnable).getPriority());
ThreadFactory factory2 = builder.setPriority(2).build();
assertEquals(1, factory1.newThread(monitoredRunnable).getPriority());
assertEquals(2, factory2.newThread(monitoredRunnable).getPriority());
}
public void testBuildTwice() {
builder.build(); // this is allowed
builder.build(); // this is *also* allowed
}
public void testBuildMutate() {
ThreadFactory factory1 = builder.setPriority(1).build();
assertEquals(1, factory1.newThread(monitoredRunnable).getPriority());
builder.setPriority(2); // change the state of the builder
assertEquals(1, factory1.newThread(monitoredRunnable).getPriority());
}
public void testThreadFactory() throws InterruptedException {
final String THREAD_NAME = "ludicrous speed";
final int THREAD_PRIORITY = 1;
final boolean THREAD_DAEMON = false;
ThreadFactory backingThreadFactory = new ThreadFactory() {
@Override public Thread newThread(Runnable r) {
Thread thread = new Thread(r);
thread.setName(THREAD_NAME);
thread.setPriority(THREAD_PRIORITY);
thread.setDaemon(THREAD_DAEMON);
thread.setUncaughtExceptionHandler(UNCAUGHT_EXCEPTION_HANDLER);
return thread;
}
};
Thread thread = builder.setThreadFactory(backingThreadFactory).build()
.newThread(monitoredRunnable);
assertEquals(THREAD_NAME, thread.getName());
assertEquals(THREAD_PRIORITY, thread.getPriority());
assertEquals(THREAD_DAEMON, thread.isDaemon());
assertSame(UNCAUGHT_EXCEPTION_HANDLER,
thread.getUncaughtExceptionHandler());
assertSame(Thread.State.NEW, thread.getState());
assertFalse(completed);
thread.start();
thread.join();
assertTrue(completed);
}
public void testNulls() {
NullPointerTester npTester = new NullPointerTester();
npTester.testAllPublicConstructors(ThreadFactoryBuilder.class);
npTester.testAllPublicStaticMethods(ThreadFactoryBuilder.class);
npTester.testAllPublicInstanceMethods(builder);
}
}