@NonNull @SuppressWarnings("unchecked") private <Model, Data> ModelLoader<Model, Data> build(@NonNull Entry<?, ?> entry) { return (ModelLoader<Model, Data>) Preconditions.checkNotNull(entry.factory.build(this)); }
private <Model, Data> void tearDown( @NonNull List<ModelLoaderFactory<? extends Model, ? extends Data>> factories) { for (ModelLoaderFactory<? extends Model, ? extends Data> factory : factories) { factory.teardown(); } }
@Before public void setUp() { MockitoAnnotations.initMocks(this); throwableListPool = FactoryPools.threadSafeList(); multiFactory = new MultiModelLoaderFactory(throwableListPool, multiModelLoaderFactory); when(firstFactory.build(eq(multiFactory))).thenReturn(firstModelLoader); when(secondFactory.build(eq(multiFactory))).thenReturn(secondModelLoader); }
/** * Removes any {@link ModelLoaderFactory} registered for the given model and resource classes if one exists. If a * {@link ModelLoaderFactory} is removed, its {@link ModelLoaderFactory#teardown()}} method will be called. * * @deprecated Use {@link #register(Class, Class, ModelLoaderFactory)} to replace * a registered loader rather than simply removing it. * @param modelClass The model class. * @param resourceClass The resource class. * @param <T> The type of the model. * @param <Y> The type of the resource. */ @Deprecated public <T, Y> void unregister(Class<T> modelClass, Class<Y> resourceClass) { ModelLoaderFactory<T, Y> removed = loaderFactory.unregister(modelClass, resourceClass); if (removed != null) { removed.teardown(); } }
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; }
ModelLoaderFactory<T, Y> removed = loaderFactory.register(modelClass, resourceClass, factory); if (removed != null) { removed.teardown();
@SuppressWarnings("unchecked") private <T> void registerMockStreamModelLoader(final Class<T> modelClass) { ModelLoader<T, InputStream> modelLoader = mockStreamModelLoader(modelClass); ModelLoaderFactory<T, InputStream> modelLoaderFactory = mock(ModelLoaderFactory.class); when(modelLoaderFactory.build(isA(MultiModelLoaderFactory.class))).thenReturn(modelLoader); Glide.get(context).getRegistry() .prepend(modelClass, InputStream.class, modelLoaderFactory); }
private <Model, Data> void tearDown(List<ModelLoaderFactory<Model, Data>> factories) { for (ModelLoaderFactory<?, ?> factory : factories) { factory.teardown(); } }
@SuppressWarnings("unchecked") private <T, Z> void registerFailFactory(Class<T> failModel, Class<Z> failResource) { DataFetcher<Z> failFetcher = mock(DataFetcher.class); doAnswer(new Util.CallDataReady<>(null)) .when(failFetcher) .loadData(isA(Priority.class), isA(DataFetcher.DataCallback.class)); when(failFetcher.getDataClass()).thenReturn(failResource); ModelLoader<T, Z> failLoader = mock(ModelLoader.class); when(failLoader.buildLoadData(isA(failModel), anyInt(), anyInt(), isA(Options.class))) .thenReturn(new ModelLoader.LoadData<>(mock(Key.class), failFetcher)); when(failLoader.handles(isA(failModel))).thenReturn(true); ModelLoaderFactory<T, Z> failFactory = mock(ModelLoaderFactory.class); when(failFactory.build(isA(MultiModelLoaderFactory.class))).thenReturn(failLoader); Glide.get(context).getRegistry().prepend(failModel, failResource, failFactory); }
private static <X, Y> void registerMockModelLoader(Class<X> modelClass, Class<Y> dataClass, Y loadedData, Registry registry) { DataFetcher<Y> mockStreamFetcher = mock(DataFetcher.class); when(mockStreamFetcher.getDataClass()).thenReturn(dataClass); try { doAnswer(new Util.CallDataReady<>(loadedData)) .when(mockStreamFetcher) .loadData(isA(Priority.class), isA(DataFetcher.DataCallback.class)); } catch (Exception e) { throw new RuntimeException(e); } ModelLoader<X, Y> mockUrlLoader = mock(ModelLoader.class); when(mockUrlLoader.buildLoadData(isA(modelClass), anyInt(), anyInt(), isA(Options.class))) .thenReturn(new ModelLoader.LoadData<>(mock(Key.class), mockStreamFetcher)); when(mockUrlLoader.handles(isA(modelClass))).thenReturn(true); ModelLoaderFactory<X, Y> mockUrlLoaderFactory = mock(ModelLoaderFactory.class); when(mockUrlLoaderFactory.build(isA(MultiModelLoaderFactory.class))) .thenReturn(mockUrlLoader); registry.replace(modelClass, dataClass, mockUrlLoaderFactory); }
result = factory.build(context, this); cacheModelLoader(modelClass, resourceClass, result); } else {
@SuppressWarnings("unchecked") private <Model, Data> ModelLoader<Model, Data> build(Entry<?, ?> entry) { return (ModelLoader<Model, Data>) Preconditions.checkNotNull(entry.factory.build(this)); }