<!DOCTYPE html>
<html lang="en">
  <head>

    <meta charset="UTF-8">
      <title>Validation Keys Audit Report</title>
    <meta name="description" content="Apache TomEE">
    <meta name="author" content="Apache TomEE">
    <meta name="google-translate-customization" content="f36a520c08f4c9-0a04e86a9c075ce9-g265f3196f697cf8f-10">
    <meta http-equiv="Pragma" content="no-cache">
    <meta http-equiv="Expires" content="0">
    <meta http-equiv="Cache-Control" content="no-store, no-cache, must-revalidate, max-age=0">

    <!-- Le HTML5 shim, for IE6-8 support of HTML elements -->
    <!--[if lt IE 9]>
      <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
    <![endif]-->

    <!-- Le styles -->
    <link href="./../resources/css/bootstrap.css" rel="stylesheet">
    <link href="./../resources/css/prettify.css" rel="stylesheet">
    <!--link href="./../resources/css/bootstrap-mods.css" rel="stylesheet"-->
    <link href="./../resources/css/main.css" rel="stylesheet">
    <link href="./../resources/font-awesome-4.6.3/css/font-awesome.min.css" rel="stylesheet">

    <script type="text/javascript">
        var t = encodeURIComponent(document.title.replace(/^\s+|\s+$/g,""));
        var u = encodeURIComponent(""+document.URL);
    
      function fbshare () {
          window.open(
                  "http://www.facebook.com/sharer/sharer.php?u="+u,
                  'Share on Facebook',
                  'width=640,height=426');
      };
      function gpshare () {
          window.open(
                  "https://plus.google.com/share?url="+u,
                  'Share on Google+',
                  'width=584,height=385');
      };
      function twshare () {
          window.open(
                  "https://twitter.com/intent/tweet?url="+u+"&text="+t,
                  'Share on Twitter',
                  'width=800,height=526');
      };
      function pinshare () {
          window.open("//www.pinterest.com/pin/create/button/?url="+u+"&media=http%3A%2F%2Ftomee.apache.org%2Fresources%2Fimages%2Ffeather-logo.png&description="+t,
                  'Share on Pinterest',
                  'width=800,height=526');
      };
    </script>

    <!-- Le fav and touch icons -->
    <link rel="shortcut icon" href="./../favicon.ico">
    <link rel="apple-touch-icon" href="./../resources/images/apple-touch-icon.png">
    <link rel="apple-touch-icon" sizes="72x72" href="./../resources/images/apple-touch-icon-72x72.png">
    <link rel="apple-touch-icon" sizes="114x114" href="./../resources/images/apple-touch-icon-114x114.png">

    <script src="./../resources/js/prettify.js" type="text/javascript"></script>
    <script src="./../resources/js/jquery-latest.js"></script>
    <script src="http://platform.twitter.com/widgets.js" type="text/javascript"></script>
    <script src="./../resources/js/common.js"></script>
    <script src="./../resources/js/prettyprint.js"></script>
    <!--script src="//assets.pinterest.com/js/pinit.js" type="text/javascript" async></script//-->
    
    <script type="text/javascript">

      var _gaq = _gaq || [];
      _gaq.push(['_setAccount', 'UA-2717626-1']);
      _gaq.push(['_setDomainName', 'apache.org']);
      _gaq.push(['_trackPageview']);

      (function() {
        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
      })();

    </script>
  </head>

  <body>

    <div class="topbar" data-dropdown="dropdown">
      <div class="fill">
        <div class="container">
          <a class="brand" href="./../index.html">Apache TomEE</a>
          <ul class="nav">
              <li class="dropdown">
                  <a class="dropdown-toggle" data-toggle="dropdown" href="#">
                  Apache
                      <b class="caret"></b>
                  </a>
                  <ul class="dropdown-menu">
                     <!-- <li><a href="./../misc/whoweare.html">Who we are?</a></li> -->
                     <!-- <li><a href="./../misc/heritage.html">Heritage</a></li> -->
                     <li><a href="http://www.apache.org">Apache Home</a></li>
                     <!-- <li><a href="./../misc/resources.html">Resources</a></li> -->
                     <li><a href="./../misc/contact.html">Contact</a></li>
                     <li><a href="./../misc/legal.html">Legal</a></li>
                     <li><a href="http://www.apache.org/foundation/sponsorship.html">Sponsorship</a></li>
                     <li><a href="http://www.apache.org/foundation/thanks.html">Thanks</a></li>
                     <li class="divider"/>
                     <li><a href="http://www.apache.org/security">Security</a></li>
                  </ul>
              </li>
              <li><a href="./../index.html">Home</a></li>
              <li><a href="./../downloads.html">Downloads</a></li>
              <li><a href="./../documentation.html">Documentation</a></li>
              <li><a href="./../examples-trunk/index.html">Examples</a></li>
              <li><a href="./../support.html">Support</a></li>
              <li><a href="./../contribute.html">Contribute</a></li>
              <li><a href="./../security/index.html">Security</a></li>
          </ul>

            <!-- Google CSE Search Box Begins  -->
            <FORM class="pull-right" id="searchbox_010475492895890475512:_t4iqjrgx90" action="http://www.google.com/cse">
                <INPUT type="hidden" name="cx" value="010475492895890475512:_t4iqjrgx90">
                <INPUT type="hidden" name="cof" value="FORID:0">
                <INPUT size="18" width="130" style="width:130px" name="q" type="text" placeholder="Search">
            </FORM>
            <!--<SCRIPT type="text/javascript" src="http://www.google.com/coop/cse/brand?form=searchbox_010475492895890475512:_t4iqjrgx90"></SCRIPT>-->
            <!-- Google CSE Search Box Ends -->
        </div>
      </div>
    </div>

    <div class="container">
    

