my $expected_version = "0.000145";
print("import: Test2::AsyncSubtest\n");
use Test2::AsyncSubtest;

if (defined Test2::AsyncSubtest->VERSION) {
	my $given_version = Test2::AsyncSubtest->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::AsyncSubtest->VERSION . '
');

}
print("import: Test2::AsyncSubtest::Event::Attach\n");
use Test2::AsyncSubtest::Event::Attach;

if (defined Test2::AsyncSubtest::Event::Attach->VERSION) {
	my $given_version = Test2::AsyncSubtest::Event::Attach->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::AsyncSubtest::Event::Attach->VERSION . '
');

}
print("import: Test2::AsyncSubtest::Event::Detach\n");
use Test2::AsyncSubtest::Event::Detach;

if (defined Test2::AsyncSubtest::Event::Detach->VERSION) {
	my $given_version = Test2::AsyncSubtest::Event::Detach->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::AsyncSubtest::Event::Detach->VERSION . '
');

}
print("import: Test2::AsyncSubtest::Hub\n");
use Test2::AsyncSubtest::Hub;

if (defined Test2::AsyncSubtest::Hub->VERSION) {
	my $given_version = Test2::AsyncSubtest::Hub->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::AsyncSubtest::Hub->VERSION . '
');

}
print("import: Test2::Bundle\n");
use Test2::Bundle;

if (defined Test2::Bundle->VERSION) {
	my $given_version = Test2::Bundle->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Bundle->VERSION . '
');

}
print("import: Test2::Bundle::Extended\n");
use Test2::Bundle::Extended;

if (defined Test2::Bundle::Extended->VERSION) {
	my $given_version = Test2::Bundle::Extended->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Bundle::Extended->VERSION . '
');

}
print("import: Test2::Bundle::More\n");
use Test2::Bundle::More;

if (defined Test2::Bundle::More->VERSION) {
	my $given_version = Test2::Bundle::More->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Bundle::More->VERSION . '
');

}
print("import: Test2::Bundle::Simple\n");
use Test2::Bundle::Simple;

if (defined Test2::Bundle::Simple->VERSION) {
	my $given_version = Test2::Bundle::Simple->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Bundle::Simple->VERSION . '
');

}
print("import: Test2::Compare\n");
use Test2::Compare;

if (defined Test2::Compare->VERSION) {
	my $given_version = Test2::Compare->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare->VERSION . '
');

}
print("import: Test2::Compare::Array\n");
use Test2::Compare::Array;

if (defined Test2::Compare::Array->VERSION) {
	my $given_version = Test2::Compare::Array->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Array->VERSION . '
');

}
print("import: Test2::Compare::Bag\n");
use Test2::Compare::Bag;

if (defined Test2::Compare::Bag->VERSION) {
	my $given_version = Test2::Compare::Bag->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Bag->VERSION . '
');

}
print("import: Test2::Compare::Base\n");
use Test2::Compare::Base;

if (defined Test2::Compare::Base->VERSION) {
	my $given_version = Test2::Compare::Base->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Base->VERSION . '
');

}
print("import: Test2::Compare::Bool\n");
use Test2::Compare::Bool;

if (defined Test2::Compare::Bool->VERSION) {
	my $given_version = Test2::Compare::Bool->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Bool->VERSION . '
');

}
print("import: Test2::Compare::Custom\n");
use Test2::Compare::Custom;

if (defined Test2::Compare::Custom->VERSION) {
	my $given_version = Test2::Compare::Custom->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Custom->VERSION . '
');

}
print("import: Test2::Compare::DeepRef\n");
use Test2::Compare::DeepRef;

if (defined Test2::Compare::DeepRef->VERSION) {
	my $given_version = Test2::Compare::DeepRef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::DeepRef->VERSION . '
');

}
print("import: Test2::Compare::Delta\n");
use Test2::Compare::Delta;

if (defined Test2::Compare::Delta->VERSION) {
	my $given_version = Test2::Compare::Delta->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Delta->VERSION . '
');

}
print("import: Test2::Compare::Event\n");
use Test2::Compare::Event;

