* @return true if static, false otherwise
     */
    public static boolean isStatic(final int modifier) {
        return Modifier.isStatic(modifier);
    }

    /**
     * Checks if the specified modifier is final.
     *
     * @param modifier
     *            the modifier to check
     * @return true if final, false otherwise
     */
    public static boolean isFinal(final int modifier) {

        Field serialVersionField = FessLabels.class.getDeclaredField("serialVersionUID");
        assertNotNull(serialVersionField);
        assertTrue(Modifier.isStatic(serialVersionField.getModifiers()));
        assertTrue(Modifier.isFinal(serialVersionField.getModifiers()));
        assertTrue(Modifier.isPrivate(serialVersionField.getModifiers()));
        serialVersionField.setAccessible(true);
        assertEquals(1L, serialVersionField.getLong(null));

package clause

type Insert struct {
	Table    Table
	Modifier string
}

// Name insert clause name
func (insert Insert) Name() string {
	return "INSERT"
}

// Build build insert clause
func (insert Insert) Build(builder Builder) {
	if insert.Modifier != "" {
		builder.WriteString(insert.Modifier)
		builder.WriteByte(' ')
	}

	builder.WriteString("INTO ")
	if insert.Table.Name == "" {

    }

    public void test_isPublicClass() {
        assertTrue("FessWebResourceRoot should be public", java.lang.reflect.Modifier.isPublic(FessWebResourceRoot.class.getModifiers()));
        assertFalse("FessWebResourceRoot should not be abstract",
                java.lang.reflect.Modifier.isAbstract(FessWebResourceRoot.class.getModifiers()));
    }

    public void test_constructorSignature() {

            Method setObjectMethod = WebApiUtil.class.getMethod("setObject", String.class, Object.class);
            assertTrue("setObject should be static", java.lang.reflect.Modifier.isStatic(setObjectMethod.getModifiers()));
            assertTrue("setObject should be public", java.lang.reflect.Modifier.isPublic(setObjectMethod.getModifiers()));
            assertEquals("setObject should return void", void.class, setObjectMethod.getReturnType());

    public void test_class_is_public() {
        assertTrue("Class should be public", java.lang.reflect.Modifier.isPublic(SystemMonitorTarget.class.getModifiers()));
        assertFalse("Class should not be abstract", java.lang.reflect.Modifier.isAbstract(SystemMonitorTarget.class.getModifiers()));
        assertFalse("Class should not be final", java.lang.reflect.Modifier.isFinal(SystemMonitorTarget.class.getModifiers()));
    }

  public final boolean isPrivate() {
    return Modifier.isPrivate(getModifiers());
  }

  /** Returns true if the element is static. */
  public final boolean isStatic() {
    return Modifier.isStatic(getModifiers());
  }

  /**
   * Returns {@code true} if this method is final, per {@code Modifier.isFinal(getModifiers())}.
   *

package clause

type Delete struct {
	Modifier string
}

func (d Delete) Name() string {
	return "DELETE"
}

func (d Delete) Build(builder Builder) {
	builder.WriteString("DELETE")

	if d.Modifier != "" {
		builder.WriteByte(' ')
		builder.WriteString(d.Modifier)
	}
}

func (d Delete) MergeClause(clause *Clause) {
	clause.Name = ""
	clause.Expression = d

        assertTrue("Class should be public", java.lang.reflect.Modifier.isPublic(HotThreadMonitorTarget.class.getModifiers()));
        assertFalse("Class should not be abstract", java.lang.reflect.Modifier.isAbstract(HotThreadMonitorTarget.class.getModifiers()));
        assertFalse("Class should not be final", java.lang.reflect.Modifier.isFinal(HotThreadMonitorTarget.class.getModifiers()));
    }

    Field[] fields = type.getDeclaredFields();
    Arrays.sort(fields, BY_FIELD_NAME);
    for (Field field : fields) {
      if (Modifier.isPublic(field.getModifiers())
          && Modifier.isStatic(field.getModifiers())
          && Modifier.isFinal(field.getModifiers())) {
        if (field.getGenericType() == field.getType() && type.isAssignableFrom(field.getType())) {
          field.setAccessible(true);