/** *{@inheritDoc} */ @Override public <T extends ICDKObject> T newInstance(Class<T> clazz, Object... params) throws IllegalArgumentException { return factory.ofClass(clazz, params); }
/** *{@inheritDoc} */ @Override public <T extends ICDKObject> T newInstance(Class<T> clazz, Object... params) { return factory.ofClass(clazz, params); }
/** *{@inheritDoc} */ @Override public <T extends ICDKObject> T newInstance(Class<T> clazz, Object... params) throws IllegalArgumentException { return factory.ofClass(clazz, params); }
/** *{@inheritDoc} */ @Override public <T extends ICDKObject> T newInstance(Class<T> clazz, Object... params) { return factory.ofClass(clazz, params); }
/** *{@inheritDoc} */ @Override public <T extends ICDKObject> T newInstance(Class<T> clazz, Object... params) { return factory.ofClass(clazz, params); }
/** * Check we get an exception when we try to build from a non-interface. * @throws Exception */ @Test(expected = IllegalArgumentException.class) public void testOfConcrete_Params() throws Exception { IAtom mock = mock(MockedAtom.class); DynamicFactory factory = new DynamicFactory(5); assertTrue(factory.implementorsOf(IAtom.class).isEmpty()); // register the mock class factory.register(IAtom.class, mock.getClass()); // ofClass -> illegal argument, non-interface IAtom instance = factory.ofClass(mock.getClass(), this); }
/** * Unit test ensures the factory wraps up varargs into the correct * representation. This is needed as passing a uniform array will be * converted to actual varargs - this test checks both cases. */ @Test public void testOfClass_Wrapping() { DynamicFactory factory = new DynamicFactory(5); // register ICDKObject with an mock instantiator factory.register(key(ICDKObject.class, IAtom[].class), new DynamicFactory.BasicCreator<IAtom>(null) { @Override public IAtom create(Object[] objects) { return mock(IAtom.class); } }); // uniform parameter array assertNotNull(factory.ofClass(ICDKObject.class, new IAtom[]{mock(IAtom.class), mock(IAtom.class), mock(IAtom.class)})); // is equivalent to just using varargs... assertNotNull(factory.ofClass(ICDKObject.class, mock(IAtom.class), mock(IAtom.class), mock(IAtom.class))); // unless we double wrap it (which resolves to the same instantiator) assertNotNull(factory.ofClass(ICDKObject.class, new Object[]{new IAtom[]{mock(IAtom.class), mock(IAtom.class), mock(IAtom.class)}})); }
@Test public void testOfClass() throws Exception { IAtom mock = mock(MockedAtom.class); DynamicFactory factory = new DynamicFactory(5); assertTrue(factory.implementorsOf(IAtom.class).isEmpty()); // register the mock class factory.register(IAtom.class, mock.getClass()); // ofClass needs to know the inner class is coming from 'this' IAtom instance = factory.ofClass(IAtom.class, this); assertNotNull(instance); }
/** * Test mocks {@link org.openscience.cdk.DynamicFactory.CreationModifier} * and ensures the modify is called once when a registered implementation is * created. */ @Test @SuppressWarnings("unchecked") public void testRegister_WithModifier() { DynamicFactory factory = new DynamicFactory(5); IAtom mock = mock(IAtom.class); DynamicFactory.CreationModifier modifier = mock(DynamicFactory.CreationModifier.class); // ignore compiler warnings here... we're mocking so don't have a set type factory.register(IAtom.class, mock.getClass(), modifier); assertNotNull(factory.ofClass(IAtom.class)); // verify the modify method was called once verify(modifier, times(1)).modify(anyObject()); }
@SuppressWarnings("unchecked") // mocking generics @Test public void testRegister_Constructor_Modifier() throws Exception { DynamicFactory factory = new DynamicFactory(5); DynamicFactory.CreationModifier modifier = mock(DynamicFactory.CreationModifier.class); assertTrue(factory.register(ICDKObject.class, DynamicFactoryTestMock.class.getConstructor(String.class), modifier)); assertNotNull(factory.ofClass(ICDKObject.class, "empty")); // verify the modifier was invoked once verify(modifier).modify(anyObject()); }
@Test(expected = IllegalArgumentException.class) public void testOfConcrete() throws Exception { DynamicFactory factory = new DynamicFactory(5); assertTrue(factory.implementorsOf(ICDKObject.class).isEmpty()); // register the mock class factory.register(ICDKObject.class, DynamicFactoryTestMock.class); // ofClass -> illegal argument, non-interface ICDKObject instance = factory.ofClass(DynamicFactoryTestMock.class); }
@Test public void testOfClass_WithParams() throws Exception { IAtom mock = mock(MockedAtom.class); DynamicFactory factory = new DynamicFactory(5); assertTrue(factory.implementorsOf(IAtom.class).isEmpty()); // register the mock class factory.register(IAtom.class, mock.getClass()); // ofClass needs to know the inner class is coming from 'this' IAtom instance = factory.ofClass(IAtom.class, this, "C"); assertNotNull(instance); assertEquals("C", instance.getSymbol()); }
@Test public void testOfClass_Instantiator() throws Exception { DynamicFactory factory = new DynamicFactory(5); factory.register(key(IAtom.class), new DynamicFactory.BasicCreator<IAtom>(null) { @Override public IAtom create(Object[] objects) { return mock(IAtom.class); } }); assertNotNull(factory.ofClass(IAtom.class)); }