if (defined Test2::Compare::Event->VERSION) {
	my $given_version = Test2::Compare::Event->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Event->VERSION . '
');

}
print("import: Test2::Compare::EventMeta\n");
use Test2::Compare::EventMeta;

if (defined Test2::Compare::EventMeta->VERSION) {
	my $given_version = Test2::Compare::EventMeta->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::EventMeta->VERSION . '
');

}
print("import: Test2::Compare::Float\n");
use Test2::Compare::Float;

if (defined Test2::Compare::Float->VERSION) {
	my $given_version = Test2::Compare::Float->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Float->VERSION . '
');

}
print("import: Test2::Compare::Hash\n");
use Test2::Compare::Hash;

if (defined Test2::Compare::Hash->VERSION) {
	my $given_version = Test2::Compare::Hash->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Hash->VERSION . '
');

}
print("import: Test2::Compare::Isa\n");
use Test2::Compare::Isa;

if (defined Test2::Compare::Isa->VERSION) {
	my $given_version = Test2::Compare::Isa->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Isa->VERSION . '
');

}
print("import: Test2::Compare::Meta\n");
use Test2::Compare::Meta;

if (defined Test2::Compare::Meta->VERSION) {
	my $given_version = Test2::Compare::Meta->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Meta->VERSION . '
');

}
print("import: Test2::Compare::Negatable\n");
use Test2::Compare::Negatable;

if (defined Test2::Compare::Negatable->VERSION) {
	my $given_version = Test2::Compare::Negatable->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Negatable->VERSION . '
');

}
print("import: Test2::Compare::Number\n");
use Test2::Compare::Number;

if (defined Test2::Compare::Number->VERSION) {
	my $given_version = Test2::Compare::Number->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Number->VERSION . '
');

}
print("import: Test2::Compare::Object\n");
use Test2::Compare::Object;

if (defined Test2::Compare::Object->VERSION) {
	my $given_version = Test2::Compare::Object->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Object->VERSION . '
');

}
print("import: Test2::Compare::OrderedSubset\n");
use Test2::Compare::OrderedSubset;

if (defined Test2::Compare::OrderedSubset->VERSION) {
	my $given_version = Test2::Compare::OrderedSubset->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::OrderedSubset->VERSION . '
');

}
print("import: Test2::Compare::Pattern\n");
use Test2::Compare::Pattern;

if (defined Test2::Compare::Pattern->VERSION) {
	my $given_version = Test2::Compare::Pattern->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Pattern->VERSION . '
');

}
print("import: Test2::Compare::Ref\n");
use Test2::Compare::Ref;

if (defined Test2::Compare::Ref->VERSION) {
	my $given_version = Test2::Compare::Ref->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Ref->VERSION . '
');

}
print("import: Test2::Compare::Regex\n");
use Test2::Compare::Regex;

if (defined Test2::Compare::Regex->VERSION) {
	my $given_version = Test2::Compare::Regex->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Regex->VERSION . '
');

}
print("import: Test2::Compare::Scalar\n");
use Test2::Compare::Scalar;

if (defined Test2::Compare::Scalar->VERSION) {
	my $given_version = Test2::Compare::Scalar->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Scalar->VERSION . '
');

}
print("import: Test2::Compare::Set\n");
use Test2::Compare::Set;

if (defined Test2::Compare::Set->VERSION) {
	my $given_version = Test2::Compare::Set->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Set->VERSION . '
');

}
print("import: Test2::Compare::String\n");
use Test2::Compare::String;

if (defined Test2::Compare::String->VERSION) {
	my $given_version = Test2::Compare::String->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::String->VERSION . '
');

}
print("import: Test2::Compare::Undef\n");
use Test2::Compare::Undef;

if (defined Test2::Compare::Undef->VERSION) {
	my $given_version = Test2::Compare::Undef->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Undef->VERSION . '
');

}
print("import: Test2::Compare::Wildcard\n");
use Test2::Compare::Wildcard;

if (defined Test2::Compare::Wildcard->VERSION) {
	my $given_version = Test2::Compare::Wildcard->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Compare::Wildcard->VERSION . '
');

}
print("import: Test2::Manual\n");
use Test2::Manual;

if (defined Test2::Manual->VERSION) {
	my $given_version = Test2::Manual->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual->VERSION . '
');

}
print("import: Test2::Manual::Anatomy\n");
use Test2::Manual::Anatomy;

