org.robolectric.annotation.Implementation Java Examples

@Implementation
protected int read(short[] audioData, int offsetInShorts, int sizeInShorts) {
  synchronized (audioDataLock) {
    if (ShadowAudioRecord.audioData.size() > 0) {
      System.arraycopy(
          Shorts.toArray(
              ShadowAudioRecord.audioData.subList(
                  0,
                  sizeInShorts > ShadowAudioRecord.audioData.size()
                      ? ShadowAudioRecord.audioData.size()
                      : sizeInShorts)),
          0,
          audioData,
          offsetInShorts,
          sizeInShorts);
      if (ShadowAudioRecord.audioData.size() > 10) {
        ShadowAudioRecord.audioData =
            ShadowAudioRecord.audioData.subList(sizeInShorts, ShadowAudioRecord.audioData.size());
      } else {
        ShadowAudioRecord.audioData.clear();
      }
      return sizeInShorts;
    }
    return 0;
  }
}
 

@Implementation
public static void initialize(Context context,
                              List<Locale> supportedLocales,
                              MatchingAlgorithm matchingAlgorithm,
                              LocalePreference preference) {
    //Block Multiple Initialization Error
    if (calls.get() == 0) {
        calls.compareAndSet(0, 1);
        Shadow.directlyOn(
                LocaleChanger.class,
                "initialize",
                ReflectionHelpers.ClassParameter.from(Context.class, context),
                ReflectionHelpers.ClassParameter.from(List.class, supportedLocales),
                ReflectionHelpers.ClassParameter.from(MatchingAlgorithm.class, matchingAlgorithm),
                ReflectionHelpers.ClassParameter.from(LocalePreference.class, preference)
        );
    }
}
 

/**
 * Validate a Bluetooth address, such as "00:43:A8:23:10:F0"
 * <p>Alphabetic characters must be uppercase to be valid.
 *
 * @param address
 *         Bluetooth address as string
 * @return true if the address is valid, false otherwise
 */
@Implementation
public static boolean checkBluetoothAddress(String address) {
    if (address == null || address.length() != ADDRESS_LENGTH) {
        return false;
    }
    for (int i = 0; i < ADDRESS_LENGTH; i++) {
        char c = address.charAt(i);
        switch (i % 3) {
            case 0:
            case 1:
                if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')) {
                    // hex character, OK
                    break;
                }
                return false;
            case 2:
                if (c == ':') {
                    break;  // OK
                }
                return false;
        }
    }
    return true;
}
 

