If your TestSuite is a singleton (as it sounds like), you can make a package variable ($TestSuite::ts) that contains the one TestSuite that's been instantiated, and then everybody can have at it as they like.

If you plan to have more than one TestSuite, have it hand itself to its sub-objects at their creation.

$ts->make_a_blob();
$ts->{blob}->{your_lord_and_master} = $ts;
weaken $ts->{blob}->{your_lord_and_master};
[download]

Note the importance of using weaken from Scalar::Util to create a weak reference. Without that, the circular references we just created will keep the objects from being destroyed properly when it's time to collect garbage.

Then Blob::print_stuff() can look at $self->{your_lord_and_master}->{info} and more.

Thanks folks, I think the package variable is probably the correct answer here :-)

A few possibilities. Simplest is just to make $ts a global, even if that becomes $TestSuite::ts. The painful part here is just to keep ts pointing to the right object at all times if there can be more than one TestSuite object active in the process at a time. Not hard, just tedious.

Next is to pass in $ts, not $ts->{info}. Because although print_stuff needs access to $ts->{info}, frobnicator may need access to $ts->{frobs}. A consistent framework where the $ts is always passed in may suffice.

Finally, your factory method (where you create the objects) could just take the test suite object as a parameter, and put it into the object being created such that $ts->{blob}->{testsuite} == $ts. Then in print_stuff, you'd be able to use $self->{testsuite}->{info}.

That said, I wouldn't actually suggest accessing other objects' internals directly like that. Make accessor methods to do it. Just nicer that way.

Globals suck. Make a method which returns that data. Zing, now it's accessible to all subclasses, it's encapsulated behind a nice interface, and it's not stompable elsewhere by accident.

Your reply does not help at all. Maybe read the question again?

Hint: Just replace every "$ts->{info}" in the question with "$ts->info()" while reading...

---

_Search, Ask, ^Know

I can read just fine, thank you. I said "globals suck". Perhaps I should have been more explicit to say "passing parameters is much better, and I think you'll appreciate that design more in the future if you have to make further changes."

I have created a hierarchy of classes in OO style for a testing program

Not an answer to your question... and I'm obviously biased... but have you looked at Test::Class?

• Catalyst and Excel::Template both solve this problem by passing the context around to every method. In E::T, this is an actual Excel::Template::Context object. In Catalyst, this is a Catalyst::Controller object. So, every method in both starts as so:

  sub floober {
      my ($self, $c) = @_;
  }
  [download]

• DBM::Deep prefers to provide a reference to the context in the instantiation of every object, then weaken it. So, every object can call $self->engine and get the context object. Thus, every constructor looks like:

  sub new {
      my $class = shift;
      my ($params) = @_;
  
      my $self = bless {}, $class;
      $self->{engine} = $params->{engine};
      Scalar::Util::weaken( $self->{engine} );
  
      return $self;
  }
  [download]

BUT ... you really need to use one of them. Messing around with globals is bad juju. That you're asking here is a sign that you feel it smells wrong. That's the sign of a software journeyman. To demonstrate mastery, you need to learn why it smells and how to avoid it.

use strict;

package TestSuite;

sub new {
    my ($this, $motto) = @_;
    bless { info => $motto }, $this;
}

sub make_a_blob {
    my ($self) = @_;
    $self->{blob} = Blob->new;
    return $self;
}

sub print_blob {
    my ($self) = @_;
    $self->{blob}->print_stuff(); 
}


package Blob;
use PadWalker qw(peek_my);

sub new {        
    bless {}, shift;
}

sub print_stuff {
    my $callerObject = ${peek_my(1)->{'$self'}};
    print $callerObject->{info}."\n";
}


package main;

my $ts = new TestSuite("The holy grail!"); 
my $ts2 = new TestSuite("A rotten apple!"); 
$ts->make_a_blob();
$ts->print_blob();
$ts2->make_a_blob->print_blob;

__DATA__
The holy grail!
A rotten apple!
[download]