android.test.mock.MockContentResolver Java Examples

@Override
protected void setUp() throws Exception {
    super.setUp();

    mResolver = new MockContentResolver();
    RenamingDelegatingContext targetContextWrapper = new RenamingDelegatingContext(
            new DelegatedMockContext(getContext()), // The context that most methods are delegated to
            getContext(), // The context that file methods are delegated to
            filenamePrefix);
    mProviderContext = new IsolatedContext(mResolver, targetContextWrapper);

    ProviderInfo providerInfo = new ProviderInfo();
    providerInfo.authority = mProviderAuthority;

    mProvider = mProviderClass.newInstance();
    mProvider.attachInfo(mProviderContext, providerInfo);
    assertNotNull(mProvider);
    mResolver.addProvider(mProviderAuthority, mProvider);
}
 

@Before
public void setupMockAndViews() {
    MockitoAnnotations.initMocks(this);
    PowerMockito.mockStatic(BoxingManager.class);
    PowerMockito.mockStatic(TextUtils.class);
    PowerMockito.when(BoxingManager.getInstance()).thenReturn(mPickerManager);
    mPresenter = new PickerPresenter(mView);
    MockContentResolver contentResolver = new MockContentResolver();

    Mockito.when(mView.getAppCr()).thenReturn(contentResolver);
    PowerMockito.when(TextUtils.isEmpty(any(CharSequence.class))).thenAnswer(new Answer<Boolean>() {
        @Override
        public Boolean answer(InvocationOnMock invocation) throws Throwable {
            CharSequence charSequence = (CharSequence) invocation.getArguments()[0];
            return !(charSequence != null && charSequence.length() > 0);
        }
    });
}
 

@Override
protected void setUp() throws Exception {
  super.setUp();

  MockContentResolver mockContentResolver = new MockContentResolver();
  RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
      getContext(), getContext(), "test.");
  MockContext context = new MockContext(mockContentResolver, targetContext);
  MyTracksProvider provider = new MyTracksProvider();
  provider.attachInfo(context, null);
  mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, provider);
  setContext(context);

  providerUtils = MyTracksProviderUtils.Factory.get(context);
  engine = new SearchEngine(providerUtils);
}
 

@Override
protected void setUp() throws Exception {
  super.setUp();
  
  MockContentResolver mockContentResolver = new MockContentResolver();
  RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
      getContext(), getContext(), "test.");
  context = new MockContext(mockContentResolver, targetContext);
  MyTracksProvider provider = new MyTracksProvider();
  provider.attachInfo(context, null);
  mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, provider);
  setContext(context);

  providerUtils = MyTracksProviderUtils.Factory.get(context);
  providerUtils.deleteAllTracks(context);
}
 

public void testSimpleOperationNotifiesChangeOnSuccess() {
    final AssertionLatch latch = new AssertionLatch(1);
    final MockContext context = new MockContext() {
        @Override
        public ContentResolver getContentResolver() {
            return new MockContentResolver() {
                @Override
                public void notifyChange(final Uri u, final ContentObserver o) {
                    latch.countDown();
                }
            };
        }
    };
    final TestSimpleOperation operation = new TestSimpleOperation(Uri.EMPTY);
    operation.onSuccess(context, null);
    latch.assertComplete();
}
 

public ContentResolver getMockResolver() {
    final MockContentResolver mockContentResolver = new MockContentResolver(mTargetContext);
    for (String authority : mProviders.keySet()) {
        mockContentResolver.addProvider(authority, mProviders.get(authority));
    }
    return mockContentResolver;
}
 

public ProviderTestRule build() {
  Set<WeakReference<ContentProvider>> mProvidersRef = new HashSet<>();
  MockContentResolver resolver = new MockContentResolver();
  DelegatingContext context =
      new DelegatingContext(
          InstrumentationRegistry.getInstrumentation().getTargetContext(), prefix, resolver);

  for (Map.Entry<String, Class<? extends ContentProvider>> entry : providerClasses.entrySet()) {
    ContentProvider provider =
        createProvider(entry.getKey(), entry.getValue(), resolver, context);
    mProvidersRef.add(new WeakReference<>(provider));
  }

  return new ProviderTestRule(
      mProvidersRef, new HashSet<>(databaseArgsMap.values()), resolver, context);
}
 

