Hi,
                  
                  
                  To start with, indeed, the ecosystem isn't that
                    big anymore, so whatever we do we have to take this
                    fact into account. Was it still 2010 with larger
                    amounts of users and available resources, other
                    choices might have been made.
                  
                  
                  For Mojarra we have multiple versions of tests
                  
                  
                  
                  2. Integration tests using Arquillian
                  3. Internal tests using Cactus
                  4. JUnit tests using Mock types
                  
                  
                  I'm going to delete the Cactus tests. It's simply
                    undoable to either convert or maintain them.
                  
                  
                  
                  
                  
                  The cargo/script based tests are very easy to
                    convert to Arquillian (copy/paste, add arquillian
                    runner and deploy annotations), but even that of
                    course takes work. Finally there's 921 unit tests,
                    where everything is mocked.
                  
                  
                  So where does that leave us? The Arquillian tests
                    of Mojarra and Myfaces could be joined, but we both
                    don't have that many of them. They can be, more or
                    less, instantly rubber stamped as TCK. This is
                    essentially how the CDI, Batch, Validation, and all
                    MP TCKs work. I can spend a few days picking a
                    selection of tests from the cargo reservoir, which
                    should give us a reasonable base. I'm not sure if we
                    will reach 100.
                  
                  
                  As for the unit tests, we've been working on a
                    servlet/EE runtime implementation called Piranha,
                    that at its lowest level can be used like a unit
                    testing framework. This feels just like using a
                    servlet mock, except that the servlet implementation
                    is the same one the higher level server actually
                    uses. Maybe this is an option for the future to use.
                  
                  
                  For now though my gut feeling says that if we can
                    agree on rubber stamping the existing Arquillian
                    tests as TCK we're essentially there. There's some
                    specs that don't have a TCK, but those are always
                    trouble, so it's best to have at least a small TCK.
                  
                  
                  Kind regards,
                  Arjan