fixup: remove underscores and unify test naming

core/unit_test/tstAoSoA.hpp

@@ -606,19 +606,19 @@ void testUnmanaged()
 //---------------------------------------------------------------------------//
 // RUN TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, aosoa_test ) { testAoSoA(); }
+TEST( AoSoA, Test ) { testAoSoA(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, aosoa_raw_data_test ) { testRawData(); }
+TEST( AoSoA, RawData ) { testRawData(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, aosoa_tuple_test ) { testTuple(); }
+TEST( AoSoA, Tuple ) { testTuple(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, aosoa_access_test ) { testAccess(); }
+TEST( AoSoA, Access ) { testAccess(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, aosoa_unmanaged_test ) { testUnmanaged(); }
+TEST( AoSoA, Unmanaged ) { testUnmanaged(); }
 
 //---------------------------------------------------------------------------//
 

core/unit_test/tstCartesianGrid.cpp

@@ -19,7 +19,7 @@
 namespace Test
 {
 
-TEST( cabana_cartesian_grid, grid_test )
+TEST( CartesianGrid, Test )
 {
     double min[3] = { -1.0, -0.5, -0.6 };
     double max[3] = { 2.5, 1.5, 1.9 };

core/unit_test/tstCommunicationPlan.hpp

@@ -595,35 +595,35 @@ void testTopology()
 //---------------------------------------------------------------------------//
 // RUN TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, comm_plan_test_1 ) { test1( true ); }
+TEST( CommPlan, Test1 ) { test1( true ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_2 ) { test2( true ); }
+TEST( CommPlan, Test2 ) { test2( true ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_3 ) { test3( true ); }
+TEST( CommPlan, Test3 ) { test3( true ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_4 ) { test4( true ); }
+TEST( CommPlan, Test4 ) { test4( true ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_5 ) { test5( true ); }
+TEST( CommPlan, Test5 ) { test5( true ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_6 ) { test6( true ); }
+TEST( CommPlan, Test6 ) { test6( true ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_7 ) { test7( true ); }
+TEST( CommPlan, Test7 ) { test7( true ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_1_no_topo ) { test1( false ); }
+TEST( CommPlan, Test1NoTopo ) { test1( false ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_2_no_topo ) { test2( false ); }
+TEST( CommPlan, Test2NoTopo ) { test2( false ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_3_no_topo ) { test3( false ); }
+TEST( CommPlan, Test3NoTopo ) { test3( false ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_4_no_topo ) { test4( false ); }
+TEST( CommPlan, Test4NoTopo ) { test4( false ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_5_no_topo ) { test5( false ); }
+TEST( CommPlan, Test5NoTopo ) { test5( false ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_6_no_topo ) { test6( false ); }
+TEST( CommPlan, Test6NoTopo ) { test6( false ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_7_no_topo ) { test7( false ); }
+TEST( CommPlan, Test7NoTopo ) { test7( false ); }
 
-TEST( TEST_CATEGORY, comm_plan_test_topology ) { testTopology(); }
+TEST( CommPlan, TestTopology ) { testTopology(); }
 
 //---------------------------------------------------------------------------//
 

core/unit_test/tstDeepCopy.hpp

@@ -443,21 +443,21 @@ void testAssign()
 //---------------------------------------------------------------------------//
 // TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, deep_copy_to_host_same_layout_test )
+TEST( DeepCopy, ToHostSameLayout )
 {
     testAoSoADeepCopy<Kokkos::HostSpace, TEST_MEMSPACE, 16, 16>();
     testParticleListDeepCopy<Kokkos::HostSpace, TEST_MEMSPACE, 16, 16>();
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, deep_copy_from_host_same_layout_test )
+TEST( DeepCopy, FromHostSameLayout )
 {
     testAoSoADeepCopy<TEST_MEMSPACE, Kokkos::HostSpace, 16, 16>();
     testParticleListDeepCopy<TEST_MEMSPACE, Kokkos::HostSpace, 16, 16>();
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, deep_copy_to_host_different_layout_test )
+TEST( DeepCopy, ToHostDifferentLayout )
 {
     testAoSoADeepCopy<Kokkos::HostSpace, TEST_MEMSPACE, 16, 32>();
     testAoSoADeepCopy<Kokkos::HostSpace, TEST_MEMSPACE, 64, 8>();
@@ -466,7 +466,7 @@ TEST( TEST_CATEGORY, deep_copy_to_host_different_layout_test )
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, deep_copy_from_host_different_layout_test )
+TEST( DeepCopy, FromHostDifferentLayout )
 {
     testAoSoADeepCopy<TEST_MEMSPACE, Kokkos::HostSpace, 64, 8>();
     testAoSoADeepCopy<TEST_MEMSPACE, Kokkos::HostSpace, 16, 32>();
@@ -475,10 +475,10 @@ TEST( TEST_CATEGORY, deep_copy_from_host_different_layout_test )
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, mirror_test ) { testMirror(); }
+TEST( DeepCopy, Mirror ) { testMirror(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, assign_test ) { testAssign(); }
+TEST( DeepCopy, Assign ) { testAssign(); }
 
 //---------------------------------------------------------------------------//
 

core/unit_test/tstDistributor.hpp

@@ -756,41 +756,41 @@ void test9( const bool use_topology )
 //---------------------------------------------------------------------------//
 // RUN TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, distributor_test_1 ) { test1( true ); }
+TEST( Distributor, Test1 ) { test1( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_2 ) { test2( true ); }
+TEST( Distributor, Test2 ) { test2( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_3 ) { test3( true ); }
+TEST( Distributor, Test3 ) { test3( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_4 ) { test4( true ); }
+TEST( Distributor, Test4 ) { test4( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_5 ) { test5( true ); }
+TEST( Distributor, Test5 ) { test5( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_6 ) { test6( true ); }
+TEST( Distributor, Test6 ) { test6( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_7 ) { test7( true ); }
+TEST( Distributor, Test7 ) { test7( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_8 ) { test8( true ); }
+TEST( Distributor, Test8 ) { test8( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_9 ) { test9( true ); }
+TEST( Distributor, Test9 ) { test9( true ); }
 
-TEST( TEST_CATEGORY, distributor_test_1_no_topo ) { test1( false ); }
+TEST( Distributor, Test1NoTopo ) { test1( false ); }
 
-TEST( TEST_CATEGORY, distributor_test_2_no_topo ) { test2( false ); }
+TEST( Distributor, Test2NoTopo ) { test2( false ); }
 
-TEST( TEST_CATEGORY, distributor_test_3_no_topo ) { test3( false ); }
+TEST( Distributor, Test3NoTopo ) { test3( false ); }
 
-TEST( TEST_CATEGORY, distributor_test_4_no_topo ) { test4( false ); }
+TEST( Distributor, Test4NoTopo ) { test4( false ); }
 
-TEST( TEST_CATEGORY, distributor_test_5_no_topo ) { test5( false ); }
+TEST( Distributor, Test5NoTopo ) { test5( false ); }
 
-TEST( TEST_CATEGORY, distributor_test_6_no_topo ) { test6( false ); }
+TEST( Distributor, Test6NoTopo ) { test6( false ); }
 
-TEST( TEST_CATEGORY, distributor_test_7_no_topo ) { test7( false ); }
+TEST( Distributor, Test7NoTopo ) { test7( false ); }
 
-TEST( TEST_CATEGORY, distributor_test_8_no_topo ) { test8( false ); }
+TEST( Distributor, Test8NoTopo ) { test8( false ); }
 
-TEST( TEST_CATEGORY, distributor_test_9_no_topo ) { test9( false ); }
+TEST( Distributor, Test9NoTopo ) { test9( false ); }
 
 //---------------------------------------------------------------------------//
 

core/unit_test/tstHDF5ParticleOutput.hpp

@@ -191,7 +191,7 @@ void writeReadTest()
 //---------------------------------------------------------------------------//
 // RUN TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, write_read_test ) { writeReadTest(); }
+TEST( HDF5, WriteRead ) { writeReadTest(); }
 
 //---------------------------------------------------------------------------//
 

core/unit_test/tstHalo.hpp

@@ -586,26 +586,26 @@ void testHaloBuffers( TestTag tag, const bool use_topology )
 // RUN TESTS
 //---------------------------------------------------------------------------//
 // test without collisions (each ghost is unique)
-TEST( TEST_CATEGORY, halo_test_unique )
+TEST( Halo, Unique )
 {
     testHalo( UniqueTestTag{}, true );
     testHaloBuffers( UniqueTestTag{}, true );
 }
 
-TEST( TEST_CATEGORY, halo_test_unique_no_topo )
+TEST( Halo, UniqueNoTopo )
 {
     testHalo( UniqueTestTag{}, false );
     testHaloBuffers( UniqueTestTag{}, false );
 }
 
 // tests with collisions (each ghost is duplicated on all ranks)
-TEST( TEST_CATEGORY, halo_test_all )
+TEST( Halo, All )
 {
     testHalo( AllTestTag{}, true );
     testHaloBuffers( AllTestTag{}, false );
 }
 
-TEST( TEST_CATEGORY, halo_test_all_no_topo )
+TEST( Halo, AllNoTopo )
 {
     testHalo( AllTestTag{}, false );
     testHaloBuffers( AllTestTag{}, false );

core/unit_test/tstIndex.cpp

@@ -21,7 +21,7 @@
 namespace Test
 {
 
-TEST( cabana_index, index_test )
+TEST( Index, Test )
 {
     auto aosoa_idx_s = Cabana::Impl::Index<16>::s( 40 );
     auto aosoa_idx_i = Cabana::Impl::Index<16>::a( 40 );

core/unit_test/tstLinkedCellList.hpp

@@ -770,23 +770,21 @@ void testLinkedListView()
 //---------------------------------------------------------------------------//
 // RUN TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, linked_cell_stencil_test ) { testLinkedCellStencil(); }
+//---------------------------------------------------------------------------//
+TEST( LinkedCellList, Stencil ) { testLinkedCellStencil(); }
 
-TEST( TEST_CATEGORY, linked_list_test ) { testLinkedList(); }
+TEST( LinkedCellList, AoSoA ) { testLinkedList(); }
 
-TEST( TEST_CATEGORY, linked_list_slice_test ) { testLinkedListSlice(); }
+TEST( LinkedCellList, Slice ) { testLinkedListSlice(); }
 
-TEST( TEST_CATEGORY, linked_list_neighbor_test )
-{
-    testLinkedCellNeighborInterface();
-}
+TEST( LinkedCellList, Neighbor ) { testLinkedCellNeighborInterface(); }
 
-TEST( TEST_CATEGORY, linked_list_parallel_test ) { testLinkedCellParallel(); }
+TEST( LinkedCellList, ParallelFor ) { testLinkedCellParallel(); }
 
-TEST( TEST_CATEGORY, linked_list_reduce_test ) { testLinkedCellReduce(); }
+TEST( LinkedCellList, ParallelReduce ) { testLinkedCellReduce(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, linked_list_view_test ) { testLinkedListView(); }
+TEST( LinkedCellList, linked_list_view_test ) { testLinkedListView(); }
 
 //---------------------------------------------------------------------------//
 

core/unit_test/tstNeighborList.hpp

@@ -335,8 +335,7 @@ void testNeighborHistogram()
 //---------------------------------------------------------------------------//
 // TESTS
 //---------------------------------------------------------------------------//
-
-TEST( TEST_CATEGORY, verlet_list_full_test )
+TEST( VerletList, Full )
 {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET // FIXME_OPENMPTARGET
     testVerletListFull<Cabana::VerletLayoutCSR, Cabana::TeamOpTag>();
@@ -350,7 +349,7 @@ TEST( TEST_CATEGORY, verlet_list_full_test )
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, verlet_list_half_test )
+TEST( VerletList, Half )
 {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET // FIXME_OPENMPTARGET
     testVerletListHalf<Cabana::VerletLayoutCSR, Cabana::TeamOpTag>();
@@ -364,7 +363,7 @@ TEST( TEST_CATEGORY, verlet_list_half_test )
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, verlet_list_full_range_test )
+TEST( VerletList, FullRange )
 {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET // FIXME_OPENMPTARGET
     testVerletListFullPartialRange<Cabana::VerletLayoutCSR,
@@ -381,7 +380,7 @@ TEST( TEST_CATEGORY, verlet_list_full_range_test )
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, parallel_for_test )
+TEST( VerletList, ParallelFor )
 {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET // FIXME_OPENMPTARGET
     testNeighborParallelFor<Cabana::VerletLayoutCSR>();
@@ -390,7 +389,7 @@ TEST( TEST_CATEGORY, parallel_for_test )
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, parallel_reduce_test )
+TEST( VerletList, ParallelReduce )
 {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET // FIXME_OPENMPTARGET
     testNeighborParallelReduce<Cabana::VerletLayoutCSR>();
@@ -399,7 +398,7 @@ TEST( TEST_CATEGORY, parallel_reduce_test )
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, modify_list_test )
+TEST( VerletList, ModifyList )
 {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET // FIXME_OPENMPTARGET
     testModifyNeighbors<Cabana::VerletLayoutCSR>();
@@ -408,7 +407,7 @@ TEST( TEST_CATEGORY, modify_list_test )
 }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, neighbor_histogram_test )
+TEST( VerletList, NeighborHistogram )
 {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
     testNeighborHistogram<Cabana::VerletLayoutCSR>();

core/unit_test/tstNeighborListArborX.hpp

@@ -290,25 +290,19 @@ void testNeighborArborXParallelReduce()
 //---------------------------------------------------------------------------//
 // TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, neighbor_list_full_test ) { testArborXListFull(); }
+TEST( ArborXList, Full ) { testArborXListFull(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, neighbor_list_half_test ) { testArborXListHalf(); }
+TEST( ArborXList, Half ) { testArborXListHalf(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, neighbor_list_full_range_test )
-{
-    testArborXListFullPartialRange();
-}
+TEST( ArborXList, FullRange ) { testArborXListFullPartialRange(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, parallel_for_test ) { testNeighborArborXParallelFor(); }
+TEST( ArborXList, ParallelFor ) { testNeighborArborXParallelFor(); }
 
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, parallel_reduce_test )
-{
-    testNeighborArborXParallelReduce();
-}
+TEST( ArborXList, ParallelReduce ) { testNeighborArborXParallelReduce(); }
 //---------------------------------------------------------------------------//
 
 } // end namespace Test

core/unit_test/tstParallel.hpp

@@ -250,7 +250,7 @@ void runTest2d()
 //---------------------------------------------------------------------------//
 // RUN TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, simd_parallel_for_test ) { runTest2d(); }
+TEST( SimdParallel, ParallelFor ) { runTest2d(); }
 
 //---------------------------------------------------------------------------//
 

core/unit_test/tstParameterPack.hpp

@@ -55,9 +55,9 @@ void emptyTest() { std::ignore = Cabana::makeParameterPack(); }
 //---------------------------------------------------------------------------//
 // RUN TESTS
 //---------------------------------------------------------------------------//
-TEST( TEST_CATEGORY, parameter_pack_capture ) { captureTest(); }
+TEST( ParameterPack, Capture ) { captureTest(); }
 
-TEST( TEST_CATEGORY, parameter_pack_empty ) { emptyTest(); }
+TEST( ParameterPack, Empty ) { emptyTest(); }
 
 //---------------------------------------------------------------------------//