if (defined Test2::Manual::Anatomy->VERSION) {
	my $given_version = Test2::Manual::Anatomy->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Anatomy->VERSION . '
');

}
print("import: Test2::Manual::Anatomy::API\n");
use Test2::Manual::Anatomy::API;

if (defined Test2::Manual::Anatomy::API->VERSION) {
	my $given_version = Test2::Manual::Anatomy::API->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Anatomy::API->VERSION . '
');

}
print("import: Test2::Manual::Anatomy::Context\n");
use Test2::Manual::Anatomy::Context;

if (defined Test2::Manual::Anatomy::Context->VERSION) {
	my $given_version = Test2::Manual::Anatomy::Context->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Anatomy::Context->VERSION . '
');

}
print("import: Test2::Manual::Anatomy::EndToEnd\n");
use Test2::Manual::Anatomy::EndToEnd;

if (defined Test2::Manual::Anatomy::EndToEnd->VERSION) {
	my $given_version = Test2::Manual::Anatomy::EndToEnd->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Anatomy::EndToEnd->VERSION . '
');

}
print("import: Test2::Manual::Anatomy::Event\n");
use Test2::Manual::Anatomy::Event;

if (defined Test2::Manual::Anatomy::Event->VERSION) {
	my $given_version = Test2::Manual::Anatomy::Event->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Anatomy::Event->VERSION . '
');

}
print("import: Test2::Manual::Anatomy::Hubs\n");
use Test2::Manual::Anatomy::Hubs;

if (defined Test2::Manual::Anatomy::Hubs->VERSION) {
	my $given_version = Test2::Manual::Anatomy::Hubs->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Anatomy::Hubs->VERSION . '
');

}
print("import: Test2::Manual::Anatomy::IPC\n");
use Test2::Manual::Anatomy::IPC;

if (defined Test2::Manual::Anatomy::IPC->VERSION) {
	my $given_version = Test2::Manual::Anatomy::IPC->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Anatomy::IPC->VERSION . '
');

}
print("import: Test2::Manual::Anatomy::Utilities\n");
use Test2::Manual::Anatomy::Utilities;

if (defined Test2::Manual::Anatomy::Utilities->VERSION) {
	my $given_version = Test2::Manual::Anatomy::Utilities->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Anatomy::Utilities->VERSION . '
');

}
print("import: Test2::Manual::Concurrency\n");
use Test2::Manual::Concurrency;

if (defined Test2::Manual::Concurrency->VERSION) {
	my $given_version = Test2::Manual::Concurrency->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Concurrency->VERSION . '
');

}
print("import: Test2::Manual::Contributing\n");
use Test2::Manual::Contributing;

if (defined Test2::Manual::Contributing->VERSION) {
	my $given_version = Test2::Manual::Contributing->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Contributing->VERSION . '
');

}
print("import: Test2::Manual::Testing\n");
use Test2::Manual::Testing;

if (defined Test2::Manual::Testing->VERSION) {
	my $given_version = Test2::Manual::Testing->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Testing->VERSION . '
');

}
print("import: Test2::Manual::Testing::Introduction\n");
use Test2::Manual::Testing::Introduction;

if (defined Test2::Manual::Testing::Introduction->VERSION) {
	my $given_version = Test2::Manual::Testing::Introduction->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Testing::Introduction->VERSION . '
');

}
print("import: Test2::Manual::Testing::Migrating\n");
use Test2::Manual::Testing::Migrating;

if (defined Test2::Manual::Testing::Migrating->VERSION) {
	my $given_version = Test2::Manual::Testing::Migrating->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Testing::Migrating->VERSION . '
');

}
print("import: Test2::Manual::Testing::Planning\n");
use Test2::Manual::Testing::Planning;

if (defined Test2::Manual::Testing::Planning->VERSION) {
	my $given_version = Test2::Manual::Testing::Planning->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Testing::Planning->VERSION . '
');

}
print("import: Test2::Manual::Testing::Todo\n");
use Test2::Manual::Testing::Todo;

