Java 类java.lang.reflect.Field 实例源码

private static AndroidNClassLoader createAndroidNClassLoader(PathClassLoader originalClassLoader, Application application) throws Exception {
    //let all element ""
    final AndroidNClassLoader androidNClassLoader = new AndroidNClassLoader("",  originalClassLoader, application);
    final Field pathListField = ShareReflectUtil.findField(originalClassLoader, "pathList");
    final Object originPathList = pathListField.get(originalClassLoader);

    // To avoid 'dex file register with multiple classloader' exception on Android O, we must keep old
    // dexPathList in original classloader so that after the newly loaded base dex was bound to
    // AndroidNClassLoader we can still load class in base dex from original classloader.

    Object newPathList = recreateDexPathList(originPathList, androidNClassLoader);

    // Update new classloader's pathList.
    pathListField.set(androidNClassLoader, newPathList);

    return androidNClassLoader;
}

protected static Map<String, SQLStmt> getStatments(Procedure proc) {
    Class<? extends Procedure> c = proc.getClass();
    Map<String, SQLStmt> stmts = new HashMap<String, SQLStmt>();
    for (Field f : c.getDeclaredFields()) {
        int modifiers = f.getModifiers();
        if (Modifier.isTransient(modifiers) == false &&
            Modifier.isPublic(modifiers) == true &&
            Modifier.isStatic(modifiers) == false) {
            try {
                Object o = f.get(proc);
                if (o instanceof SQLStmt) {
                    stmts.put(f.getName(), (SQLStmt)o);
                }
            } catch (Exception ex) {
                throw new RuntimeException("Failed to retrieve " + f + " from " + c.getSimpleName(), ex);
            }
        }
    } // FOR
    return (stmts);
}

public PostProcessor[] scan(final Object instance) {
    return FluentIterable
            .from(ReflectionUtils.getDeclaredFields(instance.getClass(), true))
            .filter(new Predicate<Field>() {
                @Override
                public boolean apply(Field input) {
                    return input.isAnnotationPresent(Random.PostProcessor.class)
                            && PostProcessor.class.isAssignableFrom(input.getType());
                }
            })
            .transform(new Function<Field, PostProcessor>() {
                @Override
                public PostProcessor apply(Field field) {
                    try {
                        if (!ReflectionUtils.makeFieldAccessible(field)) {
                            return null;
                        }
                        return (PostProcessor) field.get(instance);
                    } catch (IllegalAccessException e) {
                        throw new RandomitoException(e);
                    }
                }
            })
            .filter(Predicates.<PostProcessor>notNull())
            .toArray(PostProcessor.class);
}

@Override
protected void scanField(Field field, long offset) {
    Class<?> type = field.getType();
    if (VALUE_CLASS.isAssignableFrom(type) && !CONSTANT_VALUE_CLASS.isAssignableFrom(type)) {
        assert !Modifier.isFinal(field.getModifiers()) : "Value field must not be declared final because it is modified by register allocator: " + field;
        OperandModeAnnotation annotation = getOperandModeAnnotation(field);
        assert annotation != null : "Field must have operand mode annotation: " + field;
        EnumSet<OperandFlag> flags = getFlags(field);
        assert verifyFlags(field, type, flags);
        annotation.values.add(new ValueFieldInfo(offset, field.getName(), type, field.getDeclaringClass(), flags));
        annotation.directCount++;
    } else if (VALUE_ARRAY_CLASS.isAssignableFrom(type)) {
        OperandModeAnnotation annotation = getOperandModeAnnotation(field);
        assert annotation != null : "Field must have operand mode annotation: " + field;
        EnumSet<OperandFlag> flags = getFlags(field);
        assert verifyFlags(field, type.getComponentType(), flags);
        annotation.values.add(new ValueFieldInfo(offset, field.getName(), type, field.getDeclaringClass(), flags));
    } else {
        assert getOperandModeAnnotation(field) == null : "Field must not have operand mode annotation: " + field;
        assert field.getAnnotation(LIRInstruction.State.class) == null : "Field must not have state annotation: " + field;
        super.scanField(field, offset);
    }
}

