I haven't used either Test::Spec or Test::Class previously. I managed to get these interacting at a very basic level: calling Test::Class::->runtests; from within a Test::Spec it() function.

The main script:

ken@ganymede: ~/tmp
$ cat pm_class_spec_comb.pl
#!/usr/bin/env perl

use strict;
use warnings;

use Test::Spec;
use Test::Class::Example::Hello::Tests;

it 'runs Test::Spec and Test::Class tests' => sub {
    diag('Hello, world! (from Test::More::diag() as: diag())');
    print qq{Hello, world! (from Test::Spec::it() as: it CODE\n};
    Test::Class::->runtests;
    diag('Last it() statement.');
};

runtests unless caller;
[download]

The Test::Class::Example::Hello::Tests module:

ken@ganymede: ~/tmp/Test/Class/Example/Hello
$ cat Tests.pm 
package Test::Class::Example::Hello::Tests;

use base 'Test::Class';

sub test_Hello : Test {
    print qq{Hello, world! (from Test::Class as: sub test_Hello : Test
+\n};
    return 1;
}

1;
[download]

Sample run:

$ pm_class_spec_comb.pl
# Hello, world! (from Test::More::diag() as: diag())
Hello, world! (from Test::Spec::it() as: it CODE
1..1
Hello, world! (from Test::Class as: sub test_Hello : Test
ok 1 # skip 1
# Last it() statement.
[download]

I'll leave you to experiment further.

Thank you :o)

It's quite unexpected, but also not quite what i expected.
What you did here is run a Test::Class inside a Test::Spec.
What i would like would be to write a Test::Class in Test::Spec style, with the "describe/it" nested structure.

I still tried to add a "describe" assertion in the Test::Spec file, and a Test::More::ok() assertion into the Test.pm file, hoping that the TAP would produce a mixed output (i'm not sure how it would be useful, but i'm still interested by the experiment). But it didn't.
I added in the pm_class_spec_comb.pl file :

describe 'A mixed Test' => sub {
    it 'runs Test::Spec and Test::Class tests' => sub {
        [...]
    };
};
[download]

and in the Test.pm file :

use Test::More;
[download]

and

ok(1);
[download]

and it printed

ok 1 - test Hello
[download]

which is the normal Test::Class output. While i was hoping for it to write something mixed, like
"A mixed Test runs Test::Spec and Test::Class tests test Hello"

But anyway, this would still not be what i want.

Let me try to rephrase what i want.
In Test::Spec i can build "nested statements". For example,

describe 'A Fruit' => {

    [general tests on a Fruit, here]

    describe 'attached to its branch' => {
        [tests on Fruits which are still on their branch]
        [example :]
        it 'grows' => sub {
            ok(1);
        }
    };

    describe 'fallen on the floor' => {
        [tests on Fruits which have fallen on the floor]
    };

    describe 'on a pie' => sub {
        [tests on Fruits which are on a pie]
    }; 
};
[download]

And in each section, the output for each assertion will start with the corresponding context. For example i will read :

ok 1 - A fruit attached to its branch grows
[download]

This nested structure also enables nested declaration of the variables that i need for my tests. So, all the tests that are grouped together share the same variables, which can be re-initialized before each test, with the "before each" function. This way i don't need a $test variable to reinitialise and carry variables that are used in several tests : i can directly use my variables in several tests

See the @roll variable in my Game::Bowling example, for example. With Test::Class i would need to use $test->{roll} all the time, and i think i wouldn't be able to initialize it differently for different groups of tests.

I don't know if such a thing can be achieved with Test::Class.
I should maybe write my Game::Bowling example with Test::Class, to give a comparizon.

use Test::Class::Sugar;

testclass exercises Test::Class {
    my $test;
    startup >> 1 {
        ok $test->subject;
      }

      test autonaming {
        ok $test->subject;
    }

    test the naming of parts {
        ok $test->current_method, 'score';
    }

    test multiple assertions >> 2 {
        ok ref($test), 'Test::Class::Bowling';
          ok $test->current_method, 'test_multiple_assertions';
      } sub score {
        my $game           = Bowling->new;
        my @rolls          = (2) x 20;
        my $expected_score = 40;
    }
}

Test::Class->runtests;
[download]

The best idea i've come up with, right now, is using a similar technique to the one used by Damian Conway in the Perl6::Slurp tests with Test::More, and extend it to Test::Class. Here is what he does, to avoid duplicating the test name (Test::Class does this automatically, with the subroutine name) :

my $desc;
sub TEST { $desc = $_[0] };

TEST "can't slurp in void context";
# your test here
ok 1, $desc;
[download]

What i did to extend it to groups of tests in Test::Class, is to use Tests() groups, and having the TEST subroutine declare a test description for each test, and append the subroutine name at the beginning. Like this :

use strict;
use warnings;   #comment before releasing

use Perl6::Say;
use Time::TimeTick;

# TEST :
# my function for displaying information about each test,
# in a Test::Class Test subroutine with several tests
my $desc;
sub TEST { 
    my $test_name   = $_[0]; 
    
    my $caller_func = (caller(1))[3]; # the subroutine full name
    my $test_group  
        = (split('::', $caller_func))[-1]; # only the subroutine name
    $test_group =~ s/_/ /g; # replace underscores by spaces

    $desc = "$test_group  $test_name"; 
};

use base qw(Test::Class);  
use Test::More 0.98;

__PACKAGE__->runtests unless caller;

sub A_Fruit__On_a_branch : Tests(3) {

    TEST "Grows";
    ok 1, $desc;
    
    TEST "Can rot";
    ok 1, $desc;

    TEST "Can fall";
    ok 1, $desc;

}; 

sub A_Fruit__On_the_floor__Rots : Test {
    ok 1;
}

done_testing();
1;
[download]

The output is

1..4
ok 1 - A Fruit  On a branch  Grows
ok 2 - A Fruit  On a branch  Can rot
ok 3 - A Fruit  On a branch  Can fall
ok 4 - A Fruit  On the floor  Rots
[download]

Conclusion :
This does part of what i want : my (one level) nested structure enables me to avoid duplication in test names.
And it doesn't do some of the things that i want (and that Test::Spec does - just check the synopsis) :
- more than one level nested structure.
- different "before" setup functions in different test groups.
- nested "before" setup functions : "The setup work done in each before block cascades from one level to the next"

PS : i just realized, i have no idea to which extent this would work with the Test::Class inheritance process. I guess i'll have to try.

And same thing if i implemented a bit of Test::Spec into Test::Class (i thought of a possible not-too-hard way to implement "describe" and "before each"), i'm not sure that it would work with inheritance. You can inherit a subroutine, but how do you inherit it's context ("describe" and "before each" nested structure) ?

Cheers =)

If i understood well, Test::Class::Sugar is one particular type of sugar. And i would need to use Test::Class::Sugar::CodeGenerator to create my own, which feels too complex for me now.
I also checked the Test::Spec code, with the same result : too complex for me to build something equivalent.