// Then
            assertTrue(Modifier.isPublic(field.getModifiers()));
            assertTrue(Modifier.isStatic(field.getModifiers()));
            assertTrue(Modifier.isFinal(field.getModifiers()));
            assertEquals(int.class, field.getType());
        }
    }

    @Nested
    @DisplayName("Deprecation Tests")
    class DeprecationTests {

        @Test

     */
    boolean isStatic();

    /**
     * Returns {@literal true} if the field is {@literal final}.
     *
     * @return {@literal true} if the field is {@literal final}
     */
    boolean isFinal();

    /**
     * Returns {@literal true} if the field is parameterized.
     *
     * @return {@literal true} if the field is parameterized
     */
    boolean isParameterized();

    /**

        return FieldUtil.isPublicField(field);
    }

    @Override
    public boolean isStatic() {
        return !FieldUtil.isInstanceField(field);
    }

    @Override
    public boolean isFinal() {
        return FieldUtil.isFinalField(field);
    }

    @Override
    public boolean isParameterized() {
        return parameterizedClassDesc != null && parameterizedClassDesc.isParameterizedClass();

            // Then
            assertTrue(Modifier.isPublic(field.getModifiers()));
            assertTrue(Modifier.isStatic(field.getModifiers()));
            assertTrue(Modifier.isFinal(field.getModifiers()));
            assertEquals(int.class, field.getType());
        }
    }

    @Nested
    @DisplayName("Integration Tests")
    class IntegrationTests {

        @Test

     */
    boolean isStatic();

    /**
     * Returns {@literal true} if the method is {@literal final}.
     *
     * @return {@literal true} if the method is {@literal final}
     */
    boolean isFinal();

    /**
     * Returns {@literal true} if the method is {@literal abstract}.
     *
     * @return {@literal true} if the method is {@literal abstract}
     */
    boolean isAbstract();

    /**

    @Override
    public void visit(FieldDeclaration fieldDeclaration, ClassMetaDataRepository<ClassMetaData> arg) {
        boolean isConst = getCurrentClass().isInterface() || (fieldDeclaration.isStatic() && fieldDeclaration.isFinal());
        if (isConst) {
            fieldDeclaration.getVariables().forEach(variableDeclarator -> {
                String constName = variableDeclarator.getNameAsString();

     * @return {@literal true} if it is a final field
     */
    public static boolean isFinalField(final Field field) {
        assertArgumentNotNull("field", field);

        return Modifier.isFinal(field.getModifiers());
    }

    /**
     * Returns the element type of a parameterized collection field.
     *
     * @param field a field of a parameterized collection type (must not be {@literal null})

                        if (isQualifiedForInterpolation(currentField, type)) {
                            if (String.class == type) {
                                if (!Modifier.isFinal(currentField.getModifiers())) {
                                    fields.add(new StringField(currentField));
                                }
                            } else if (List.class.isAssignableFrom(type)) {

                return matchOutput;
            }

            pendingOutput = fst.outputs.add(pendingOutput, scratchArc.output());

            if (scratchArc.isFinal()) {
                matchOutput = fst.outputs.add(pendingOutput, scratchArc.nextFinalOutput());
                longestMatchEndOffset = start + index + Character.charCount(codePoint);
            }

    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);
          try {