public static SaveField[] findFieldsNotAnnotatedWith(Class<? extends Annotation> annotation, Class<?>... classes) {
    List<SaveField> fields = new LinkedList<>();
    int i = 0;

    for (Class<?> clazz : classes) {
        for (Field f : clazz.getDeclaredFields()) {
            if (!f.isAnnotationPresent(annotation)) {
                fields.add(new SaveField(f, i));
            }
            i++;
        }
        i = 0;
    }

    return fields.toArray(new SaveField[fields.size()]);
}

public EmbeddedActivityRecord startEmbeddedActivity(String bundleName) throws Exception{
    EmbeddedActivityRecord activityRecord = new EmbeddedActivityRecord();
    activityRecord.id = "embedded_"+mParent.getClass().getSimpleName();
    Field mThemeResourceF = AndroidHack.findField(mParent,"mThemeResource");
    int mThemeResource = (Integer)mThemeResourceF.get(mParent);
    Intent intent = new Intent();
    intent.setClassName(mParent,EmbeddedActivity.class.getName());
    intent.putExtra("themeId",mThemeResource);
    intent.putExtra("bundleName",bundleName);
    ActivityInfo info = intent.resolveActivityInfo(mParent.getPackageManager(), PackageManager.GET_ACTIVITIES);
    activityRecord.activity = (EmbeddedActivity) ActivityThread_startActivityNow.invoke(AndroidHack.getActivityThread(),
            mParent, activityRecord.id, intent, info, activityRecord.activity, null, null);
    activityRecord.activityInfo = info;
    return activityRecord;
}

/**
 * Get class field
 *
 * @param fieldName Field's name
 * @param type Field's type class
 * @param <V> Field's type
 * @return {@link FieldWrapper} object or empty, if field wasn't found
 */
@Contract("null, null -> fail")
@SuppressWarnings("unchecked")
public <V> Optional<FieldWrapper<V>> getField(String fieldName, Class<V> type) {
    /* Check arguments */
    if(fieldName == null) throw new IllegalStateException("Field name shouldn't be null!");
    if(type == null) throw new IllegalStateException("Field type shouldn't be null!");

    /* Try to find cached field */
    FieldInfo fieldInfo = new FieldInfo(fieldName, type);

    /* Get field */
    Integer found = FIELD_INDEX.get(fieldInfo);
    Field[] field = new Field[] { found != null ? FIELD_CACHE.get(found) : null };
    field[0] = field[0] != null ? field[0] : findDeclaredField(fieldName, type);
    if(field[0] == null) return Optional.empty();

    /* Wrap field */
    return Optional.of((FieldWrapper<V>)FIELDWRAPPER_CACHE.computeIfAbsent(found,
            k -> MethodHandleFieldWrapper.of(this, field[0], type)));
}

@Override
public List<Property> getProperties() {
    if (proxy.properties == null) {
        proxy.properties = new ArrayList<>();
        proxy.propertyAccessors = new HashMap<>();
        for (Field f : getAccessibleFields()) {
            ODataProperty annotation = f.getAnnotation(ODataProperty.class);
            if (annotation != null) {
                String name = annotation.name();
                RealAccessors<JpaOlingoEntity> accessors = new RealAccessors<>(this, f);
                proxy.properties.add(new Property(null, name, annotation.valueType(), accessors.get(this)));
                proxy.propertyAccessors.put(name, accessors);
            }
        }
    }
    return proxy.properties;
}

/**
 * 合并pipeline参数设置
 */