<div class="page-header">
    <small><a href="./../index.html">Home</a>&nbsp;&raquo&nbsp;<a href="./../dev/">Dev</a></small><br>
    <h1>Validation Keys Audit Report

        <div style="float: right; position: relative; bottom: -10px; ">
            <a onclick="javascript:gpshare()" class="gp-share sprite" title="Share on Google+">share [gp]</a>
            <a onclick="javascript:fbshare()" class="fb-share sprite" title="Share on Facebook">share [fb]</a>
            <a onclick="javascript:twshare()" class="tw-share sprite" title="Share on Twitter">share [tw]</a>
            <a onclick="javascript:pinshare()" class="pin-share sprite" title="Share on Pinterest">share [pin]</a>
            <a data-toggle="modal" href="#edit" class="edit-page" title="Contribute to this Page">contribute</a>
        </div>
    </h1>
</div>

<p><div class="warning">:title=Warning}This page is auto-generated. Any manual changes
would be over-written the next time this page is regenerated{warning}<div class="info">:title=Audit Result}h2.Out of a total of 144 keys, 123 have been
tested. Test coverage for keys is 85.41666666666666 %.{info}<div class="table-plus">:autoNumber=true}</p>

<p>| abstractAnnotatedAsBean | 
 | ann.ejb.beanClass | 
 | ann.ejb.notInterface | 
 | ann.localRemote.generalconflict | 
 | asynchronous.badExceptionType | 
 | asynchronous.badReturnType | 
 | asynchronous.methodignored | 
 | asynchronous.missing | 
 | callback.missing.possibleTypo | 
 | cannot.validate | 
 | client.missingMainClass | 
 | ignoredClassAnnotation | 
 | interfaceAnnotatedAsBean | 
 | missing.dependent.class | 
 | misslocated.class | 
 | multiplyAnnotatedAsBean | 
 | timeout.badReturnType | 
 | timeout.invalidArguments | 
 | timeout.missing.possibleTypo | 
 | timeout.tooManyMethods | 
 | xml.noEjbClass | <div class="table-plus">}
