/** * Tests whether the priority is set on newly created threads. */ @Test public void testNewThreadPriority() { final ThreadFactory wrapped = EasyMock.createMock(ThreadFactory.class); final Runnable r = EasyMock.createMock(Runnable.class); final Thread t = new Thread(); EasyMock.expect(wrapped.newThread(r)).andReturn(t); EasyMock.replay(wrapped, r); final int priority = Thread.NORM_PRIORITY + 1; final BasicThreadFactory factory = builder.wrappedFactory(wrapped).priority( priority).build(); assertSame("Wrong thread", t, factory.newThread(r)); assertEquals("Wrong priority", priority, t.getPriority()); EasyMock.verify(wrapped, r); }
/** * Tests whether the original priority is not changed if no priority is * specified. */ @Test public void testNewThreadNoPriority() { final ThreadFactory wrapped = EasyMock.createMock(ThreadFactory.class); final Runnable r = EasyMock.createMock(Runnable.class); final int orgPriority = Thread.NORM_PRIORITY + 1; final Thread t = new Thread(); t.setPriority(orgPriority); EasyMock.expect(wrapped.newThread(r)).andReturn(t); EasyMock.replay(wrapped, r); final BasicThreadFactory factory = builder.wrappedFactory(wrapped).build(); assertSame("Wrong thread", t, factory.newThread(r)); assertEquals("Wrong priority", orgPriority, t.getPriority()); EasyMock.verify(wrapped, r); }
/** * Helper method for testing whether the daemon flag is taken into account. * * @param flag the value of the flag */ private void checkDaemonFlag(final boolean flag) { final ThreadFactory wrapped = EasyMock.createMock(ThreadFactory.class); final Runnable r = EasyMock.createMock(Runnable.class); final Thread t = new Thread(); EasyMock.expect(wrapped.newThread(r)).andReturn(t); EasyMock.replay(wrapped, r); final BasicThreadFactory factory = builder.wrappedFactory(wrapped).daemon( flag).build(); assertSame("Wrong thread", t, factory.newThread(r)); assertTrue("Wrong daemon flag", flag == t.isDaemon()); EasyMock.verify(wrapped, r); }
/** * Tests whether the daemon flag is not touched on newly created threads if * it is not specified. */ @Test public void testNewThreadNoDaemonFlag() { final ThreadFactory wrapped = EasyMock.createMock(ThreadFactory.class); final Runnable r1 = EasyMock.createMock(Runnable.class); final Runnable r2 = EasyMock.createMock(Runnable.class); final Thread t1 = new Thread(); final Thread t2 = new Thread(); t1.setDaemon(true); EasyMock.expect(wrapped.newThread(r1)).andReturn(t1); EasyMock.expect(wrapped.newThread(r2)).andReturn(t2); EasyMock.replay(wrapped, r1, r2); final BasicThreadFactory factory = builder.wrappedFactory(wrapped).build(); assertSame("Wrong thread 1", t1, factory.newThread(r1)); assertTrue("No daemon thread", t1.isDaemon()); assertSame("Wrong thread 2", t2, factory.newThread(r2)); assertFalse("A daemon thread", t2.isDaemon()); EasyMock.verify(wrapped, r1, r2); }
/** * Tests whether the naming pattern is applied to new threads. */ @Test public void testNewThreadNamingPattern() { final ThreadFactory wrapped = EasyMock.createMock(ThreadFactory.class); final Runnable r = EasyMock.createMock(Runnable.class); final int count = 12; for (int i = 0; i < count; i++) { EasyMock.expect(wrapped.newThread(r)).andReturn(new Thread()); } EasyMock.replay(wrapped, r); final BasicThreadFactory factory = builder.wrappedFactory(wrapped) .namingPattern(PATTERN).build(); for (int i = 0; i < count; i++) { final Thread t = factory.newThread(r); assertEquals("Wrong thread name", String.format(PATTERN, Long .valueOf(i + 1)), t.getName()); assertEquals("Wrong thread count", i + 1, factory.getThreadCount()); } EasyMock.verify(wrapped, r); }
/** * Tests the reset() method of the builder. */ @Test public void testBuilderReset() { final ThreadFactory wrappedFactory = EasyMock.createMock(ThreadFactory.class); final Thread.UncaughtExceptionHandler exHandler = EasyMock .createMock(Thread.UncaughtExceptionHandler.class); EasyMock.replay(wrappedFactory, exHandler); builder.namingPattern(PATTERN).daemon(true).priority( Thread.MAX_PRIORITY).uncaughtExceptionHandler(exHandler) .wrappedFactory(wrappedFactory); builder.reset(); final BasicThreadFactory factory = builder.build(); checkFactoryDefaults(factory); assertNotSame("Wrapped factory not reset", wrappedFactory, factory .getWrappedFactory()); EasyMock.verify(wrappedFactory, exHandler); }
/** * Tests whether the original exception handler is not touched if none is * specified. */ @Test public void testNewThreadNoExHandler() { final ThreadFactory wrapped = EasyMock.createMock(ThreadFactory.class); final Runnable r = EasyMock.createMock(Runnable.class); final Thread.UncaughtExceptionHandler handler = EasyMock .createMock(Thread.UncaughtExceptionHandler.class); final Thread t = new Thread(); t.setUncaughtExceptionHandler(handler); EasyMock.expect(wrapped.newThread(r)).andReturn(t); EasyMock.replay(wrapped, r, handler); final BasicThreadFactory factory = builder.wrappedFactory(wrapped).build(); assertSame("Wrong thread", t, factory.newThread(r)); assertEquals("Wrong exception handler", handler, t .getUncaughtExceptionHandler()); EasyMock.verify(wrapped, r, handler); } }
/** * Tests whether the exception handler is set if one is provided. */ @Test public void testNewThreadExHandler() { final ThreadFactory wrapped = EasyMock.createMock(ThreadFactory.class); final Runnable r = EasyMock.createMock(Runnable.class); final Thread.UncaughtExceptionHandler handler = EasyMock .createMock(Thread.UncaughtExceptionHandler.class); final Thread t = new Thread(); EasyMock.expect(wrapped.newThread(r)).andReturn(t); EasyMock.replay(wrapped, r, handler); final BasicThreadFactory factory = builder.wrappedFactory(wrapped) .uncaughtExceptionHandler(handler).build(); assertSame("Wrong thread", t, factory.newThread(r)); assertEquals("Wrong exception handler", handler, t .getUncaughtExceptionHandler()); EasyMock.verify(wrapped, r, handler); }
/** * Tests whether the thread name is not modified if no naming pattern is * set. */ @Test public void testNewThreadNoNamingPattern() { final ThreadFactory wrapped = EasyMock.createMock(ThreadFactory.class); final Runnable r = EasyMock.createMock(Runnable.class); final String name = "unchangedThreadName"; final Thread t = new Thread(name); EasyMock.expect(wrapped.newThread(r)).andReturn(t); EasyMock.replay(wrapped, r); final BasicThreadFactory factory = builder.wrappedFactory(wrapped).build(); assertSame("Wrong thread", t, factory.newThread(r)); assertEquals("Name was changed", name, t.getName()); EasyMock.verify(wrapped, r); }
/** * Tests whether reset() is automatically called after build(). */ @Test public void testBuilderResetAfterBuild() { builder.wrappedFactory(EasyMock.createNiceMock(ThreadFactory.class)) .namingPattern(PATTERN).daemon(true).build(); checkFactoryDefaults(builder.build()); }
/** * Tries to set a null wrapped factory. */ @Test(expected = NullPointerException.class) public void testBuildWrappedFactoryNull() { builder.wrappedFactory(null); }