public synchronized <Model, Data> void append( @NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) { multiModelLoaderFactory.append(modelClass, dataClass, factory); cache.clear(); }
@NonNull synchronized <Model, Data> List<ModelLoaderFactory<? extends Model, ? extends Data>> replace( @NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) { List<ModelLoaderFactory<? extends Model, ? extends Data>> removed = remove(modelClass, dataClass); append(modelClass, dataClass, factory); return removed; }
private <X, Y> ModelLoader<X, Y> registerFactoryFor( Class<X> modelClass, Class<Y> dataClass, boolean append) { ModelLoaderFactory<X, Y> factory = mockFactory(); @SuppressWarnings("unchecked") ModelLoader<X, Y> loader = mock(ModelLoader.class); when(factory.build(eq(multiFactory))).thenReturn(loader); if (append) { multiFactory.append(modelClass, dataClass, factory); } else { multiFactory.prepend(modelClass, dataClass, factory); } return loader; }
@Test public void testRemove_returnsPreviouslyRegisteredFactories_withModelAndDataClasses() { ModelLoaderFactory<String, String> other = mockFactory(); multiFactory.append(String.class, String.class, other); multiFactory.append(String.class, String.class, firstFactory); List<ModelLoaderFactory<? extends String, ? extends String>> removed = multiFactory.remove(String.class, String.class); assertThat(removed).containsExactly(firstFactory, other); }
@Test public void testBuild_withModelAndDataClasses_excludesModelLoadersForOtherDataClasses() { multiFactory.append(String.class, String.class, firstFactory); assertThrows( NoModelLoaderAvailableException.class, new ThrowingRunnable() { @Override public void run() throws Throwable { multiFactory.build(String.class, Integer.class); } }); }
@Test public void testBuild_withModelAndDataClasses_excludesModelLoadersForOtherModelClasses() { multiFactory.append(String.class, String.class, firstFactory); assertThrows( NoModelLoaderAvailableException.class, new ThrowingRunnable() { @Override public void run() throws Throwable { multiFactory.build(Integer.class, String.class); } }); }
@Test public void testReplace_returnsPreviouslyRegisteredFactories_withModelAndDataClasses() { ModelLoaderFactory<String, String> firstOtherFactory = mockFactory(); ModelLoaderFactory<String, String> secondOtherFactory = mockFactory(); multiFactory.append(String.class, String.class, firstOtherFactory); multiFactory.append(String.class, String.class, secondOtherFactory); List<ModelLoaderFactory<? extends String, ? extends String>> removed = multiFactory.replace(String.class, String.class, firstFactory); assertThat(removed).containsExactly(firstOtherFactory, secondOtherFactory); }
@Test public void testBuild_withModelClass_excludesModelLoadersForOtherModelClasses() { multiFactory.append(String.class, String.class, firstFactory); List<ModelLoader<Integer, ?>> modelLoaders = multiFactory.build(Integer.class); assertThat(modelLoaders).doesNotContain(firstModelLoader); }
@Test public void testAppend_addsModelLoaderForModelClass() { multiFactory.append(String.class, String.class, firstFactory); List<ModelLoader<String, ?>> modelLoaders = multiFactory.build(String.class); assertThat(modelLoaders).containsExactly(firstModelLoader); }
@Test public void testAppend_addsModelLoaderForModelAndDataClass() { multiFactory.append(String.class, String.class, firstFactory); ModelLoader<String, String> modelLoader = multiFactory.build(String.class, String.class); assertThat(modelLoader).isEqualTo(firstModelLoader); }
@Test public void testBuild_withModelClass_returnsMultipleModelLoaders_ofGivenModelClassWithDifferentDataClasses() { ModelLoader<String, Integer> otherLoader = appendFactoryFor(String.class, Integer.class); multiFactory.append(String.class, String.class, firstFactory); List<ModelLoader<String, ?>> modelLoaders = multiFactory.build(String.class); assertThat(modelLoaders).containsExactly(otherLoader, firstModelLoader); }
@Test public void testBuild_withModelClass_returnsMultipleModelLoaders_ofGivenModelAndDataClasses() { ModelLoader<String, String> otherLoader = appendFactoryFor(String.class, String.class); multiFactory.append(String.class, String.class, firstFactory); List<ModelLoader<String, ?>> modelLoaders = multiFactory.build(String.class); assertThat(modelLoaders).containsExactly(otherLoader, firstModelLoader); }
@Test public void testBuild_withModelAndDataClasses_returnsMultipleModelLoaders_ofGivenModelAndDataClasses() { ModelLoader<String, String> otherLoader = appendFactoryFor(String.class, String.class); multiFactory.append(String.class, String.class, firstFactory); List<ModelLoader<String, String>> modelLoaders = buildModelLoaders(String.class, String.class); assertThat(modelLoaders).containsExactly(otherLoader, firstModelLoader); }
synchronized <Model, Data> List<ModelLoaderFactory<Model, Data>> replace(Class<Model> modelClass, Class<Data> dataClass, ModelLoaderFactory<Model, Data> factory) { List<ModelLoaderFactory<Model, Data>> removed = remove(modelClass, dataClass); append(modelClass, dataClass, factory); return removed; }
public synchronized <Model, Data> void append(Class<Model> modelClass, Class<Data> dataClass, ModelLoaderFactory<Model, Data> factory) { multiModelLoaderFactory.append(modelClass, dataClass, factory); cache.clear(); }