/**
   * All methods should have a
   *
   * @param descriptor the Enterprise Java Bean deployment descriptor
   * @return <code>Result</code> the results for this assertion
   */
  public Result check(EjbDescriptor descriptor) {

    result = getInitializedResult();
    //        boolean oneFailed = false;

    try {
      if (descriptor instanceof EjbSessionDescriptor || descriptor instanceof EjbEntityDescriptor) {

        Set methods = descriptor.getMethodDescriptors();
        //		 Set methodPermissions = new HashSet();
        boolean noPermissions = false;

        for (Iterator i = methods.iterator(); i.hasNext(); ) {
          MethodDescriptor md = (MethodDescriptor) i.next();
          Set permissions = descriptor.getMethodPermissionsFor(md);
          if (permissions.isEmpty() || (permissions == null)) {
            result.addWarningDetails(
                smh.getLocalString(
                    getClass().getName() + ".failed",
                    "Warning: Method [ {0} ] of EJB [ {1} ] does not have assigned security-permissions",
                    new Object[] {md.getName(), descriptor.getName()}));
            result.setStatus(result.WARNING);
            noPermissions = true;
          }
        }

        if (!noPermissions) {
          result.passed(
              smh.getLocalString(
                  getClass().getName() + ".passed",
                  "Valid: All [ {0} ]EJB  interfaces methods have security-permissions assigned.",
                  new Object[] {descriptor.getName()}));
        }

      } else {
        result.notApplicable(
            smh.getLocalString(
                getClass().getName() + ".notApplicable",
                "The bean [ {0} ] is neither a Session nor Entity Bean",
                new Object[] {descriptor.getName()}));
        return result;
      }
    } catch (Exception e) {
      result.failed(
          smh.getLocalString(
              getClass().getName() + ".exception",
              "The test generated the following exception [ {0} ]",
              new Object[] {e.getLocalizedMessage()}));
    }
    return result;
  }
  /**
   * Optionally implemented SessionSynchronization interface transaction demarcation test. If an
   * enterprise bean implements the javax.ejb.SessionSynchronization interface, the Application
   * Assembler can specify only the following values for the transaction attributes of the bean's
   * methods: Required RequiresNew Mandatory
   *
   * @param descriptor the Enterprise Java Bean deployment descriptor
   * @return <code>Result</code> the results for this assertion
   */
  public Result check(EjbDescriptor descriptor) {

    Result result = getInitializedResult();
    ComponentNameConstructor compName = getVerifierContext().getComponentNameConstructor();
    boolean oneFound = false;

    if (descriptor instanceof EjbSessionDescriptor) {
      try {
        Context context = getVerifierContext();
        ClassLoader jcl = context.getClassLoader();
        Class c =
            Class.forName(
                descriptor.getEjbClassName(), false, getVerifierContext().getClassLoader());
        // walk up the class tree
        do {
          Class[] interfaces = c.getInterfaces();

          for (int i = 0; i < interfaces.length; i++) {
            if (interfaces[i].getName().equals("javax.ejb.SessionSynchronization")) {
              oneFound = true;
              break;
            }
          }
        } while ((c = c.getSuperclass()) != null);

      } catch (ClassNotFoundException e) {
        Verifier.debug(e);
        addErrorDetails(result, compName);
        result.failed(
            smh.getLocalString(
                getClass().getName() + ".failedException1",
                "Error: [ {0} ] class not found.",
                new Object[] {descriptor.getEjbClassName()}));
        return result;
      }

      // If an enterprise bean implements the javax.ejb.SessionSynchronization
      // interface, the Application Assembler can specify only the following
      // values for the transaction attributes of the bean's methods:
      //   Required, RequiresNew, Mandatory
      if (oneFound) {
        String transactionAttribute = "";
        ContainerTransaction containerTransaction = null;
        boolean oneFailed = false;
        if (!descriptor.getMethodContainerTransactions().isEmpty()) {
          for (Enumeration ee = descriptor.getMethodContainerTransactions().keys();
              ee.hasMoreElements(); ) {
            MethodDescriptor methodDescriptor = (MethodDescriptor) ee.nextElement();
            containerTransaction =
                (ContainerTransaction)
                    descriptor.getMethodContainerTransactions().get(methodDescriptor);

            if (!(containerTransaction != null && properAttribDefined(containerTransaction))) {
              transactionAttribute = containerTransaction.getTransactionAttribute();
              addErrorDetails(result, compName);
              result.failed(
                  smh.getLocalString(
                      getClass().getName() + ".failed",
                      "Error: TransactionAttribute [ {0} ] for method [ {1} ] is not valid.",
                      new Object[] {transactionAttribute, methodDescriptor.getName()}));
            }
          }
        }
      }
    }

    if (result.getStatus() != Result.FAILED) {
      addGoodDetails(result, compName);
      result.passed(
          smh.getLocalString(
              getClass().getName() + ".passed",
              "TransactionAttributes are defined properly for the bean"));
    }
    return result;
  }