public void merge(PipelineParameter pipelineParameter) {
    try {
        Field[] fields = this.getClass().getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            // Skip static and final fields.
            if (Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers())) {
                continue;
            }

            ReflectionUtils.makeAccessible(field);
            Object srcValue = field.get(pipelineParameter);
            if (srcValue != null) { // 忽略null值
                field.set(this, srcValue);
            }
        }
    } catch (Exception e) {
        // ignore
    }
}

protected Map<Integer, String> getIdTable(@RTypes String resName) throws IllegalAccessException, ClassNotFoundException {
    // R资源类全称
    String rClassName = mPackageName + ".R$" + resName;

    if (mResourceCache.hasIdTableCache(rClassName)) {
        return mResourceCache.getIdTableCache(rClassName);
    }

    Class                stringRClass = Class.forName(rClassName);
    Field[]              fields       = stringRClass.getDeclaredFields();
    Map<Integer, String> idTable      = new HashMap<>();
    for (Field field : fields) {
        field.setAccessible(true);

        int    id   = (int) field.get(null);
        String name = field.getName();

        idTable.put(id, name);
    }

    mResourceCache.cacheIdTable(rClassName, idTable);

    return idTable;
}

/**
 * 获取实体类ID Class
 * @param clazz
 * @return
 */
@SuppressWarnings("unchecked")
public static Class<? extends Serializable> getDomainIDClass(Class<? extends BaseDomain> clazz){
    /**
     * 如果是联合主键实体类则返回domainID，因为联合主键类必须实现getDomainID()方法
     */
    IdClass annotation = clazz.getAnnotation(IdClass.class);
    if (annotation != null) {
        return annotation.value();
    }
    try {
        Field f = ReflectUtil.getDeclaredField(clazz, getDomainIDName(clazz));
        if (f != null) {
            return (Class<? extends Serializable>) f.getType();
        }
    } catch (Exception e) {
        e.printStackTrace();
        throw createFindIdException(clazz, e);
    }  
    throw createIDNotfoundException(clazz);
}

@PostConstruct
public void init() throws
        IllegalAccessException, NoSuchMethodException, InvocationTargetException {

    Collection<SiteOption> siteOptionKeyValues = siteOptionRepository.findAll();

    Map<String, Object> options = new Hashtable<>();
    for (SiteOption siteOption : siteOptionKeyValues) {
        options.put(siteOption.getName(), siteOption.getValue());
    }
    for (String key : options.keySet()) {
        for (Field f : this.getClass().getDeclaredFields()) {
            if (f.getName().toUpperCase().equals(key.toUpperCase())) {
                setSiteOptionProperty(key, options.get(key));
            }
        }
    }
}

@Override
public void closeBlocking() throws InterruptedException {
    super.closeBlocking();
    try {
        Field channelField = this.getClass().getSuperclass().getDeclaredField("channel");
        channelField.setAccessible(true);
        SocketChannel channel = (SocketChannel) channelField.get(this);
        if (channel != null && channel.isOpen()) {
            Socket socket = channel.socket();
            if (socket != null)
                    socket.close();
        }
    }
    catch (Exception ex) {
        System.out.println("Exception in Websocket close hack.");
        ex.printStackTrace();
    }
}

public static Set<Field> getHiddenFields(final Class<?> clazz) {
    final Field[] fields = clazz.getDeclaredFields();
    final Set<Field> declaredFieldSet = CollectionUtils.arrayToSet(fields);
    final Set<Field> ret = new HashSet<>();

    Class<?> currentClass = clazz.getSuperclass();

    while (currentClass != null) {
        final Field[] superFields = currentClass.getDeclaredFields();

        for (Field superField : superFields) {
            final Field match = getMatch(declaredFieldSet, superField);

            if (!Modifier.isPrivate(superField.getModifiers()) && !Modifier.isStatic(superField.getModifiers())
                    && match != null) {
                ret.add(match);
            }
        }
        currentClass = currentClass.getSuperclass();
    }

    return ret;
}

