Hi,
                If we are going to consider keeping the
                  Corba references in the Platform TCK for Jakarta EE
                  9.1, it would be good to see TCK changes soon for
                  that.  The goal of doing that is being able to run the
                  Corba using tests on Java SE 11.  The other goal is to
                  allow Jakarta EE implementations that do not include
                  Corba API/impl classes to run the Jakarta EE Platform
                  TCK tests without having to run the (certain to fail
                  for them) Corba using tests.  
                
                [1] is one example of how we moved the
                  JAX-RS tests that use JAXB, into a new (separate)
                  package.  For example, we moved (JAXB using) tests
                  from the existing `com.sun.ts.tests.jaxrs.spec.provider.standard`
                      package into `
                  com.sun.ts.tests.jaxrs.spec.provider.standardwithxmlbinding`. 
                          I would like to submit this as an example of
                          the type of change we could make to the EJB
                          tests that use Corba, to better isolate the
                          Corba tests so they *could* be made optional. 
                          I'm sharing this information to ensure that
                          all involved have an understanding of one way
                          we could make only the tests that need Corba
                          optional.  Since it is not yet decided what
                          the Jakarta Enterprise Beans Specification
                          will do with Corba in Jakarta EE 9.1, this
                          email is assuming that keeping the Corba tests
                          is an option (as per some previous
                          discussions). 
                        
                The basic pattern for the EJB30
                          tests that use Corba, could be something like:
                1.  Duplicate each EJB test
                          client (e.g. *Client*.java) that has some
                          tests that use Corba.  The idea being to make
                          a complete copy of the Corba using test client
                          class along with the related classes
                          (typically in the same package with the
                          exception of a shared abstract EJB test
                          class).
                2.  In the Corba using copy of
                          the test, only keep the Corba using test code.
                        
                3.  In the non-Corba original
                          test, remove the Corba using test code.
                With the ^ simple pattern, we
                          will end up with duplicated code in some cases
                          but that is okay.  We can do better at
                          cleaning up the duplication but I favor simple
                          changes when possible.  
                        
                I probably spent more time on
                          refactoring the various tests to remove unused
                          imports than I wanted but I am very happy with
                          the results.  I basically did this for all
                          tests except for the web services tests (due
                          to some mistakes that Eclipse IDE kept making
                          due to my bad Eclipse profile for TCK).  IMO
                          it would be good to make the simple EJB test
                          changes first to separate Corba use and then
                          maybe a separate PR for refactoring to clean
                          it up.
                [1] separated the JAXB using tests into new
                  separate test clients so that each separate test
                  client can be specified in the keyword.properties file
                  [2] as enabled when a certain keyword is specified on
                  the `ant runclient` command line, for example `ant
                  -Dkeywords="javaee|xml_binding"` or `ant
                  -Dkeywords="javaee|corba"`.
                Scott
                [1] https://github.com/eclipse-ee4j/jakartaee-tck/commit/565e41159
                  [2] https://github.com/eclipse-ee4j/jakartaee-tck/blob/master/src/com/sun/ts/lib/harness/keyword.properties