<a name="ValidationKeysAuditReport-Listofkeyswhichhavebeentested."></a></p>

<h2>List of keys which have been tested.<div class="table-plus">:autoNumber=true}</h2>

<p><table>
<tr><th> Key </td><td> Method which tests the key </th></tr>
<tr><td> ann.ejb.ejbLocalObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidejbreftest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidEjbRefTest.test() </a>
</tr>
<tr><td> ann.ejb.ejbObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidejbreftest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidEjbRefTest.test() </a>
</tr>
<tr><td> ann.invalidConcurrencyAttribute </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidconcurrencyattributetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidConcurrencyAttributeTest.test() </a>
</tr>
<tr><td> ann.invalidTransactionAttribute </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidtransactionattributetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidTransactionAttributeTest.annotation() </a>
</tr>
<tr><td> ann.local.noAttributes </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidannotatedinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidAnnotatedInterfacesTest.noAttributes() </a>
</tr>
<tr><td> ann.localRemote.ambiguous </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidannotatedinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidAnnotatedInterfacesTest.ambiguous() </a>
</tr></p>

<p><tr><td> ann.notAnInterface </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.test() </a>
</tr>
<tr><td> ann.remote.noAttributes </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidannotatedinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidAnnotatedInterfacesTest.noAttributes() </a>
</tr>
<tr><td> ann.remoteOrLocal.converse.parent </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.test2() </a>
</tr>
<tr><td> ann.remoteOrLocal.ejbHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.test() </a>
</tr>
<tr><td> ann.remoteOrLocal.ejbLocalHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.test() </a>
</tr>
<tr><td> ann.remoteOrLocal.ejbLocalObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.test() </a>
</tr>
<tr><td> ann.remoteOrLocal.ejbObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.test() </a>
</tr></p>

<p><tr><td> aroundInvoke.missing.possibleTypo </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcallbackstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidCallbacksTest.test1() </a>
</tr>
<tr><td> aroundInvoke.mustThrowException </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidaroundtimeouttest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidAroundTimeoutTest.testInvalidAroundTimeoutReturnValue() </a>
</tr>
<tr><td> callback.badModifier </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcallbackstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidCallbacksTest.test() </a>
</tr>
<tr><td> callback.badReturnType </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcallbackstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidCallbacksTest.test() </a>
</tr>
<tr><td> callback.invalidArguments </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcallbackstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidCallbacksTest.test() </a>
</tr>
<tr><td> callback.missing </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcallbackstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidCallbacksTest.test() </a>
</tr>
<tr><td> callback.sessionSynchronization.invalidUse </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcallbackstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidCallbacksTest.test() </a>
</tr>
<tr><td> callback.sessionbean.invalidusage </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcallbackstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidCallbacksTest.test2() </a>
</tr>
<tr><td> conflictingSecurityAnnotations </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidsecurityannotationstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidSecurityAnnotationsTest.test() </a>
</tr>
<tr><td> containerTransaction.ejbNameRequired </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcontainertransactiontest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidContainerTransactionTest.test() </a>
</tr>
<tr><td> containerTransaction.noSuchEjbName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidcontainertransactiontest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidContainerTransactionTest.test() </a>
</tr>
<tr><td> dependsOn.circuit </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkdependsontest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckDependsOnTest.dependsOn() </a>
</tr>
<tr><td> dependsOn.noSuchEjb </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkdependsontest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckDependsOnTest.dependsOn() </a>
</tr>
<tr><td> ejbAnnotation.onClassWithNoBeanInterface </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidejbreftest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidEjbRefTest.test1() </a>
</tr>
<tr><td> ejbAnnotation.onClassWithNoName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidejbreftest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidEjbRefTest.test1() </a>
</tr>
<tr><td> entity.no.ejb.create </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checknocreatemethodstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckNoCreateMethodsTest.noCreateMethod() </a>
</tr></p>