/**
 * Sets the field, bypassing scope restriction.
 *
 * @param subject Object where the field belongs
 * @param fieldName name of the field to set
 * @param value value to set to the field.
 * @param <T> subject type
 * @param <U> value type
 * @throws TestUtilsException if there are reflection errors while setting
 * the field
 */
public static <T, U> void setField(T subject, String fieldName, U value)
        throws TestUtilsException {
    @SuppressWarnings("unchecked")
    Class clazz = subject.getClass();
    try {
        while (clazz != null) {
            try {
                Field field = clazz.getDeclaredField(fieldName);
                field.setAccessible(true);
                field.set(subject, value);
                break;
            } catch (NoSuchFieldException ex) {
                if (clazz == clazz.getSuperclass()) {
                    break;
                }
                clazz = clazz.getSuperclass();
            }
        }
    } catch (SecurityException | IllegalArgumentException |
             IllegalAccessException e) {
        throw new TestUtilsException("setField failed", e);
    }
}

@SuppressWarnings("unchecked")
private static ArangoLinkInfo[] collectInfosIfAbsent(Class type) {
    ArangoLinkInfo[] infos = LINKS_CACHING.get(type);
    if (infos != null) {
        return infos;
    }

    final List<ArangoLinkInfo> list = new ArrayList<>();
    for (Field field : ClassUtil.getMemberFields(type)) {
        if (field.getType() != String.class) {
            continue;
        }
        ArangoLink linkAnno = field.getAnnotation(ArangoLink.class);
        if (linkAnno == null) {
            continue;
        }
        ClassUtil.setAccessible(field);
        Class<Entity> linkType = linkAnno.value();
        Class<?> serviceClass = linkAnno.service() != Object.class ? linkAnno.service()
                : linkType.getAnnotation(ArangoLink.class).value();

        list.add(new ArangoLinkInfo(((ArangoService) Services.get(serviceClass)).getDao(), field, linkType));
    }
    infos = list.isEmpty() ? EMPTY_LINKS : list.toArray(new ArangoLinkInfo[list.size()]);
    return LINKS_CACHING.putIfAbsent(type, infos);
}

/**
 * Search for the fields marked with @{@link ServiceInfo}
 */
private void initServiceHandlers(Class targetClass, Object target, Context context) throws IllegalArgumentException {
    Field[] fields = targetClass.getDeclaredFields();
    for (Field field : fields) {
        ServiceInfo serviceInfo = field.getAnnotation(ServiceInfo.class);
        if (serviceInfo != null) {
            if (IInterface.class.isAssignableFrom(field.getType())) {
                addServiceHandler(serviceInfo, (Class<? extends IInterface>) field.getType(), context);
                addFieldInfo(serviceInfo, field, target);
            } else if (isRemoter(field.getType())) {
                addRemoterServiceHandler(serviceInfo, field.getType(), context);
                addFieldInfo(serviceInfo, field, target);

            } else {
                throw new IllegalArgumentException(field.getName() + " is not a field of type IInterface or Remoter");
            }
        }
    }
}

public static int getStatusBarHeight(Context context) {
    Class<?> c = null;
    Object obj = null;
    Field field = null;
    int x = 0, statusBarHeight = 0;
    try {
        c = Class.forName("com.android.internal.R$dimen");
        obj = c.newInstance();
        field = c.getField("status_bar_height");
        x = Integer.parseInt(field.get(obj).toString());
        statusBarHeight = context.getResources().getDimensionPixelSize(x);
    } catch (Exception e1) {
        e1.printStackTrace();
    }
    return statusBarHeight;
}

/**
 * Copies all private data from this event into that.
 * Space is allocated for the copied data that will be
 * freed when the that is finalized. Upon completion,
 * this event is not changed.
 */