private Rows initRows(String[][] data, Filter filter) {
    MockContentResolver resolver = new MockContentResolver();
    TestContentProvider provider = new TestContentProvider(getContext(), data);
    resolver.addProvider(MediaStore.AUTHORITY, provider);
    Rows rows = new Rows(resolver, new ParametersStub(), null);
    rows.setFilter(filter);
    rows.init();
    return rows;
}
 

@Before
@Override
public void setUp() throws Exception {
    // Fake content provider
    mFakeContactsContentProvider = new FakeContactsContentProvider();
    mMatrixCursor = new MatrixCursor(ContactsDictionaryConstants.PROJECTION);
    // Add the fake content provider to fake content resolver.
    final MockContentResolver contentResolver = new MockContentResolver();
    contentResolver.addProvider(ContactsContract.AUTHORITY, mFakeContactsContentProvider);
    // Add the fake content resolver to a fake context.
    final ContextWithMockContentResolver context = new ContextWithMockContentResolver(mContext);
    context.setContentResolver(contentResolver);

    mManager = new ContactsManager(context);
}
 

private Rows initRows(String[][] data, Filter filter) {
    MockContentResolver resolver = new MockContentResolver();
    TestContentProvider provider = new TestContentProvider(getContext(), data);
    resolver.addProvider(MediaStore.AUTHORITY, provider);
    Rows rows = new Rows(resolver, new ParametersStub(), null);
    rows.setFilter(filter);
    rows.init();
    return rows;
}
 

@Override
protected void setUp() throws Exception {
  super.setUp();

  MockContentResolver mockContentResolver = new MockContentResolver();
  RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
      getContext(), getContext(), "test.");
  Context context = new MockContext(mockContentResolver, targetContext);
  MyTracksProvider myTracksProvider = new MyTracksProvider();
  myTracksProvider.attachInfo(context, null);
  mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, myTracksProvider);
  setContext(context);
  myTracksProviderUtils = MyTracksProviderUtils.Factory.get(context);
  oldProviderUtilsFactory = TestingProviderUtilsFactory.installWithInstance(
      myTracksProviderUtils);

  mocksControl = EasyMock.createStrictControl();
  trackWriter = mocksControl.createMock(TrackWriter.class);

  Track track = new Track();
  track.setName(TRACK_NAME);
  track.setId(TRACK_ID);

  tracks = new Track[] {track};
  
  outputStream = new ByteArrayOutputStream();
  TrackExporterListener trackExporterListener = new TrackExporterListener() {
    
      @Override
    public void onProgressUpdate(int number, int max) {
      // Safe to ignore

    }
  };
  fileTrackExporter = new FileTrackExporter(
      myTracksProviderUtils, tracks, trackWriter, trackExporterListener);
}
 

@UsesMocks({ MyTracksProviderUtils.class, DataSource.class, TrackDataListener.class })
@Override
protected void setUp() throws Exception {
  super.setUp();
  context = new MockContext(new MockContentResolver(), new RenamingDelegatingContext(
      getContext(), getContext(), "test."));
  sharedPreferences = context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
  myTracksProviderUtils = AndroidMock.createMock(MyTracksProviderUtils.class);
  dataSource = AndroidMock.createMock(DataSource.class, context);
  trackDataManager = new TrackDataManager();
  trackDataHub = new TrackDataHub(
      context, trackDataManager, myTracksProviderUtils, TARGET_POINTS) {
      @Override
    protected DataSource newDataSource() {
      return dataSource;
    }

      @Override
    protected void runInHanderThread(Runnable runnable) {
      // Run everything in the same thread
      runnable.run();
    }
  };

  trackDataListener1 = AndroidMock.createStrictMock(
      "trackDataListener1", TrackDataListener.class);
  trackDataListener2 = AndroidMock.createStrictMock(
      "trackDataListener2", TrackDataListener.class);
  PreferencesUtils.setLong(context, R.string.recording_track_id_key, TRACK_ID);
}
 