if (defined Test2::Manual::Testing::Todo->VERSION) {
	my $given_version = Test2::Manual::Testing::Todo->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Testing::Todo->VERSION . '
');

}
print("import: Test2::Manual::Tooling\n");
use Test2::Manual::Tooling;

if (defined Test2::Manual::Tooling->VERSION) {
	my $given_version = Test2::Manual::Tooling->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling->VERSION . '
');

}
print("import: Test2::Manual::Tooling::FirstTool\n");
use Test2::Manual::Tooling::FirstTool;

if (defined Test2::Manual::Tooling::FirstTool->VERSION) {
	my $given_version = Test2::Manual::Tooling::FirstTool->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::FirstTool->VERSION . '
');

}
print("import: Test2::Manual::Tooling::Formatter\n");
use Test2::Manual::Tooling::Formatter;

if (defined Test2::Manual::Tooling::Formatter->VERSION) {
	my $given_version = Test2::Manual::Tooling::Formatter->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::Formatter->VERSION . '
');

}
print("import: Test2::Manual::Tooling::Nesting\n");
use Test2::Manual::Tooling::Nesting;

if (defined Test2::Manual::Tooling::Nesting->VERSION) {
	my $given_version = Test2::Manual::Tooling::Nesting->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::Nesting->VERSION . '
');

}
print("import: Test2::Manual::Tooling::Plugin::TestExit\n");
use Test2::Manual::Tooling::Plugin::TestExit;

if (defined Test2::Manual::Tooling::Plugin::TestExit->VERSION) {
	my $given_version = Test2::Manual::Tooling::Plugin::TestExit->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::Plugin::TestExit->VERSION . '
');

}
print("import: Test2::Manual::Tooling::Plugin::TestingDone\n");
use Test2::Manual::Tooling::Plugin::TestingDone;

if (defined Test2::Manual::Tooling::Plugin::TestingDone->VERSION) {
	my $given_version = Test2::Manual::Tooling::Plugin::TestingDone->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::Plugin::TestingDone->VERSION . '
');

}
print("import: Test2::Manual::Tooling::Plugin::ToolCompletes\n");
use Test2::Manual::Tooling::Plugin::ToolCompletes;

if (defined Test2::Manual::Tooling::Plugin::ToolCompletes->VERSION) {
	my $given_version = Test2::Manual::Tooling::Plugin::ToolCompletes->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::Plugin::ToolCompletes->VERSION . '
');

}
print("import: Test2::Manual::Tooling::Plugin::ToolStarts\n");
use Test2::Manual::Tooling::Plugin::ToolStarts;

if (defined Test2::Manual::Tooling::Plugin::ToolStarts->VERSION) {
	my $given_version = Test2::Manual::Tooling::Plugin::ToolStarts->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::Plugin::ToolStarts->VERSION . '
');

}
print("import: Test2::Manual::Tooling::Subtest\n");
use Test2::Manual::Tooling::Subtest;

if (defined Test2::Manual::Tooling::Subtest->VERSION) {
	my $given_version = Test2::Manual::Tooling::Subtest->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::Subtest->VERSION . '
');

}
print("import: Test2::Manual::Tooling::TestBuilder\n");
use Test2::Manual::Tooling::TestBuilder;

if (defined Test2::Manual::Tooling::TestBuilder->VERSION) {
	my $given_version = Test2::Manual::Tooling::TestBuilder->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::TestBuilder->VERSION . '
');

}
print("import: Test2::Manual::Tooling::Testing\n");
use Test2::Manual::Tooling::Testing;

if (defined Test2::Manual::Tooling::Testing->VERSION) {
	my $given_version = Test2::Manual::Tooling::Testing->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Manual::Tooling::Testing->VERSION . '
');

}
print("import: Test2::Mock\n");
use Test2::Mock;

if (defined Test2::Mock->VERSION) {
	my $given_version = Test2::Mock->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Mock->VERSION . '
');

}
print("import: Test2::Plugin\n");
use Test2::Plugin;

if (defined Test2::Plugin->VERSION) {
	my $given_version = Test2::Plugin->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Plugin->VERSION . '
');

}
print("import: Test2::Plugin::BailOnFail\n");
use Test2::Plugin::BailOnFail;