<p><tr><td> injectionTarget.nameContainsSet </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinjectiontargetstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInjectionTargetsTest.test() </a>
</tr>
<tr><td> interceptor.callback.badReturnType </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidinterceptortest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidInterceptorTest.test() </a>
</tr>
<tr><td> interceptor.callback.invalidArguments </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidinterceptortest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidInterceptorTest.test() </a>
</tr>
<tr><td> interceptor.callback.missing </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidinterceptortest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidInterceptorTest.test() </a>
</tr>
<tr><td> interceptor.callback.missing.possibleTypo </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidinterceptortest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidInterceptorTest.test() </a>
</tr>
<tr><td> interceptor.unused </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidinterceptortest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidInterceptorTest.test1() </a>
</tr>
<tr><td> interceptorBinding.ejbNameRequiredWithMethod </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidinterceptortest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidInterceptorTest.test() </a>
</tr>
<tr><td> interceptorBinding.noSuchEjbName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidinterceptortest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidInterceptorTest.test() </a>
</tr>
<tr><td> interface.beanOnlyAnnotation </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.test1() </a>
</tr>
<tr><td> interfaceMethod.beanOnlyAnnotation </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.test1() </a>
</tr>
<tr><td> methodPermission.ejbNameRequired </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidmethodpermissionstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidMethodPermissionsTest.test() </a>
</tr>
<tr><td> methodPermission.noSuchEjbName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidmethodpermissionstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidMethodPermissionsTest.test() </a>
</tr>
<tr><td> missing.class </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkmissingclasstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckMissingClassTest.wrongClassType() </a>
</tr>
<tr><td> no.busines.method </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checknobusinessmethodtest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckNoBusinessMethodTest.noBusinessMethod() </a>
</tr>
<tr><td> no.busines.method.args </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checknobusinessmethodtest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckNoBusinessMethodTest.noBusinessMethod() </a>
</tr>
<tr><td> no.busines.method.case </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checknobusinessmethodtest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckNoBusinessMethodTest.noBusinessMethod() </a>
</tr>
<tr><td> no.home.create </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checknocreatemethodstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckNoCreateMethodsTest.noCreateMethod() </a>
</tr>
<tr><td> noInterfaceDeclared.entity </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkwrongclasstypetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckWrongClassTypeTest.wrongClassType() </a>
</tr>
<tr><td> permitAllAndRolesAllowedOnClass </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidsecurityannotationstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidSecurityAnnotationsTest.test() </a>
</tr>
<tr><td> persistenceContextAnnotation.onClassWithNoName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistencecontextusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceContextUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceContextAnnotation.onEntityManagerFactory </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistencecontextusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceContextUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceContextAnnotation.onNonEntityManager </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistencecontextusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceContextUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceContextExtented.nonStateful </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistencecontextusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceContextUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceContextRef.noMatches </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistencecontextusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceContextUsageTest.noUnitName() </a>
</tr>
<tr><td> persistenceContextRef.noPersistenceUnits </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistencecontextusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceContextUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceContextRef.noUnitName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistencecontextusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceContextUsageTest.noUnitName() </a>
</tr>
<tr><td> persistenceContextRef.vagueMatches </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistencecontextusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceContextUsageTest.vagueMatches() </a>
</tr>
<tr><td> persistenceUnitAnnotation.onClassWithNoName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistenceunitusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceUnitUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceUnitAnnotation.onEntityManager </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistenceunitusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceUnitUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceUnitAnnotation.onNonEntityManagerFactory </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistenceunitusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceUnitUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceUnitRef.noMatches </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistenceunitusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceUnitUsageTest.noUnitName() </a>
</tr>
<tr><td> persistenceUnitRef.noPersistenceUnits </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistenceunitusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceUnitUsageTest.wrongUsage() </a>
</tr>
<tr><td> persistenceUnitRef.noUnitName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistenceunitusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceUnitUsageTest.noUnitName() </a>
</tr>
<tr><td> persistenceUnitRef.vagueMatches </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkpersistenceunitusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckPersistenceUnitUsageTest.vagueMatches() </a>
</tr>
<tr><td> resourceAnnotation.onClassWithNoName </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/mistakenresourcerefusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/MistakenResourceRefUsageTest.wrongUsage() </a>
</tr>
<tr><td> resourceAnnotation.onClassWithNoType </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/mistakenresourcerefusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/MistakenResourceRefUsageTest.wrongUsage() </a>
</tr>
<tr><td> resourceRef.onEntityManager </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/mistakenresourcerefusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/MistakenResourceRefUsageTest.wrongUsage() </a>
</tr>
<tr><td> resourceRef.onEntityManagerFactory </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/mistakenresourcerefusagetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/MistakenResourceRefUsageTest.wrongUsage() </a>
</tr>
<tr><td> session.no.ejb.create </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checknocreatemethodstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckNoCreateMethodsTest.noCreateMethod() </a>
</tr>
<tr><td> unused.ejb.create </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checknocreatemethodstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckNoCreateMethodsTest.noCreateMethod() </a>
</tr>
<tr><td> unused.ejbPostCreate </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checknocreatemethodstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckNoCreateMethodsTest.noCreateMethod() </a>
</tr>
<tr><td> userTransactionRef.forbiddenForCmtdBeans </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkusertransactionrefstest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckUserTransactionRefsTest.testSLSBwithUserTransaction() </a>
</tr>
<tr><td> wrong.class.type </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkwrongclasstypetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckWrongClassTypeTest.wrongClassType() </a>
</tr>
<tr><td> xml.businessLocal.beanClass </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBeanClass() </a>
</tr>
<tr><td> xml.businessLocal.ejbHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBHome() </a>
</tr></p>