@Implementation
public void removeStickyBroadcast(Intent intent) {
    try {
        ShadowInstrumentation instrumentation = shadowOf(ShadowInstrumentation.getInstrumentation());
        Field field = ShadowInstrumentation.class.getDeclaredField("stickyIntents");
        field.setAccessible(true);
        @SuppressWarnings("unchecked")
        Map<String, Intent> stickyIntents = (Map<String, Intent>) field.get(instrumentation);
        stickyIntents.remove(intent.getAction());
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

@SuppressWarnings("ClassNewInstance")
@Implementation
public static NetworkSecurityPolicy getInstance() {
  //noinspection OverlyBroadCatchBlock
  try {
    Class<?> shadow = Class.forName("android.security.NetworkSecurityPolicy");
    return (NetworkSecurityPolicy) shadow.newInstance();
  } catch (Exception e) {
    throw new AssertionError(e);
  }
}
 

@Implementation
public static Snackbar make(@NonNull View view, @NonNull CharSequence text, int duration) {
    Snackbar snackbar = null;

    try {
        Constructor<Snackbar> constructor = Snackbar.class.getDeclaredConstructor(ViewGroup.class);

        //just in case, maybe they'll change the method signature in the future
        if (null == constructor)
            throw new IllegalArgumentException("Seems like the constructor was not found!");


        if (Modifier.isPrivate(constructor.getModifiers())) {
            constructor.setAccessible(true);
        }

        snackbar = constructor.newInstance(findSuitableParent(view));
        snackbar.setText(text);
        snackbar.setDuration(duration);
    } catch (Exception e) {
        e.printStackTrace();
    }

    shadowOf(snackbar).text = text.toString();

    shadowSnackbars.add(shadowOf(snackbar));

    return snackbar;
}
 

@Override @Implementation
public boolean equals(Object object) {
    if (object == null) return false;
    if (this == object) return true;
    if (object.getClass() != PointF.class) return false;

    PointF that = (PointF) object;
    if (this.realPointF.x == that.x && this.realPointF.y == that.y) return true;

    return false;
}
 

@Implementation
protected void __constructor__(
    int audioSource,
    int sampleRateInHz,
    int channelConfig,
    int audioFormat,
    int bufferSizeInBytes)
    throws IllegalArgumentException {}
 

@Implementation
public static float getDesiredWidth(CharSequence source, TextPaint paint) {
  if (LONG_TEXT.equals(source)) {
    return LONG_TEXT_LENGTH;
  } else if (SHORT_TEXT.equals(source)) {
    return SHORT_TEXT_LENGTH;
  }
  return 0;
}
 

@Implementation
public static NetworkSecurityPolicy getInstance() {
    try {
        Class<?> shadow = Class.forName("android.security.NetworkSecurityPolicy");
        return (NetworkSecurityPolicy) shadow.newInstance();
    } catch (Exception e) {
        throw new AssertionError();
    }
}
 

@Implementation
public static void runAsynchronously(final Handler androidUIHandler,
                                     final Runnable call,
                                     final Runnable callback) {
  runnables.add(call);
  runnables.add(callback);
}
 

@Implementation
public static File getStorage() {
  try {
    File temp = File.createTempFile("osmdroid", "tmp");
    if (!temp.delete() || !temp.mkdirs()) {
      throw new IllegalStateException("Unable to create temporary directory.");
    }
    temp.deleteOnExit();
    return temp;
  } catch(IOException e) {
    throw new IllegalStateException("Unable to create temporary directory.");
  }
}
 

@Implementation
public static int startMethod(Object object, String method) {
  return mockTracker.startMethod(object, method);
}
 

@Implementation
public void sendResponse(@NonNull BroadcastQuery query, @Nullable byte[] responseMessage) {
    mockQueryResponseSender.sendResponse(query, responseMessage);
}
 

@Implementation
public static void endMethod(int trackingId) {
  mockTracker.endMethod(trackingId);
}
 

@Implementation
protected void stop() throws IllegalStateException {}
 

@Implementation
public void scrollTo(int x, int y) {
    super.scrollTo(x, y);
}
 

@Implementation
public static int startUrl(String url, String verb) {
  return mockTracker.startUrl(url, verb);
}
 

@Implementation
public static long getUidTxBytes(int uid) {
  return sTxBytes;
}
 

@Implementation
public static AuthenticationDomain fromPackageName(
        @NonNull Context context,
        @NonNull String packageName) {
    return sAuthDomainLookup.get(packageName);
}
 

@Implementation
public static void endMetric() {
  mockTracker.endMetric();
}
 

@Implementation
public static void prolongMetric() {
  mockTracker.prolongMetric();
}
 

@Implementation
public static void startMetric(String metricId) {
  mockTracker.startMetric(metricId);
}
 

@Implementation(minSdk = N)
protected void registerDefaultNetworkCallback(
    ConnectivityManager.NetworkCallback networkCallback) {
  defaultNetworkCallbacks.add(networkCallback);
}
 

@Implementation
public void __constructor__(int nativePicture) {
  // Do nothing.
}
 

@Implementation
public void writeStrongBinder(IBinder binder) {
  int id = nextBinderId.getAndIncrement();
  binderMap.put(id, binder);
  realObject.writeInt(id);
}
 

@Implementation
public boolean isCleartextTrafficPermitted(String hostname) {
  return true;
}
 

@SuppressWarnings("unchecked")
@Implementation
public CachingObservable<T> getObservable() {
  return new CachingObservable<>((T) cachedContent);
}
 

@Implementation
protected boolean isPackageEnabled(String packageName, UserHandle user) {
    List<String> packages = enabledPackages.get(user);
    return packages != null && packages.contains(packageName);
}
 

@Implementation
public static int startCustom(String measurementId) {
  return mockTracker.startCustom(measurementId);
}