private ContentProvider createProvider(
    String auth,
    Class<? extends ContentProvider> clazz,
    MockContentResolver resolver,
    Context context) {
  ContentProvider provider;

  try {
    provider = clazz.getConstructor().newInstance();
  } catch (NoSuchMethodException me) {
    Log.e(
        TAG,
        "NoSuchMethodException occurred when trying create new Instance for "
            + clazz.toString());
    throw new RuntimeException(me);
  } catch (InvocationTargetException ite) {
    Log.e(
        TAG,
        "InvocationTargetException occurred when trying create new Instance for "
            + clazz.toString());
    throw new RuntimeException(ite);
  } catch (IllegalAccessException iae) {
    Log.e(
        TAG,
        "IllegalAccessException occurred when trying create new Instance for "
            + clazz.toString());
    throw new RuntimeException(iae);
  } catch (InstantiationException ie) {
    Log.e(
        TAG,
        "InstantiationException occurred when trying create new Instance for "
            + clazz.toString());
    throw new RuntimeException(ie);
  }

  ProviderInfo providerInfo = new ProviderInfo();
  providerInfo.authority = auth;
  // attachInfo will call ContentProvider.onCreate(), so will refresh the context
  // used by ContentProvider.
  provider.attachInfo(context, providerInfo);
  resolver.addProvider(providerInfo.authority, provider);
  return provider;
}
 

private RequestDispatcher getDispatcher() {
	final MockContentResolver resolver = new MockContentResolver();
	resolver.addProvider(AUTHORITY, mProvider);
	final RequestExecutor executor = new RequestExecutor.DefaultRequestExecutor(resolver);
	return new SupportRequestDispatcher(executor, getContext(), mLoaderManager);
}
 

private RequestDispatcher getDispatcher() {
	final MockContentResolver resolver = new MockContentResolver();
	resolver.addProvider(AUTHORITY, mProvider);
	final RequestExecutor executor = new RequestExecutor.DefaultRequestExecutor(resolver);
	return new ModernRequestDispatcher(executor, getContext(), mLoaderManager);
}
 

@Override
public ContentResolver getContentResolver() {
    final MockContentResolver resolver = new MockContentResolver();
    resolver.addProvider(AUTHORITY, mProvider);
    return resolver;
}
 

/**
 * Tests the method {@link MyTracksProviderUtilsImpl#createContentValues(Waypoint)}.
 */
public void testCreateContentValues_waypoint() {
  long trackId = System.currentTimeMillis();
  Track track = getTrack(trackId, 10);
  providerUtils.insertTrack(track);
  // Bottom
  long startTime = 1000L;
  // AverageSpeed
  double minGrade = -20.11;
  TripStatistics statistics = new TripStatistics();
  statistics.setStartTime(startTime);
  statistics.setStopTime(2500L);
  statistics.setTotalTime(1500L);
  statistics.setMovingTime(700L);
  statistics.setTotalDistance(750.0);
  statistics.setTotalElevationGain(50.0);
  statistics.setMaxSpeed(60.0);
  statistics.setMaxElevation(1250.0);
  statistics.setMinElevation(1200.0);
  statistics.setMaxGrade(15.0);
  statistics.setMinGrade(minGrade);
  statistics.setBounds(-10000, 20000, 30000, -40000);
  // Insert at first.
  Waypoint waypoint = new Waypoint();
  waypoint.setDescription(TEST_DESC);
  waypoint.setType(WaypointType.STATISTICS);
  waypoint.setTripStatistics(statistics);
  
  Location loc = new Location("test");
  loc.setLatitude(22);
  loc.setLongitude(22);
  loc.setAccuracy((float) 1 / 100.0f);
  loc.setAltitude(2.5);
  waypoint.setLocation(loc);
  providerUtils.insertWaypoint(waypoint);

  MyTracksProviderUtilsImpl myTracksProviderUtilsImpl = new MyTracksProviderUtilsImpl(
      new MockContentResolver());
  
  long waypointId = System.currentTimeMillis();
  waypoint.setId(waypointId);
  ContentValues contentValues = myTracksProviderUtilsImpl.createContentValues(waypoint);
  assertEquals(waypointId, contentValues.get(WaypointsColumns._ID));
  assertEquals(22 * 1000000, contentValues.get(WaypointsColumns.LONGITUDE));
  assertEquals(TEST_DESC, contentValues.get(WaypointsColumns.DESCRIPTION));
  assertEquals(startTime, contentValues.get(WaypointsColumns.STARTTIME));
  assertEquals(minGrade, contentValues.get(WaypointsColumns.MINGRADE));
}
 

public MockContentResolver getMockContentResolver() {
    return mResolver;
}