if (defined Test2::Plugin::BailOnFail->VERSION) {
	my $given_version = Test2::Plugin::BailOnFail->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Plugin::BailOnFail->VERSION . '
');

}
print("import: Test2::Plugin::DieOnFail\n");
use Test2::Plugin::DieOnFail;

if (defined Test2::Plugin::DieOnFail->VERSION) {
	my $given_version = Test2::Plugin::DieOnFail->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Plugin::DieOnFail->VERSION . '
');

}
print("import: Test2::Plugin::ExitSummary\n");
use Test2::Plugin::ExitSummary;

if (defined Test2::Plugin::ExitSummary->VERSION) {
	my $given_version = Test2::Plugin::ExitSummary->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Plugin::ExitSummary->VERSION . '
');

}
print("import: Test2::Plugin::SRand\n");
use Test2::Plugin::SRand;

if (defined Test2::Plugin::SRand->VERSION) {
	my $given_version = Test2::Plugin::SRand->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Plugin::SRand->VERSION . '
');

}
print("import: Test2::Plugin::Times\n");
use Test2::Plugin::Times;

if (defined Test2::Plugin::Times->VERSION) {
	my $given_version = Test2::Plugin::Times->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Plugin::Times->VERSION . '
');

}
print("import: Test2::Plugin::UTF8\n");
use Test2::Plugin::UTF8;

if (defined Test2::Plugin::UTF8->VERSION) {
	my $given_version = Test2::Plugin::UTF8->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Plugin::UTF8->VERSION . '
');

}
print("import: Test2::Require\n");
use Test2::Require;

if (defined Test2::Require->VERSION) {
	my $given_version = Test2::Require->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Require->VERSION . '
');

}
print("import: Test2::Require::AuthorTesting\n");
use Test2::Require::AuthorTesting;

if (defined Test2::Require::AuthorTesting->VERSION) {
	my $given_version = Test2::Require::AuthorTesting->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Require::AuthorTesting->VERSION . '
');

}
print("import: Test2::Require::EnvVar\n");
use Test2::Require::EnvVar;

if (defined Test2::Require::EnvVar->VERSION) {
	my $given_version = Test2::Require::EnvVar->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Require::EnvVar->VERSION . '
');

}
print("import: Test2::Require::Fork\n");
use Test2::Require::Fork;

if (defined Test2::Require::Fork->VERSION) {
	my $given_version = Test2::Require::Fork->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Require::Fork->VERSION . '
');

}
print("import: Test2::Require::Module\n");
use Test2::Require::Module;

if (defined Test2::Require::Module->VERSION) {
	my $given_version = Test2::Require::Module->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Require::Module->VERSION . '
');

}
print("import: Test2::Require::Perl\n");
use Test2::Require::Perl;

if (defined Test2::Require::Perl->VERSION) {
	my $given_version = Test2::Require::Perl->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Require::Perl->VERSION . '
');

}
print("import: Test2::Require::RealFork\n");
use Test2::Require::RealFork;

if (defined Test2::Require::RealFork->VERSION) {
	my $given_version = Test2::Require::RealFork->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Require::RealFork->VERSION . '
');

}
print("import: Test2::Require::Threads\n");
use Test2::Require::Threads;

if (defined Test2::Require::Threads->VERSION) {
	my $given_version = Test2::Require::Threads->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Require::Threads->VERSION . '
');

}
print("import: Test2::Suite\n");
use Test2::Suite;

if (defined Test2::Suite->VERSION) {
	my $given_version = Test2::Suite->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Suite->VERSION . '
');

}
print("import: Test2::Todo\n");
use Test2::Todo;

if (defined Test2::Todo->VERSION) {
	my $given_version = Test2::Todo->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Todo->VERSION . '
');

}
print("import: Test2::Tools\n");
use Test2::Tools;

if (defined Test2::Tools->VERSION) {
	my $given_version = Test2::Tools->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools->VERSION . '
');

}
print("import: Test2::Tools::AsyncSubtest\n");
use Test2::Tools::AsyncSubtest;

if (defined Test2::Tools::AsyncSubtest->VERSION) {
	my $given_version = Test2::Tools::AsyncSubtest->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::AsyncSubtest->VERSION . '
');

}
print("import: Test2::Tools::Basic\n");
use Test2::Tools::Basic;