void copyPrivateDataInto(AWTEvent that) {
    that.bdata = this.bdata;
    // Copy canAccessSystemClipboard value from this into that.
    if (this instanceof InputEvent && that instanceof InputEvent) {
        Field field = get_InputEvent_CanAccessSystemClipboard();
        if (field != null) {
            try {
                boolean b = field.getBoolean(this);
                field.setBoolean(that, b);
            } catch(IllegalAccessException e) {
                if (log.isLoggable(PlatformLogger.Level.FINE)) {
                    log.fine("AWTEvent.copyPrivateDataInto() got IllegalAccessException ", e);
                }
            }
        }
    }
    that.isSystemGenerated = this.isSystemGenerated;
}

public static Method getMethod(final Object obj, final Field field) {
    Method method = null;
    final String fieldName = field.getName();
    final String methodName = "get" + StringUtils.capitalize(fieldName);
    try {
        method = obj.getClass().getDeclaredMethod(methodName.trim(), new Class<?>[0]);
        method.setAccessible(true);
    } catch (NoSuchMethodException | SecurityException e) {
        final String[] splitedReturnType = field.getType().getName().split("\\.");
        final int splitedReturnTypeLength = splitedReturnType.length - 1;
        B4zV4lidatorUtil.LOGGER.severe("The attribute " + fieldName
                + " cannot be validated because it has not a well formed getter method. This method should be like: \n\n\tpublic "
                + splitedReturnType[splitedReturnTypeLength] + " " + methodName + "() {\n" + "\n"
                + "     return this." + fieldName + ";\n" + "   }");
    }
    return method;
}

public static void formatInjectionPoint(Formatter formatter, Dependency<?> dependency,
    InjectionPoint injectionPoint, ElementSource elementSource) {
  Member member = injectionPoint.getMember();
  Class<? extends Member> memberType = Classes.memberType(member);

  if (memberType == Field.class) {
    dependency = injectionPoint.getDependencies().get(0);
    formatter.format("  while locating %s%n", convert(dependency.getKey(), elementSource));
    formatter.format("    for field at %s%n", StackTraceElements.forMember(member));

  } else if (dependency != null) {
    formatter.format("  while locating %s%n", convert(dependency.getKey(), elementSource));
    formatter.format("    for %s%n", formatParameter(dependency));

  } else {
    formatSource(formatter, injectionPoint.getMember());
  }
}

public void testSerialization() throws Exception {
        hints.limit_local_time = 1000;
        hints.limit_total_time = 9999;
        hints.ignore_procedures.add("neworder");

        File temp = FileUtil.getTempFile("hints", true);
        System.err.println(temp);
        hints.save(temp);

        DesignerHints clone = new DesignerHints();
        clone.load(temp, null);

        for (Field f : hints.getClass().getFields()) {
            Object expected = f.get(hints);
            Object actual = f.get(clone);
//            System.err.println(String.format("%s => %s / %s", f.getName(), expected, actual));
            assertEquals(f.getName(), expected, actual);
        } // FOR
    }

/**
 * 卸载已经装载的dll
 * 
 * @param dllName
 *            库名，如Decode.dll
 **/