<p><tr><td> xml.businessLocal.ejbObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBObject() </a>
</tr></p>

<p><tr><td> xml.businessRemote.beanClass </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBeanClass() </a>
</tr></p>

<p><tr><td> xml.businessRemote.ejbLocalHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBLocalHome() </a>
</tr>
<tr><td> xml.businessRemote.ejbLocalObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBLocalObject() </a>
</tr></p>

<p><tr><td> xml.businessRemote.notInterface </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testNotInterface() </a>
</tr>
<tr><td> xml.home.beanClass </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBeanClass() </a>
</tr>
<tr><td> xml.home.businessLocal </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBusinessLocal() </a>
</tr>
<tr><td> xml.home.businessRemote </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBusinessRemote() </a>
</tr>
<tr><td> xml.home.ejbLocalHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBLocalHome() </a>
</tr>
<tr><td> xml.home.ejbLocalObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBLocalObject() </a>
</tr>
<tr><td> xml.home.ejbObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBObject() </a>
</tr>
<tr><td> xml.home.notInterface </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testNotInterface() </a>
</tr>
<tr><td> xml.home.unknown </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testUnkown() </a>
</tr>
<tr><td> xml.invalidTransactionAttribute </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/checkinvalidtransactionattributetest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/CheckInvalidTransactionAttributeTest.xml() </a>
</tr>
<tr><td> xml.local.beanClass </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBeanClass() </a>
</tr>
<tr><td> xml.local.businessLocal </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBusinessLocal() </a>
</tr>
<tr><td> xml.local.businessRemote </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBusinessRemote() </a>
</tr>
<tr><td> xml.local.ejbHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBHome() </a>
</tr>
<tr><td> xml.local.ejbLocalHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBLocalHome() </a>
</tr>
<tr><td> xml.local.ejbObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBObject() </a>
</tr>
<tr><td> xml.local.notInterface </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testNotInterface() </a>
</tr>
<tr><td> xml.local.unknown </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testUnkown() </a>
</tr>
<tr><td> xml.localHome.beanClass </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBeanClass() </a>
</tr>
<tr><td> xml.localHome.businessLocal </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBusinessLocal() </a>
</tr>
<tr><td> xml.localHome.businessRemote </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBusinessRemote() </a>
</tr>
<tr><td> xml.localHome.ejbHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBHome() </a>
</tr>
<tr><td> xml.localHome.ejbLocalObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBLocalObject() </a>
</tr>
<tr><td> xml.localHome.ejbObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBObject() </a>
</tr>
<tr><td> xml.localHome.notInterface </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testNotInterface() </a>
</tr>
<tr><td> xml.localHome.unknown </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testUnkown() </a>
</tr>
<tr><td> xml.localRemote.conflict </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testUnkown() </a>
</tr>
<tr><td> xml.remote.beanClass </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBeanClass() </a>
</tr>
<tr><td> xml.remote.businessLocal </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBusinessLocal() </a>
</tr>
<tr><td> xml.remote.businessRemote </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testBusinessRemote() </a>
</tr>
<tr><td> xml.remote.ejbHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBHome() </a>
</tr>
<tr><td> xml.remote.ejbLocalHome </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBLocalHome() </a>
</tr>
<tr><td> xml.remote.ejbLocalObject </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testEJBLocalObject() </a>
</tr>
<tr><td> xml.remote.notInterface </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testNotInterface() </a>
</tr>
<tr><td> xml.remote.unknown </td><td> <a href="-https://svn.apache.org/viewvc/tomee/tomee/trunk/container/openejb-core/src/test/java/org/apache/openejb/config/rules/invalidinterfacestest.java?revision=head&amp;view=markup-.html">org/apache/openejb/config/rules/InvalidInterfacesTest.testUnkown() </a>
</tr><div class="table-plus">}</p>




        <div id="edit" class="modal hide fade in" style="display: none; ">
            <div class="modal-header">
                <a class="close" data-dismiss="modal">x</a>

                <h3>Thank you for contributing to the documentation!</h3>
            </div>
            <div class="modal-body">
                <h4>Any help with the documentation is greatly appreciated.</h4>
                <p>All edits are reviewed before going live, so feel free to do much more than fix typos or links.  If you see a page that could benefit from an entire rewrite, we'd be thrilled to review it.  Don't be surprised if we like it so much we ask you for help with other pages :)</p>
                <small>NOTICE: unless indicated otherwise on the pages in question, all editable content available from apache.org is presumed to be licensed under the Apache License (AL) version 2.0 and hence all submissions to apache.org treated as formal Contributions under the license terms.</small>
                <!--[if gt IE 6]>
                <h4>Internet Explorer Users</h4>
                <p>If you are not an Apache committer, click the Yes link and enter a <i>anonymous</i> for the username and leave the password empty</p>
                <![endif]-->

            </div>
            <div class="modal-footer">
                Do you have an Apache ID?
                <a href="javascript:void(location.href='https://cms.apache.org/redirect?uri='+escape(location.href))" class="btn">Yes</a>
                <a href="javascript:void(location.href='https://anonymous:@cms.apache.org/redirect?uri='+escape(location.href))" class="btn">No</a>
            </div>
        </div>
        <script src="./../resources/js/bootstrap-modal.js"></script>

        <footer>
            <p>Copyright &copy; 1999-2016 The Apache Software Foundation, Licensed under the Apache License, Version 2.0.
                Apache TomEE, TomEE, Apache, the Apache feather logo, and the Apache TomEE project logo are trademarks of The Apache Software Foundation.
                All other marks mentioned may be trademarks or registered trademarks of their respective owners.</p>
        </footer>

    </div> <!-- /container -->

    <!-- Javascript
    ================================================== -->
    <!-- Placed at the end of the document so the pages load faster -->
    <script src="./../resources/js/bootstrap-dropdown.js"></script>

  </body>
</html>