if (defined Test2::Tools::Basic->VERSION) {
	my $given_version = Test2::Tools::Basic->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Basic->VERSION . '
');

}
print("import: Test2::Tools::Class\n");
use Test2::Tools::Class;

if (defined Test2::Tools::Class->VERSION) {
	my $given_version = Test2::Tools::Class->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Class->VERSION . '
');

}
print("import: Test2::Tools::ClassicCompare\n");
use Test2::Tools::ClassicCompare;

if (defined Test2::Tools::ClassicCompare->VERSION) {
	my $given_version = Test2::Tools::ClassicCompare->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::ClassicCompare->VERSION . '
');

}
print("import: Test2::Tools::Compare\n");
use Test2::Tools::Compare;

if (defined Test2::Tools::Compare->VERSION) {
	my $given_version = Test2::Tools::Compare->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Compare->VERSION . '
');

}
print("import: Test2::Tools::Defer\n");
use Test2::Tools::Defer;

if (defined Test2::Tools::Defer->VERSION) {
	my $given_version = Test2::Tools::Defer->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Defer->VERSION . '
');

}
print("import: Test2::Tools::Encoding\n");
use Test2::Tools::Encoding;

if (defined Test2::Tools::Encoding->VERSION) {
	my $given_version = Test2::Tools::Encoding->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Encoding->VERSION . '
');

}
print("import: Test2::Tools::Event\n");
use Test2::Tools::Event;

if (defined Test2::Tools::Event->VERSION) {
	my $given_version = Test2::Tools::Event->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Event->VERSION . '
');

}
print("import: Test2::Tools::Exception\n");
use Test2::Tools::Exception;

if (defined Test2::Tools::Exception->VERSION) {
	my $given_version = Test2::Tools::Exception->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Exception->VERSION . '
');

}
print("import: Test2::Tools::Exports\n");
use Test2::Tools::Exports;

if (defined Test2::Tools::Exports->VERSION) {
	my $given_version = Test2::Tools::Exports->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Exports->VERSION . '
');

}
print("import: Test2::Tools::GenTemp\n");
use Test2::Tools::GenTemp;

if (defined Test2::Tools::GenTemp->VERSION) {
	my $given_version = Test2::Tools::GenTemp->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::GenTemp->VERSION . '
');

}
print("import: Test2::Tools::Grab\n");
use Test2::Tools::Grab;

if (defined Test2::Tools::Grab->VERSION) {
	my $given_version = Test2::Tools::Grab->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Grab->VERSION . '
');

}
print("import: Test2::Tools::Mock\n");
use Test2::Tools::Mock;

if (defined Test2::Tools::Mock->VERSION) {
	my $given_version = Test2::Tools::Mock->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Mock->VERSION . '
');

}
print("import: Test2::Tools::Ref\n");
use Test2::Tools::Ref;

if (defined Test2::Tools::Ref->VERSION) {
	my $given_version = Test2::Tools::Ref->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Ref->VERSION . '
');

}
print("import: Test2::Tools::Spec\n");
use Test2::Tools::Spec;

if (defined Test2::Tools::Spec->VERSION) {
	my $given_version = Test2::Tools::Spec->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Spec->VERSION . '
');

}
print("import: Test2::Tools::Subtest\n");
use Test2::Tools::Subtest;

if (defined Test2::Tools::Subtest->VERSION) {
	my $given_version = Test2::Tools::Subtest->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Subtest->VERSION . '
');

}
print("import: Test2::Tools::Target\n");
use Test2::Tools::Target;

if (defined Test2::Tools::Target->VERSION) {
	my $given_version = Test2::Tools::Target->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Target->VERSION . '
');

}
print("import: Test2::Tools::Tester\n");
use Test2::Tools::Tester;

if (defined Test2::Tools::Tester->VERSION) {
	my $given_version = Test2::Tools::Tester->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Tester->VERSION . '
');

}
print("import: Test2::Tools::Warnings\n");
use Test2::Tools::Warnings;

if (defined Test2::Tools::Warnings->VERSION) {
	my $given_version = Test2::Tools::Warnings->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Tools::Warnings->VERSION . '
');

}
print("import: Test2::Util::Grabber\n");
use Test2::Util::Grabber;