@SuppressWarnings({ "unchecked", "unused" })
private synchronized void freeDll(String dllName) {
    try {
        ClassLoader classLoader = this.getClass().getClassLoader();
        Field field = ClassLoader.class.getDeclaredField("nativeLibraries");
        field.setAccessible(true);
        Vector<Object> libs = (Vector<Object>) field.get(classLoader);
        Iterator<Object> it = libs.iterator();
        Object o;

        while (it.hasNext()) {
            o = it.next();
            Field[] fs = o.getClass().getDeclaredFields();
            boolean hasInit = false;
            for (int k = 0; k < fs.length; k++) {
                if (fs[k].getName().equals("name")) {
                    fs[k].setAccessible(true);
                    String dllPath = fs[k].get(o).toString();
                    if (dllPath.endsWith(dllName)) {
                        hasInit = true;
                    }
                }
            }
            if (hasInit) {
                Method finalize = o.getClass().getDeclaredMethod("finalize", new Class[0]);
                finalize.setAccessible(true);
                finalize.invoke(o, new Object[0]);
                it.remove();
                libs.remove(o);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@BeforeClass
public static void setupBeforeClass() throws Exception {
  BaseTestServer.init();

  // Add custom PipelineFactory that replaces each stage with dummy stages that can fail.
  final AccelerationService service = (AccelerationService) l(AccelerationService.class);
  Field pipeManagerField = service.getClass().getDeclaredField("pipelineManager");
  pipeManagerField.setAccessible(true);
  PipelineManager pipeManager = (PipelineManager) pipeManagerField.get(service);
  Field pipeFactoryField = pipeManager.getClass().getDeclaredField("factory");
  pipeFactoryField.setAccessible(true);
  pipeFactoryField.set(pipeManager, new TestPipelineFactory());
}

private void assignAddress(Object addressesInstance, JsonElement jsonAddress, String member){

        Field addressesField;
        try {
            addressesField = addressesInstance.getClass().getDeclaredField(member);
            addressesField.setAccessible(true);
            if (jsonAddress == null){
                addressesField.set(addressesInstance, Address.class.newInstance());
            }else {
                addressesField.set(addressesInstance, gson.fromJson(jsonAddress, Address.class));
            }
        } catch (NoSuchFieldException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

@Test(groups = { "Setters" })
void setFilterEditorial_should_set_media_Filter_Editorial_and_should_return_instanceof_SearchParameters()
        throws IllegalAccessException,
        NoSuchFieldException {
    Assert.assertNotNull(param.setFilterEditorial(true));
    Field f = param.getClass().getDeclaredField("mFilterEditorial");
    f.setAccessible(true);
    Assert.assertTrue((f.get(param)).equals(true));
}

public Map<String, Field> find() throws MalformedURLException {

        Reflections reflections = new Reflections(
                new ConfigurationBuilder()
                        .setUrls(classpathUrls)
                        .addClassLoader(new URLClassLoader(classpathUrls.toArray(new URL[0]), getClass().getClassLoader()))
                        .setScanners(new SubTypesScanner()));

        Map<String, Field> metricFields = new HashMap<>();
        for (Class<? extends LambdaMetricSet> type : reflections.getSubTypesOf(LambdaMetricSet.class)) {
            metricFields.putAll(MetricsUtils.findAnnotatedFields(type));
        }

        return metricFields;
    }

@Test(groups = { "Setters" })
void setFrameRate_should_set_FrameRate_of_Type_Double_LicensePurchaseDetails()
        throws NoSuchFieldException, IllegalAccessException {
    purchaseDetails.setFrameRate(100.1);
    Field f = purchaseDetails.getClass().getDeclaredField("mFrameRate");
    f.setAccessible(true);
    Assert.assertTrue(f.get(purchaseDetails).equals(100.1));
}

/**
 * 通过文件名获取资源id 例子：getResId("icon", R.drawable.class);
 *
 * @param variableName
 * @param c
 * @return
 */
private static int getResId(String variableName, Class<?> c) {
    try {
        Field idField = c.getDeclaredField(variableName);
        return idField.getInt(idField);
    } catch (Exception e) {
        e.printStackTrace();
        return -1;
    }
}

public static Oid getOidInstance(String oidName)
    throws ClassNotFoundException, GSSException, NoSuchFieldException, IllegalAccessException {
  Class<?> oidClass;
  if (IBM_JAVA) {
    if ("NT_GSS_KRB5_PRINCIPAL".equals(oidName)) {
      // IBM JDK GSSUtil class does not have field for krb5 principal oid
      return new Oid("1.2.840.113554.1.2.2.1");
    }
    oidClass = Class.forName("com.ibm.security.jgss.GSSUtil");
  } else {
    oidClass = Class.forName("sun.security.jgss.GSSUtil");
  }
  Field oidField = oidClass.getDeclaredField(oidName);
  return (Oid) oidField.get(oidClass);
}

@Test
void pathCorrelatorInitilizationNegative() throws Throwable {
    Field configPath = PathCorrelator.class.getDeclaredField("config");
    configPath.setAccessible(true);
    configPath.set(null, "meep.json");

    Method method = PathCorrelator.class.getDeclaredMethod("loadPathCorrelation");
    method.setAccessible(true);

    InvocationTargetException ex = assertThrows(InvocationTargetException.class, () -> method.invoke(null));
    assertThat(ex).hasCauseThat().isInstanceOf(PathCorrelationException.class);
}

@Test
public void testSyncRunnerIndexOverflow() throws IOException, NoSuchFieldException,
    SecurityException, IllegalArgumentException, IllegalAccessException {
  final String name = "testSyncRunnerIndexOverflow";
  FSHLog log =
      new FSHLog(fs, FSUtils.getRootDir(conf), name, HConstants.HREGION_OLDLOGDIR_NAME, conf,
          null, true, null, null);
  try {
    Field ringBufferEventHandlerField = FSHLog.class.getDeclaredField("ringBufferEventHandler");
    ringBufferEventHandlerField.setAccessible(true);
    FSHLog.RingBufferEventHandler ringBufferEventHandler =
        (FSHLog.RingBufferEventHandler) ringBufferEventHandlerField.get(log);
    Field syncRunnerIndexField =
        FSHLog.RingBufferEventHandler.class.getDeclaredField("syncRunnerIndex");
    syncRunnerIndexField.setAccessible(true);
    syncRunnerIndexField.set(ringBufferEventHandler, Integer.MAX_VALUE - 1);
    HTableDescriptor htd =
        new HTableDescriptor(TableName.valueOf("t1")).addFamily(new HColumnDescriptor("row"));
    HRegionInfo hri =
        new HRegionInfo(htd.getTableName(), HConstants.EMPTY_START_ROW, HConstants.EMPTY_END_ROW);
    MultiVersionConcurrencyControl mvcc = new MultiVersionConcurrencyControl();
    for (int i = 0; i < 10; i++) {
      addEdits(log, hri, htd, 1, mvcc);
    }
  } finally {
    log.close();
  }
}

@Test(groups = { "Getters" })
void getSimilarId_should_return_media_Similar_id_of_Type_Integer()
        throws NoSuchFieldException,
        IllegalAccessException {
    Assert.assertTrue(param.getSimilar() == null);
    Field f = param.getClass().getDeclaredField("mSimilar");
    f.setAccessible(true);
    f.set(param, 127);
    Assert.assertEquals(127, param.getSimilar().intValue());
}

@Test(groups = { "Getters" })
void getWidth_should_return_width_of_Type_Integer_LicenseThumbnail()
        throws NoSuchFieldException, IllegalAccessException {
    Field f = thumbnail.getClass().getDeclaredField("mWidth");
    f.setAccessible(true);
    f.set(thumbnail, 100);
    Assert.assertTrue(thumbnail.getWidth().equals(100));
}

/**
 * 获取属性值
 * @param bean        实例
 * @param targetClass 属性所属class
 * @param fieldName   属性名
 * @return Field
 * @throws IllegalAccessException .{@link IllegalAccessException}
 */
public static Field getField(Object bean, Class targetClass, String fieldName) throws IllegalAccessException {
    List<Field> fields = Lists.newArrayList();
    getAllFields(bean.getClass(), fields);
    // 第一次类型和属性名都满足才返回
    Optional<Field> oneNewFields = fields.stream()
            .filter(field -> field.getName().equals(fieldName) && field.getType() == targetClass)
            .findFirst();
    // 第2次类型和属性名满足一个即返回
    Optional<Field> twoNewFields = fields.stream()
            .filter(field -> field.getName().equals(fieldName) || field.getType() == targetClass)
            .findFirst();
    return oneNewFields.orElseGet(() -> twoNewFields.orElse(null));
}

@SuppressWarnings("unchecked")
private Tuple<String, Boolean> getEntityId(String entityClass){
    try {
        Class<?> entity = null;
        if (loader == null) {
            entity = Class.forName(entityClass);
        } else {
            entity = loader.getUrlClassLoader().loadClass(entityClass);
        }

        while (entity != null){
            for (Field field : entity.getDeclaredFields()) {
                if (field.isAnnotationPresent(Id.class) || field.isAnnotationPresent(EmbeddedId.class)) {
                    this.implementsSerializable(field.getType());
                    return new Tuple<>(field.getType().getName(), this.isCustomType(field.getType()));
                }
            }

            for (Method method : entity.getDeclaredMethods()) {
                if (!method.getReturnType().equals(Void.TYPE) && (method.isAnnotationPresent(Id.class) || method.isAnnotationPresent(EmbeddedId.class))) {
                    this.implementsSerializable(method.getReturnType());
                    return new Tuple<>(method.getReturnType().getName(), this.isCustomType(method.getReturnType()));
                }
            }
            entity = entity.getSuperclass();
        }

        error = SDLogger.addError("Repository Error: Primary key not found in " + GeneratorUtils.getSimpleClassName(entityClass) + ".java");
        return null;
    } catch (GeneratorException ex) {
        error = SDLogger.addError(ex.getMessage());
        return null;
    } catch (Exception e) {
        error = SDLogger.addError("Repository Error: Failed to access entity " + GeneratorUtils.getSimpleClassName(entityClass) + ".java");
        return null;
    }
}

static String getStaticStringField(Class clazz, String variableName)
        throws NoSuchFieldException, IllegalAccessException {
    Field stringField = clazz.getDeclaredField(variableName);
    stringField.setAccessible(true);
    String value = (String) stringField.get(null);
    return value;
}

public void writeInstance(Object obj, AbstractHessianOutput out)
  throws IOException
{
  for (int i = 0; i < _fields.length; i++) {
    Field field = _fields[i];

    _fieldSerializers[i].serialize(out, obj, field);
  }
}

/**
 * Resets the command history of the {@link SystemStatus}.
 * 
 * @throws NoSuchFieldException if the use of reflection fails
 * @throws SecurityException if the use of reflection fails
 * @throws IllegalArgumentException if the use of reflection fails
 * @throws IllegalAccessException if the use of reflection fails
 */
private void resetCommandHistoryOfSystemStatus()
      throws NoSuchFieldException,
         SecurityException,
         IllegalArgumentException,
         IllegalAccessException {
   Field f = systemStatus.getClass().getDeclaredField(FIELD_SYSTEM_STATUS_COMMAND_HISTORY);
   f.setAccessible(true);

   @SuppressWarnings("unchecked")
   List<Pair<ICommand, CommandResult>> commandHistory = (List<Pair<ICommand, CommandResult>>) f.get(systemStatus);
   commandHistory.clear();
}

private int[] getPacket(int[] data) {
    AshFrameHandler frameHandler = new AshFrameHandler(null);
    byte[] bytedata = new byte[data.length];
    int cnt = 0;
    for (int value : data) {
        bytedata[cnt++] = (byte) value;
    }
    ByteArrayInputStream stream = new ByteArrayInputStream(bytedata);
    ZigBeePort port = new TestPort(stream, null);

    Method privateMethod;
    try {
        Field field = frameHandler.getClass().getDeclaredField("port");
        field.setAccessible(true);
        field.set(frameHandler, port);

        privateMethod = AshFrameHandler.class.getDeclaredMethod("getPacket");
        privateMethod.setAccessible(true);

        return (int[]) privateMethod.invoke(frameHandler);
    } catch (NoSuchMethodException | SecurityException | IllegalArgumentException | IllegalAccessException
            | InvocationTargetException | NoSuchFieldException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    return null;
}