if (defined Test2::Util::Grabber->VERSION) {
	my $given_version = Test2::Util::Grabber->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Grabber->VERSION . '
');

}
print("import: Test2::Util::Ref\n");
use Test2::Util::Ref;

if (defined Test2::Util::Ref->VERSION) {
	my $given_version = Test2::Util::Ref->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Ref->VERSION . '
');

}
print("import: Test2::Util::Stash\n");
use Test2::Util::Stash;

if (defined Test2::Util::Stash->VERSION) {
	my $given_version = Test2::Util::Stash->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Stash->VERSION . '
');

}
print("import: Test2::Util::Sub\n");
use Test2::Util::Sub;

if (defined Test2::Util::Sub->VERSION) {
	my $given_version = Test2::Util::Sub->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Sub->VERSION . '
');

}
print("import: Test2::Util::Table\n");
use Test2::Util::Table;

if (defined Test2::Util::Table->VERSION) {
	my $given_version = Test2::Util::Table->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Table->VERSION . '
');

}
print("import: Test2::Util::Table::Cell\n");
use Test2::Util::Table::Cell;

if (defined Test2::Util::Table::Cell->VERSION) {
	my $given_version = Test2::Util::Table::Cell->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Table::Cell->VERSION . '
');

}
print("import: Test2::Util::Table::LineBreak\n");
use Test2::Util::Table::LineBreak;

if (defined Test2::Util::Table::LineBreak->VERSION) {
	my $given_version = Test2::Util::Table::LineBreak->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Table::LineBreak->VERSION . '
');

}
print("import: Test2::Util::Term\n");
use Test2::Util::Term;

if (defined Test2::Util::Term->VERSION) {
	my $given_version = Test2::Util::Term->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Term->VERSION . '
');

}
print("import: Test2::Util::Times\n");
use Test2::Util::Times;

if (defined Test2::Util::Times->VERSION) {
	my $given_version = Test2::Util::Times->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Util::Times->VERSION . '
');

}
print("import: Test2::V0\n");
use Test2::V0;

if (defined Test2::V0->VERSION) {
	my $given_version = Test2::V0->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::V0->VERSION . '
');

}
print("import: Test2::Workflow\n");
use Test2::Workflow;

if (defined Test2::Workflow->VERSION) {
	my $given_version = Test2::Workflow->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Workflow->VERSION . '
');

}
print("import: Test2::Workflow::BlockBase\n");
use Test2::Workflow::BlockBase;

if (defined Test2::Workflow::BlockBase->VERSION) {
	my $given_version = Test2::Workflow::BlockBase->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Workflow::BlockBase->VERSION . '
');

}
print("import: Test2::Workflow::Build\n");
use Test2::Workflow::Build;

if (defined Test2::Workflow::Build->VERSION) {
	my $given_version = Test2::Workflow::Build->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Workflow::Build->VERSION . '
');

}
print("import: Test2::Workflow::Runner\n");
use Test2::Workflow::Runner;

if (defined Test2::Workflow::Runner->VERSION) {
	my $given_version = Test2::Workflow::Runner->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Workflow::Runner->VERSION . '
');

}
print("import: Test2::Workflow::Task\n");
use Test2::Workflow::Task;

if (defined Test2::Workflow::Task->VERSION) {
	my $given_version = Test2::Workflow::Task->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Workflow::Task->VERSION . '
');

}
print("import: Test2::Workflow::Task::Action\n");
use Test2::Workflow::Task::Action;

if (defined Test2::Workflow::Task::Action->VERSION) {
	my $given_version = Test2::Workflow::Task::Action->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Workflow::Task::Action->VERSION . '
');

}
print("import: Test2::Workflow::Task::Group\n");
use Test2::Workflow::Task::Group;

if (defined Test2::Workflow::Task::Group->VERSION) {
	my $given_version = Test2::Workflow::Task::Group->VERSION;
	$given_version =~ s/0+$//;
	die('Expected version ' . $expected_version . ' but found ' . $given_version) unless ($expected_version eq $given_version);
	print('	using version ' . Test2::Workflow::Task::Group->VERSION . '
');

}
