Replace all new_test_film with new_test_film2.

37 files changed, 165 insertions, 567 deletions

diff --git a/test/4k_test.cc b/test/4k_test.cc
index 9e80a6e27..1186d7527 100644
--- a/test/4k_test.cc
+++ b/test/4k_test.cc
@@ -44,15 +44,11 @@ using std::make_shared;
 
 BOOST_AUTO_TEST_CASE (fourk_test)
 {
-	auto film = new_test_film ("4k_test");
-	LogSwitcher ls (film->log());
-	film->set_name ("4k_test");
 	auto c = make_shared<FFmpegContent>("test/data/test.mp4");
+	auto film = new_test_film2("4k_test", { c });
+	LogSwitcher ls (film->log());
 	film->set_resolution (Resolution::FOUR_K);
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
-	film->set_container (Ratio::from_id ("185"));
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("FTR"));
 
 	make_and_verify_dcp (
 		film,
diff --git a/test/audio_analysis_test.cc b/test/audio_analysis_test.cc
index 8ded9eda9..5e8bd0e2d 100644
--- a/test/audio_analysis_test.cc
+++ b/test/audio_analysis_test.cc
@@ -102,15 +102,8 @@ BOOST_AUTO_TEST_CASE (audio_analysis_serialisation_test)
 
 BOOST_AUTO_TEST_CASE (audio_analysis_test)
 {
-	auto film = new_test_film ("audio_analysis_test");
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("FTR"));
-	film->set_container (Ratio::from_id("185"));
-	film->set_name ("audio_analysis_test");
-	boost::filesystem::path p = TestPaths::private_data() / "betty_L.wav";
-
-	auto c = make_shared<FFmpegContent>(p);
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto c = make_shared<FFmpegContent>(TestPaths::private_data() / "betty_L.wav");
+	auto film = new_test_film2("audio_analysis_test", { c });
 
 	auto job = make_shared<AnalyseAudioJob>(film, film->playlist(), false);
 	JobManager::instance()->add (job);
@@ -121,12 +114,8 @@ BOOST_AUTO_TEST_CASE (audio_analysis_test)
 /** Check that audio analysis works (i.e. runs without error) with a -ve delay */
 BOOST_AUTO_TEST_CASE (audio_analysis_negative_delay_test)
 {
-	auto film = new_test_film ("audio_analysis_negative_delay_test");
-	film->set_name ("audio_analysis_negative_delay_test");
 	auto c = make_shared<FFmpegContent>(TestPaths::private_data() / "boon_telly.mkv");
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
-
+	auto film = new_test_film2("audio_analysis_negative_delay_test", { c });
 	c->audio->set_delay (-250);
 
 	auto job = make_shared<AnalyseAudioJob>(film, film->playlist(), false);
@@ -138,11 +127,8 @@ BOOST_AUTO_TEST_CASE (audio_analysis_negative_delay_test)
 /** Check audio analysis that is incorrect in 2e98263 */
 BOOST_AUTO_TEST_CASE (audio_analysis_test2)
 {
-	auto film = new_test_film ("audio_analysis_test2");
-	film->set_name ("audio_analysis_test2");
 	auto c = make_shared<FFmpegContent>(TestPaths::private_data() / "3d_thx_broadway_2010_lossless.m2ts");
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("audio_analysis_test2", { c });
 
 	auto job = make_shared<AnalyseAudioJob>(film, film->playlist(), false);
 	JobManager::instance()->add (job);
@@ -155,16 +141,10 @@ BOOST_AUTO_TEST_CASE (audio_analysis_test2)
  */
 BOOST_AUTO_TEST_CASE (audio_analysis_test3)
 {
-	auto film = new_test_film ("analyse_audio_test");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("TLR"));
-	film->set_name ("frobozz");
-
 	auto content = make_shared<FFmpegContent>("test/data/white.wav");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
-
+	auto film = new_test_film2("analyse_audio_test", { content });
 	film->set_audio_channels (12);
+
 	boost::signals2::connection connection;
 	bool done = false;
 	JobManager::instance()->analyse_audio(film, film->playlist(), false, connection, [&done](Job::Result) { done = true; });
@@ -176,13 +156,8 @@ BOOST_AUTO_TEST_CASE (audio_analysis_test3)
 /** Run an audio analysis that triggered an exception in the audio decoder at one point */
 BOOST_AUTO_TEST_CASE (analyse_audio_test4)
 {
-	auto film = new_test_film ("analyse_audio_test");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("TLR"));
-	film->set_name ("frobozz");
 	auto content = content_factory(TestPaths::private_data() / "20 The Wedding Convoy Song.m4a")[0];
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("analyse_audio_test", { content });
 
 	auto playlist = make_shared<Playlist>();
 	playlist->add (film, content);
diff --git a/test/audio_processor_test.cc b/test/audio_processor_test.cc
index 4fe5eeb10..15e71e1c4 100644
--- a/test/audio_processor_test.cc
+++ b/test/audio_processor_test.cc
@@ -41,11 +41,8 @@ using std::make_shared;
 /** Test the mid-side decoder for analysis and DCP-making */
 BOOST_AUTO_TEST_CASE (audio_processor_test)
 {
-	auto film = new_test_film ("audio_processor_test");
-	film->set_name ("audio_processor_test");
 	auto c = make_shared<FFmpegContent>("test/data/white.wav");
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("audio_processor_test", { c });
 
 	film->set_audio_channels(16);
 	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
diff --git a/test/burnt_subtitle_test.cc b/test/burnt_subtitle_test.cc
index e8ecc0048..089b2e9ec 100644
--- a/test/burnt_subtitle_test.cc
+++ b/test/burnt_subtitle_test.cc
@@ -58,15 +58,11 @@ using namespace dcpomatic;
 /** Build a small DCP with no picture and a single subtitle overlaid onto it from a SubRip file */
 BOOST_AUTO_TEST_CASE (burnt_subtitle_test_subrip)
 {
-	auto film = new_test_film ("burnt_subtitle_test_subrip");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
 	auto content = content_factory("test/data/subrip2.srt")[0];
+	auto film = new_test_film2("burnt_subtitle_test_subrip", { content });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
 	content->text[0]->set_use(true);
 	content->text[0]->set_burn(true);
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
 	make_and_verify_dcp(
 		film,
 		{ dcp::VerificationNote::Code::MISSING_CPL_METADATA }
@@ -82,14 +78,11 @@ BOOST_AUTO_TEST_CASE (burnt_subtitle_test_subrip)
 /** Build a small DCP with no picture and a single subtitle overlaid onto it from a DCP XML file */
 BOOST_AUTO_TEST_CASE (burnt_subtitle_test_dcp)
 {
-	auto film = new_test_film ("burnt_subtitle_test_dcp");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
 	auto content = content_factory("test/data/dcp_sub.xml")[0];
+	auto film = new_test_film2("burnt_subtitle_test_dcp", { content });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	film->set_name("frobozz");
 	content->text[0]->set_use(true);
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
 	make_and_verify_dcp(
 		film,
 		{
@@ -104,26 +97,18 @@ BOOST_AUTO_TEST_CASE (burnt_subtitle_test_dcp)
 /** Burn some subtitles into an existing DCP to check the colour conversion */
 BOOST_AUTO_TEST_CASE (burnt_subtitle_test_onto_dcp)
 {
-	auto film = new_test_film ("burnt_subtitle_test_onto_dcp");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
-	film->examine_and_add_content(content_factory("test/data/flat_black.png")[0]);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("burnt_subtitle_test_onto_dcp", { content_factory("test/data/flat_black.png")[0] });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
 	make_and_verify_dcp (film);
 
 	Config::instance()->set_log_types (Config::instance()->log_types() | LogEntry::TYPE_DEBUG_ENCODE);
-	auto film2 = new_test_film ("burnt_subtitle_test_onto_dcp2");
-	film2->set_container (Ratio::from_id ("185"));
-	film2->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film2->set_name ("frobozz");
 	auto background_dcp = make_shared<DCPContent>(film->dir(film->dcp_name()));
-	film2->examine_and_add_content (background_dcp);
 	auto sub = content_factory("test/data/subrip2.srt")[0];
+	auto film2 = new_test_film2("burnt_subtitle_test_onto_dcp2", { background_dcp, sub });
+	film2->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	film2->set_name("frobozz");
 	sub->text[0]->set_burn(true);
 	sub->text[0]->set_effect(dcp::Effect::BORDER);
-	film2->examine_and_add_content (sub);
-	BOOST_REQUIRE (!wait_for_jobs());
 	make_and_verify_dcp (film2);
 
 	BOOST_CHECK (background_dcp->position() == DCPTime());
diff --git a/test/butler_test.cc b/test/butler_test.cc
index 1c59de798..b0d4590da 100644
--- a/test/butler_test.cc
+++ b/test/butler_test.cc
@@ -40,17 +40,9 @@ using namespace dcpomatic;
 
 BOOST_AUTO_TEST_CASE (butler_test1)
 {
-	auto film = new_test_film ("butler_test1");
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("FTR"));
-	film->set_name ("butler_test1");
-	film->set_container (Ratio::from_id ("185"));
-
 	auto video = content_factory("test/data/flat_red.png")[0];
-	film->examine_and_add_content (video);
 	auto audio = content_factory("test/data/staircase.wav")[0];
-	film->examine_and_add_content (audio);
-	BOOST_REQUIRE (!wait_for_jobs ());
-
+	auto film = new_test_film2("butler_test1", { video, audio });
 	film->set_audio_channels (6);
 
 	/* This is the map of the player output (5.1) to the butler output (also 5.1) */
diff --git a/test/dcp_playback_test.cc b/test/dcp_playback_test.cc
index a5b69e181..30a9e6c46 100644
--- a/test/dcp_playback_test.cc
+++ b/test/dcp_playback_test.cc
@@ -38,10 +38,8 @@ using namespace dcpomatic;
 /** Simulate the work that the player does, for profiling */
 BOOST_AUTO_TEST_CASE (dcp_playback_test)
 {
-	auto film = new_test_film ("dcp_playback_test");
 	auto content = make_shared<DCPContent>(TestPaths::private_data() / "JourneyToJah_TLR-1_F_EN-DE-FR_CH_51_2K_LOK_20140225_DGL_SMPTE_OV");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("dcp_playback_test", { content });
 
 	Player player(film, Image::Alignment::PADDED);
 
diff --git a/test/dcp_subtitle_test.cc b/test/dcp_subtitle_test.cc
index e62bd70ba..cd4c53ea5 100644
--- a/test/dcp_subtitle_test.cc
+++ b/test/dcp_subtitle_test.cc
@@ -75,14 +75,10 @@ store (ContentStringText sub)
 /** Test pass-through of a very simple DCP subtitle file */
 BOOST_AUTO_TEST_CASE (dcp_subtitle_test)
 {
-	auto film = new_test_film ("dcp_subtitle_test");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
-	film->set_interop (false);
 	auto content = make_shared<DCPSubtitleContent>("test/data/dcp_sub.xml");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs ());
+	auto film = new_test_film2("dcp_subtitle_test", { content });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	film->set_name("frobozz");
 
 	BOOST_CHECK_EQUAL (content->full_length(film).get(), DCPTime::from_seconds(2).get());
 
@@ -107,13 +103,8 @@ BOOST_AUTO_TEST_CASE (dcp_subtitle_test)
 /** Test parsing of a subtitle within an existing DCP */
 BOOST_AUTO_TEST_CASE (dcp_subtitle_within_dcp_test)
 {
-	auto film = new_test_film ("dcp_subtitle_within_dcp_test");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
 	auto content = make_shared<DCPContent>(TestPaths::private_data() / "JourneyToJah_TLR-1_F_EN-DE-FR_CH_51_2K_LOK_20140225_DGL_SMPTE_OV");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs ());
+	auto film = new_test_film2("dcp_subtitle_within_dcp_test", { content });
 
 	auto decoder = make_shared<DCPDecoder>(film, content, false, false, shared_ptr<DCPDecoder>());
 	decoder->only_text()->PlainStart.connect (bind (store, _1));
@@ -130,13 +121,8 @@ BOOST_AUTO_TEST_CASE (dcp_subtitle_within_dcp_test)
 /** Test subtitles whose text includes things like &lt;b&gt; */
 BOOST_AUTO_TEST_CASE (dcp_subtitle_test2)
 {
-	auto film = new_test_film ("dcp_subtitle_test2");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
 	auto content = make_shared<DCPSubtitleContent>("test/data/dcp_sub2.xml");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs ());
+	auto film = new_test_film2("dcp_subtitle_test2", { content });
 
 	auto decoder = make_shared<DCPSubtitleDecoder>(film, content);
 	decoder->only_text()->PlainStart.connect (bind (store, _1));
@@ -154,15 +140,10 @@ BOOST_AUTO_TEST_CASE (dcp_subtitle_test2)
 /** Test a failure case */
 BOOST_AUTO_TEST_CASE (dcp_subtitle_test3)
 {
-	auto film = new_test_film ("dcp_subtitle_test3");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
-	film->set_interop (true);
 	auto content = make_shared<DCPSubtitleContent>("test/data/dcp_sub3.xml");
-	film->examine_and_add_content (content);
+	auto film = new_test_film2("dcp_subtitle_test3", { content });
+	film->set_interop (true);
 	content->only_text()->set_language(dcp::LanguageTag("de"));
-	BOOST_REQUIRE (!wait_for_jobs ());
 
 	make_and_verify_dcp (film, { dcp::VerificationNote::Code::INVALID_STANDARD });
 
diff --git a/test/digest_test.cc b/test/digest_test.cc
index 2d49768f7..2ad6aefd1 100644
--- a/test/digest_test.cc
+++ b/test/digest_test.cc
@@ -65,17 +65,11 @@ openssl_hash (boost::filesystem::path file)
 /** Test the digests made by the DCP writing code on a multi-reel DCP */
 BOOST_AUTO_TEST_CASE (digest_test)
 {
-	auto film = new_test_film ("digest_test");
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
-	film->set_name ("digest_test");
 	auto r = make_shared<ImageContent>("test/data/flat_red.png");
 	auto g = make_shared<ImageContent>("test/data/flat_green.png");
 	auto b = make_shared<ImageContent>("test/data/flat_blue.png");
-	film->examine_and_add_content (r);
-	film->examine_and_add_content (g);
-	film->examine_and_add_content (b);
+	auto film = new_test_film2("digest_test", { r, g, b });
 	film->set_reel_type (ReelType::BY_VIDEO_CONTENT);
-	BOOST_REQUIRE (!wait_for_jobs());
 
 	BOOST_CHECK (Config::instance()->master_encoding_threads() > 1);
 	make_and_verify_dcp (film);
diff --git a/test/ffmpeg_audio_only_test.cc b/test/ffmpeg_audio_only_test.cc
index ea9a9c4e5..2c8f3f54c 100644
--- a/test/ffmpeg_audio_only_test.cc
+++ b/test/ffmpeg_audio_only_test.cc
@@ -78,12 +78,8 @@ audio (std::shared_ptr<AudioBuffers> audio, int channels)
 static shared_ptr<Film>
 test (boost::filesystem::path file)
 {
-	auto film = new_test_film ("ffmpeg_audio_only_test");
-	film->set_name ("test_film");
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
 	auto c = make_shared<FFmpegContent>(file);
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("ffmpeg_audio_only_test", { c });
 	film->write_metadata ();
 
 	/* See if can make a DCP without any errors */
diff --git a/test/ffmpeg_audio_test.cc b/test/ffmpeg_audio_test.cc
index b2a83aad8..09331c5af 100644
--- a/test/ffmpeg_audio_test.cc
+++ b/test/ffmpeg_audio_test.cc
@@ -51,12 +51,8 @@ using std::string;
 
 BOOST_AUTO_TEST_CASE (ffmpeg_audio_test)
 {
-	auto film = new_test_film ("ffmpeg_audio_test");
-	film->set_name ("ffmpeg_audio_test");
 	auto c = make_shared<FFmpegContent> ("test/data/staircase.mov");
-	film->examine_and_add_content (c);
-
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("ffmpeg_audio_test", { c });
 
 	int constexpr audio_channels = 6;
 
diff --git a/test/ffmpeg_dcp_test.cc b/test/ffmpeg_dcp_test.cc
index c332759c8..d7c372416 100644
--- a/test/ffmpeg_dcp_test.cc
+++ b/test/ffmpeg_dcp_test.cc
@@ -43,18 +43,10 @@ using std::make_shared;
 
 BOOST_AUTO_TEST_CASE (ffmpeg_dcp_test)
 {
-	auto film = new_test_film ("ffmpeg_dcp_test");
-	film->set_name ("test_film2");
 	auto c = make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (c);
-
-	BOOST_REQUIRE (!wait_for_jobs());
-
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
+	auto film = new_test_film2("ffmpeg_dcp_test", { c });
+	film->set_name("test_film2");
 	make_and_verify_dcp (film);
-
-	BOOST_REQUIRE (!wait_for_jobs());
 }
 
 
diff --git a/test/ffmpeg_decoder_seek_test.cc b/test/ffmpeg_decoder_seek_test.cc
index f38ef3564..6fb4cc876 100644
--- a/test/ffmpeg_decoder_seek_test.cc
+++ b/test/ffmpeg_decoder_seek_test.cc
@@ -80,10 +80,8 @@ test (boost::filesystem::path file, vector<ContentTime> times)
 	auto path = TestPaths::private_data() / file;
 	BOOST_REQUIRE (boost::filesystem::exists (path));
 
-	auto film = new_test_film ("ffmpeg_decoder_seek_test_" + file.string());
 	auto content = make_shared<FFmpegContent>(path);
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("ffmpeg_decoder_seek_test_" + file.string(), { content });
 	auto decoder = make_shared<FFmpegDecoder>(film, content, false);
 	decoder->video->Data.connect (bind (&store, _1));
 
diff --git a/test/ffmpeg_decoder_sequential_test.cc b/test/ffmpeg_decoder_sequential_test.cc
index 73eea719f..8bcafd275 100644
--- a/test/ffmpeg_decoder_sequential_test.cc
+++ b/test/ffmpeg_decoder_sequential_test.cc
@@ -70,11 +70,8 @@ ffmpeg_decoder_sequential_test_one (boost::filesystem::path file, float fps, int
 	auto path = TestPaths::private_data() / file;
 	BOOST_REQUIRE (boost::filesystem::exists (path));
 
-	auto film = new_test_film ("ffmpeg_decoder_sequential_test_" + file.string());
 	auto content = make_shared<FFmpegContent>(path);
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
-	film->write_metadata ();
+	auto film = new_test_film2("ffmpeg_decoder_sequential_test_" + file.string(), { content });
 	auto player = make_shared<Player>(film, Image::Alignment::COMPACT);
 
 	BOOST_REQUIRE (content->video_frame_rate());
diff --git a/test/ffmpeg_encoder_test.cc b/test/ffmpeg_encoder_test.cc
index 3690bc3fc..64ce8e96b 100644
--- a/test/ffmpeg_encoder_test.cc
+++ b/test/ffmpeg_encoder_test.cc
@@ -126,15 +126,10 @@ BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test5)
 	Cleanup cl;
 	cl.add(output);
 
-	auto film = new_test_film ("ffmpeg_encoder_prores_test5");
-	film->set_name ("ffmpeg_encoder_prores_test5");
 	auto c = make_shared<ImageContent>(TestPaths::private_data() / "bbc405.png");
-	film->set_container (Ratio::from_id ("185"));
+	auto film = new_test_film2("ffmpeg_encoder_prores_test5", { c });
 	film->set_audio_channels (6);
 
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs ());
-
 	c->video->set_length (240);
 
 	film->write_metadata ();
@@ -149,14 +144,10 @@ BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test5)
 /** Subs -> Prores */
 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test6)
 {
-	auto film = new_test_film ("ffmpeg_encoder_prores_test6");
-	film->set_name ("ffmpeg_encoder_prores_test6");
-	film->set_container (Ratio::from_id ("185"));
+	auto s = make_shared<StringTextFileContent>("test/data/subrip2.srt");
+	auto film = new_test_film2("ffmpeg_encoder_prores_test6", { s });
 	film->set_audio_channels (6);
 
-	auto s = make_shared<StringTextFileContent>("test/data/subrip2.srt");
-	film->examine_and_add_content (s);
-	BOOST_REQUIRE (!wait_for_jobs ());
 	s->only_text()->set_colour (dcp::Colour (255, 255, 0));
 	s->only_text()->set_effect (dcp::Effect::SHADOW);
 	s->only_text()->set_effect_colour (dcp::Colour (0, 255, 255));
@@ -175,18 +166,11 @@ BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test7)
 	Cleanup cl;
 	cl.add(output);
 
-	auto film = new_test_film ("ffmpeg_encoder_prores_test7");
-	film->set_name ("ffmpeg_encoder_prores_test7");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_audio_channels (6);
-
 	auto c = make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs ());
-
 	auto s = make_shared<StringTextFileContent>("test/data/subrip.srt");
-	film->examine_and_add_content (s);
-	BOOST_REQUIRE (!wait_for_jobs ());
+	auto film = new_test_film2("ffmpeg_encoder_prores_test7", { c, s });
+	film->set_audio_channels (6);
+
 	s->only_text()->set_colour (dcp::Colour (255, 255, 0));
 	s->only_text()->set_effect (dcp::Effect::SHADOW);
 	s->only_text()->set_effect_colour (dcp::Colour (0, 255, 255));
@@ -209,14 +193,10 @@ BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test1)
 /** Just subtitles -> H264 */
 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test2)
 {
-	auto film = new_test_film ("ffmpeg_encoder_h264_test2");
-	film->set_name ("ffmpeg_encoder_h264_test2");
-	film->set_container (Ratio::from_id ("185"));
+	auto s = make_shared<StringTextFileContent>("test/data/subrip2.srt");
+	auto film = new_test_film2("ffmpeg_encoder_h264_test2", { s });
 	film->set_audio_channels (6);
 
-	auto s = make_shared<StringTextFileContent>("test/data/subrip2.srt");
-	film->examine_and_add_content (s);
-	BOOST_REQUIRE (!wait_for_jobs ());
 	s->only_text()->set_colour (dcp::Colour (255, 255, 0));
 	s->only_text()->set_effect (dcp::Effect::SHADOW);
 	s->only_text()->set_effect_colour (dcp::Colour (0, 255, 255));
@@ -231,18 +211,11 @@ BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test2)
 /** Video + subs -> H264 */
 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test3)
 {
-	auto film = new_test_film ("ffmpeg_encoder_h264_test3");
-	film->set_name ("ffmpeg_encoder_h264_test3");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_audio_channels (6);
-
 	auto c = make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
-
 	auto s = make_shared<StringTextFileContent>("test/data/subrip.srt");
-	film->examine_and_add_content (s);
-	BOOST_REQUIRE (!wait_for_jobs ());
+	auto film = new_test_film2("ffmpeg_encoder_h264_test3", { c, s });
+	film->set_audio_channels (6);
+
 	s->only_text()->set_colour (dcp::Colour (255, 255, 0));
 	s->only_text()->set_effect (dcp::Effect::SHADOW);
 	s->only_text()->set_effect_colour (dcp::Colour (0, 255, 255));
@@ -271,24 +244,15 @@ BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test4)
 /** Test mixdown from 5.1 to stereo */
 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test5)
 {
-	auto film = new_test_film("ffmpeg_encoder_h264_test5");
-	film->set_name("ffmpeg_encoder_h264_test5");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_audio_channels (6);
-
 	auto L = make_shared<FFmpegContent>("test/data/L.wav");
-	film->examine_and_add_content (L);
 	auto R = make_shared<FFmpegContent>("test/data/R.wav");
-	film->examine_and_add_content (R);
 	auto C = make_shared<FFmpegContent>("test/data/C.wav");
-	film->examine_and_add_content (C);
 	auto Ls = make_shared<FFmpegContent>("test/data/Ls.wav");
-	film->examine_and_add_content (Ls);
 	auto Rs = make_shared<FFmpegContent>("test/data/Rs.wav");
-	film->examine_and_add_content (Rs);
 	auto Lfe = make_shared<FFmpegContent>("test/data/Lfe.wav");
-	film->examine_and_add_content (Lfe);
-	BOOST_REQUIRE (!wait_for_jobs ());
+
+	auto film = new_test_film2("ffmpeg_encoder_h264_test5", { L, R, C, Ls, Rs, Lfe });
+	film->set_audio_channels (6);
 
 	AudioMapping map (1, MAX_DCP_AUDIO_CHANNELS);
 
diff --git a/test/ffmpeg_examiner_test.cc b/test/ffmpeg_examiner_test.cc
index 231bd16e0..9435e4637 100644
--- a/test/ffmpeg_examiner_test.cc
+++ b/test/ffmpeg_examiner_test.cc
@@ -41,8 +41,8 @@ using namespace dcpomatic;
  */
 BOOST_AUTO_TEST_CASE (ffmpeg_examiner_test)
 {
-	auto film = new_test_film ("ffmpeg_examiner_test");
 	auto content = make_shared<FFmpegContent>("test/data/count300bd24.m2ts");
+	auto film = new_test_film2("ffmpeg_examiner_test", { content });
 	auto examiner = make_shared<FFmpegExaminer>(content);
 
 	BOOST_CHECK_EQUAL (examiner->first_video().get().get(), ContentTime::from_seconds(600).get());
diff --git a/test/ffmpeg_pts_offset_test.cc b/test/ffmpeg_pts_offset_test.cc
index 1f994374d..da9089a2e 100644
--- a/test/ffmpeg_pts_offset_test.cc
+++ b/test/ffmpeg_pts_offset_test.cc
@@ -41,10 +41,8 @@ using namespace dcpomatic;
 
 BOOST_AUTO_TEST_CASE (ffmpeg_pts_offset_test)
 {
-	auto film = new_test_film ("ffmpeg_pts_offset_test");
 	auto content = make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("ffmpeg_pts_offset_test", { content });
 
 	content->audio = make_shared<AudioContent>(content.get());
 	content->audio->add_stream (shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream));
diff --git a/test/file_naming_test.cc b/test/file_naming_test.cc
index 1b5871bd2..2a0a48172 100644
--- a/test/file_naming_test.cc
+++ b/test/file_naming_test.cc
@@ -61,17 +61,11 @@ BOOST_AUTO_TEST_CASE (file_naming_test)
 	ConfigRestorer cr;
 	Config::instance()->set_dcp_asset_filename_format (dcp::NameFormat("%c"));
 
-	auto film = new_test_film ("file_naming_test");
-	film->set_name ("file_naming_test");
-	film->set_video_frame_rate (24);
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
 	auto r = make_shared<FFmpegContent>("test/data/flat_red.png");
-	film->examine_and_add_content (r);
 	auto g = make_shared<FFmpegContent>("test/data/flat_green.png");
-	film->examine_and_add_content (g);
 	auto b = make_shared<FFmpegContent>("test/data/flat_blue.png");
-	film->examine_and_add_content (b);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("file_naming_test", { r, g, b });
+	film->set_video_frame_rate (24);
 
 	r->set_position (film, dcpomatic::DCPTime::from_seconds(0));
 	r->set_video_frame_rate(film, 24);
@@ -115,10 +109,6 @@ BOOST_AUTO_TEST_CASE (file_naming_test2)
 
 	Config::instance()->set_dcp_asset_filename_format (dcp::NameFormat ("%c"));
 
-	auto film = new_test_film ("file_naming_test2");
-	film->set_name ("file_naming_test2");
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
-
 #ifdef DCPOMATIC_WINDOWS
 	/* This is necessary so that the UTF8 string constant below gets converted properly */
 	std::locale::global(boost::locale::generator().generate(""));
@@ -126,12 +116,9 @@ BOOST_AUTO_TEST_CASE (file_naming_test2)
 #endif
 
 	auto r = make_shared<FFmpegContent>("test/data/flät_red.png");
-	film->examine_and_add_content (r);
 	auto g = make_shared<FFmpegContent>("test/data/flat_green.png");
-	film->examine_and_add_content (g);
 	auto b = make_shared<FFmpegContent>("test/data/flat_blue.png");
-	film->examine_and_add_content (b);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("file_naming_test2", { r, g, b });
 
 	r->set_position (film, dcpomatic::DCPTime::from_seconds(0));
 	r->set_video_frame_rate(film, 24);
diff --git a/test/film_metadata_test.cc b/test/film_metadata_test.cc
index 0a522fbee..e441ec9e0 100644
--- a/test/film_metadata_test.cc
+++ b/test/film_metadata_test.cc
@@ -47,12 +47,12 @@ using std::vector;
 
 BOOST_AUTO_TEST_CASE (film_metadata_test)
 {
-	auto film = new_test_film ("film_metadata_test");
+	auto film = new_test_film2("film_metadata_test");
 	auto dir = test_film_dir ("film_metadata_test");
 
 	film->_isdcf_date = boost::gregorian::from_undelimited_string ("20130211");
 	BOOST_CHECK (film->container() == Ratio::from_id ("185"));
-	BOOST_CHECK (film->dcp_content_type() == nullptr);
+	BOOST_CHECK (film->dcp_content_type() == DCPContentType::from_isdcf_name("TST"));
 
 	film->set_name ("fred");
 	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("SHR"));
diff --git a/test/frame_rate_test.cc b/test/frame_rate_test.cc
index d54868b3f..9b903fef5 100644
--- a/test/frame_rate_test.cc
+++ b/test/frame_rate_test.cc
@@ -44,11 +44,8 @@
 */
 BOOST_AUTO_TEST_CASE (best_dcp_frame_rate_test_single)
 {
-	auto film = new_test_film("best_dcp_frame_rate_test_single");
-	/* Get any piece of content, it doesn't matter what */
 	auto content = std::make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("best_dcp_frame_rate_test_single", { content });
 
 	/* Run some tests with a limited range of allowed rates */
 
@@ -222,20 +219,13 @@ BOOST_AUTO_TEST_CASE (best_dcp_frame_rate_test_single)
 */
 BOOST_AUTO_TEST_CASE (best_dcp_frame_rate_test_double)
 {
-	auto film = new_test_film("best_dcp_frame_rate_test_double");
-	/* Get any old content, it doesn't matter what */
 	auto A = std::make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (A);
 	auto B = std::make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (B);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("best_dcp_frame_rate_test_double", { A, B });
 
 	/* Run some tests with a limited range of allowed rates */
 
-	std::list<int> afr;
-	afr.push_back (24);
-	afr.push_back (25);
-	afr.push_back (30);
+	std::list<int> afr = { 24, 25, 30 };
 	Config::instance()->set_allowed_dcp_frame_rates (afr);
 
 	A->_video_frame_rate = 30;
@@ -253,16 +243,10 @@ BOOST_AUTO_TEST_CASE (best_dcp_frame_rate_test_double)
 
 BOOST_AUTO_TEST_CASE (audio_sampling_rate_test)
 {
-	auto film = new_test_film("audio_sampling_rate_test");
-	/* Get any piece of content, it doesn't matter what */
 	auto content = std::make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("audio_sampling_rate_test", { content });
 
-	std::list<int> afr;
-	afr.push_back (24);
-	afr.push_back (25);
-	afr.push_back (30);
+	std::list<int> afr = { 24, 25, 30 };
 	Config::instance()->set_allowed_dcp_frame_rates (afr);
 
 	auto stream = std::make_shared<FFmpegAudioStream>("foo", 0, 0, 0, 0, 0);
diff --git a/test/import_dcp_test.cc b/test/import_dcp_test.cc
index 7387c7be7..5ced3f9a4 100644
--- a/test/import_dcp_test.cc
+++ b/test/import_dcp_test.cc
@@ -56,17 +56,10 @@ BOOST_AUTO_TEST_CASE (import_dcp_test)
 {
 	ConfigRestorer cr;
 
-	auto A = new_test_film ("import_dcp_test");
-	A->set_container (Ratio::from_id ("185"));
-	A->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	A->set_name ("frobozz");
-	A->set_interop (false);
-
 	auto c = make_shared<FFmpegContent>("test/data/test.mp4");
-	A->examine_and_add_content (c);
+	auto A = new_test_film2("import_dcp_test", { c });
 	A->set_encrypted (true);
-	BOOST_CHECK (!wait_for_jobs ());
-
+	A->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
 	make_and_verify_dcp (A);
 
 	dcp::DCP A_dcp ("build/test/import_dcp_test/" + A->dcp_name());
@@ -80,20 +73,11 @@ BOOST_AUTO_TEST_CASE (import_dcp_test)
 	auto const decrypted_kdm = A->make_kdm(A_dcp.cpls().front()->file().get(), dcp::LocalTime ("2030-07-21T00:00:00+00:00"), dcp::LocalTime ("2031-07-21T00:00:00+00:00"));
 	auto const kdm = decrypted_kdm.encrypt(signer, Config::instance()->decryption_chain()->leaf(), {}, dcp::Formulation::MODIFIED_TRANSITIONAL_1, true, 0);
 
-	auto B = new_test_film ("import_dcp_test2");
-	B->set_container (Ratio::from_id ("185"));
-	B->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	B->set_name ("frobozz");
-	B->set_interop (false);
-	B->set_audio_channels(16);
-
 	auto d = make_shared<DCPContent>("build/test/import_dcp_test/" + A->dcp_name());
-	B->examine_and_add_content (d);
-	BOOST_CHECK (!wait_for_jobs ());
 	d->add_kdm (kdm);
-	JobManager::instance()->add (make_shared<ExamineContentJob>(B, d));
-	BOOST_CHECK (!wait_for_jobs ());
-
+	auto B = new_test_film2("import_dcp_test2", { d });
+	B->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	B->set_audio_channels(16);
 	make_and_verify_dcp (B);
 
 	/* Should be 1s red, 1s green, 1s blue */
diff --git a/test/interrupt_encoder_test.cc b/test/interrupt_encoder_test.cc
index f0755d3a0..2da9d91ab 100644
--- a/test/interrupt_encoder_test.cc
+++ b/test/interrupt_encoder_test.cc
@@ -45,14 +45,8 @@ using std::make_shared;
  */
 BOOST_AUTO_TEST_CASE (interrupt_encoder_test)
 {
-	auto film = new_test_film ("interrupt_encoder_test");
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("FTR"));
-	film->set_container (Ratio::from_id("185"));
-	film->set_name ("interrupt_encoder_test");
-
 	auto content = make_shared<FFmpegContent>(TestPaths::private_data() / "prophet_long_clip.mkv");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("interrupt_encoder_test", { content });
 
 	make_dcp (film, TranscodeJob::ChangedBehaviour::IGNORE);
 
diff --git a/test/isdcf_name_test.cc b/test/isdcf_name_test.cc
index 56686d2ac..6384ab8a4 100644
--- a/test/isdcf_name_test.cc
+++ b/test/isdcf_name_test.cc
@@ -46,7 +46,8 @@ using std::string;
 
 BOOST_AUTO_TEST_CASE (isdcf_name_test)
 {
-	auto film = new_test_film ("isdcf_name_test");
+	auto audio = content_factory("test/data/sine_440.wav")[0];
+	auto film = new_test_film2("isdcf_name_test", { audio });
 
 	/* A basic test */
 
@@ -54,9 +55,6 @@ BOOST_AUTO_TEST_CASE (isdcf_name_test)
 	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
 	film->set_container (Ratio::from_id ("185"));
 	film->_isdcf_date = boost::gregorian::date (2014, boost::gregorian::Jul, 4);
-	auto audio = content_factory("test/data/sine_440.wav")[0];
-	film->examine_and_add_content (audio);
-	BOOST_REQUIRE (!wait_for_jobs());
 	film->set_audio_language(dcp::LanguageTag("en-US"));
 	film->set_content_versions({"1"});
 	film->set_release_territory(dcp::LanguageTag::RegionSubtag("GB"));
@@ -103,7 +101,7 @@ BOOST_AUTO_TEST_CASE (isdcf_name_test)
 
 	/* Test interior aspect ratio: shouldn't be shown with trailers */
 
-	shared_ptr<ImageContent> content (new ImageContent ("test/data/simple_testcard_640x480.png"));
+	auto content = std::make_shared<ImageContent>("test/data/simple_testcard_640x480.png");
 	film->examine_and_add_content (content);
 	BOOST_REQUIRE (!wait_for_jobs());
 	content->video->set_custom_ratio (1.33);
diff --git a/test/optimise_stills_test.cc b/test/optimise_stills_test.cc
index 50514041b..5bf94c0a5 100644
--- a/test/optimise_stills_test.cc
+++ b/test/optimise_stills_test.cc
@@ -74,14 +74,9 @@ check (string name, int check_full, int check_repeat)
 /** Make a 2D DCP out of a 2D still and check that the J2K encoding is only done once for each frame */
 BOOST_AUTO_TEST_CASE (optimise_stills_test1)
 {
-	auto film = new_test_film ("optimise_stills_test1");
-	LogSwitcher ls (film->log());
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
 	auto content = content_factory("test/data/flat_red.png")[0];
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs ());
+	auto film = new_test_film2("optimise_stills_test1", { content });
+	LogSwitcher ls (film->log());
 	make_and_verify_dcp (film);
 
 	check ("optimise_stills_test1", 1, 10 * 24 - 1);
@@ -91,14 +86,9 @@ BOOST_AUTO_TEST_CASE (optimise_stills_test1)
 /** Make a 3D DCP out of a 3D L/R still and check that the J2K encoding is only done once for L and R */
 BOOST_AUTO_TEST_CASE (optimise_stills_test2)
 {
-	auto film = new_test_film ("optimise_stills_test2");
-	LogSwitcher ls (film->log());
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("TLR"));
-	film->set_name ("frobozz");
 	auto content = content_factory("test/data/flat_red.png")[0];
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs ());
+	auto film = new_test_film2("optimise_stills_test2", { content });
+	LogSwitcher ls (film->log());
 	content->video->set_frame_type (VideoFrameType::THREE_D_LEFT_RIGHT);
 	film->set_three_d (true);
 	make_and_verify_dcp (film);
diff --git a/test/player_test.cc b/test/player_test.cc
index c91458129..f86b13a94 100644
--- a/test/player_test.cc
+++ b/test/player_test.cc
@@ -78,15 +78,10 @@ accumulate (shared_ptr<AudioBuffers> audio, DCPTime)
 /** Check that the Player correctly generates silence when used with a silent FFmpegContent */
 BOOST_AUTO_TEST_CASE (player_silence_padding_test)
 {
-	auto film = new_test_film ("player_silence_padding_test");
-	film->set_name ("player_silence_padding_test");
 	auto c = std::make_shared<FFmpegContent>("test/data/test.mp4");
-	film->set_container (Ratio::from_id ("185"));
+	auto film = new_test_film2("player_silence_padding_test", { c });
 	film->set_audio_channels (6);
 
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
-
 	accumulated = std::make_shared<AudioBuffers>(film->audio_channels(), 0);
 
 	Player player(film, Image::Alignment::COMPACT);
@@ -106,18 +101,11 @@ BOOST_AUTO_TEST_CASE (player_silence_padding_test)
 /* Test insertion of black frames between separate bits of video content */
 BOOST_AUTO_TEST_CASE (player_black_fill_test)
 {
-	auto film = new_test_film ("black_fill_test");
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
-	film->set_name ("black_fill_test");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_sequence (false);
-	film->set_interop (false);
 	auto contentA = std::make_shared<ImageContent>("test/data/simple_testcard_640x480.png");
 	auto contentB = std::make_shared<ImageContent>("test/data/simple_testcard_640x480.png");
-
-	film->examine_and_add_content (contentA);
-	film->examine_and_add_content (contentB);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("black_fill_test", { contentA, contentB });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("FTR"));
+	film->set_sequence (false);
 
 	contentA->video->set_length (3);
 	contentA->set_position (film, DCPTime::from_frames(2, film->video_frame_rate()));
@@ -155,16 +143,9 @@ BOOST_AUTO_TEST_CASE (player_black_fill_test)
 /** Check behaviour with an awkward playlist whose data does not end on a video frame start */
 BOOST_AUTO_TEST_CASE (player_subframe_test)
 {
-	auto film = new_test_film ("reels_test7");
-	film->set_name ("reels_test7");
-	film->set_container (Ratio::from_id("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("TST"));
 	auto A = content_factory("test/data/flat_red.png")[0];
-	film->examine_and_add_content (A);
-	BOOST_REQUIRE (!wait_for_jobs());
 	auto B = content_factory("test/data/awkward_length.wav")[0];
-	film->examine_and_add_content (B);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("reels_test7", { A, B });
 	film->set_video_frame_rate (24);
 	A->video->set_length (3 * 24);
 
@@ -202,18 +183,10 @@ audio (shared_ptr<AudioBuffers> audio, DCPTime)
 /** Check with a video-only file that the video and audio emissions happen more-or-less together */
 BOOST_AUTO_TEST_CASE (player_interleave_test)
 {
-	auto film = new_test_film ("ffmpeg_transcoder_basic_test_subs");
-	film->set_name ("ffmpeg_transcoder_basic_test");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_audio_channels (6);
-
 	auto c = std::make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs ());
-
 	auto s = std::make_shared<StringTextFileContent>("test/data/subrip.srt");
-	film->examine_and_add_content (s);
-	BOOST_REQUIRE (!wait_for_jobs ());
+	auto film = new_test_film2("ffmpeg_transcoder_basic_test_subs", { c, s });
+	film->set_audio_channels (6);
 
 	Player player(film, Image::Alignment::COMPACT);
 	player.Video.connect(bind(&video, _1, _2));
diff --git a/test/recover_test.cc b/test/recover_test.cc
index 30090b4a3..25b37190e 100644
--- a/test/recover_test.cc
+++ b/test/recover_test.cc
@@ -58,16 +58,9 @@ note (dcp::NoteType t, string n)
 
 BOOST_AUTO_TEST_CASE (recover_test_2d)
 {
-	auto film = new_test_film("recover_test_2d");
-	film->set_interop (false);
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
-	film->set_container (Ratio::from_id ("185"));
-	film->set_name ("recover_test");
-	film->set_video_bit_rate(VideoEncoding::JPEG2000, 100000000);
-
 	auto content = make_shared<FFmpegContent>("test/data/count300bd24.m2ts");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("recover_test_2d", { content });
+	film->set_video_bit_rate(VideoEncoding::JPEG2000, 100000000);
 
 	make_and_verify_dcp (
 		film,
@@ -108,18 +101,11 @@ BOOST_AUTO_TEST_CASE (recover_test_2d)
 
 BOOST_AUTO_TEST_CASE (recover_test_3d, * boost::unit_test::depends_on("recover_test_2d"))
 {
-	auto film = new_test_film ("recover_test_3d");
-	film->set_interop (false);
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
-	film->set_container (Ratio::from_id ("185"));
-	film->set_name ("recover_test");
-	film->set_three_d (true);
-	film->set_video_bit_rate(VideoEncoding::JPEG2000, 100000000);
-
 	auto content = make_shared<ImageContent>("test/data/3d_test");
 	content->video->set_frame_type (VideoFrameType::THREE_D_LEFT_RIGHT);
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("recover_test_3d", { content });
+	film->set_three_d (true);
+	film->set_video_bit_rate(VideoEncoding::JPEG2000, 100000000);
 
 	make_and_verify_dcp (film, { dcp::VerificationNote::Code::MISSING_FFEC_IN_FEATURE, dcp::VerificationNote::Code::MISSING_FFMC_IN_FEATURE });
 
@@ -154,19 +140,12 @@ BOOST_AUTO_TEST_CASE (recover_test_3d, * boost::unit_test::depends_on("recover_t
 
 BOOST_AUTO_TEST_CASE (recover_test_2d_encrypted, * boost::unit_test::depends_on("recover_test_3d"))
 {
-	auto film = new_test_film ("recover_test_2d_encrypted");
-	film->set_interop (false);
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
-	film->set_container (Ratio::from_id ("185"));
-	film->set_name ("recover_test");
+	auto content = make_shared<FFmpegContent>("test/data/count300bd24.m2ts");
+	auto film = new_test_film2("recover_test_2d_encrypted", { content });
 	film->set_encrypted (true);
 	film->_key = dcp::Key("eafcb91c9f5472edf01f3a2404c57258");
 	film->set_video_bit_rate(VideoEncoding::JPEG2000, 100000000);
 
-	auto content = make_shared<FFmpegContent>("test/data/count300bd24.m2ts");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
-
 	make_and_verify_dcp (film, { dcp::VerificationNote::Code::MISSING_FFEC_IN_FEATURE, dcp::VerificationNote::Code::MISSING_FFMC_IN_FEATURE });
 
 	auto video = [film]() {
diff --git a/test/reels_test.cc b/test/reels_test.cc
index e6d8cf9c6..31888ecaf 100644
--- a/test/reels_test.cc
+++ b/test/reels_test.cc
@@ -65,13 +65,9 @@ filter_ok(std::vector<dcp::VerificationNote>& notes)
 /** Test Film::reels() */
 BOOST_AUTO_TEST_CASE (reels_test1)
 {
-	auto film = new_test_film ("reels_test1");
-	film->set_container (Ratio::from_id ("185"));
 	auto A = make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (A);
 	auto B = make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (B);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("reels_test1", { A, B });
 	BOOST_CHECK_EQUAL (A->full_length(film).get(), 288000);
 
 	film->set_reel_type (ReelType::SINGLE);
@@ -111,32 +107,13 @@ BOOST_AUTO_TEST_CASE (reels_test1)
  */
 BOOST_AUTO_TEST_CASE (reels_test2)
 {
-	auto film = new_test_film ("reels_test2");
-	film->set_name ("reels_test2");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_interop (false);
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
-
-	{
-		auto c = make_shared<ImageContent>("test/data/flat_red.png");
-		film->examine_and_add_content (c);
-		BOOST_REQUIRE (!wait_for_jobs());
-		c->video->set_length (24);
-	}
-
-	{
-		auto c = make_shared<ImageContent>("test/data/flat_green.png");
-		film->examine_and_add_content (c);
-		BOOST_REQUIRE (!wait_for_jobs());
-		c->video->set_length (24);
-	}
-
-	{
-		auto c = make_shared<ImageContent>("test/data/flat_blue.png");
-		film->examine_and_add_content (c);
-		BOOST_REQUIRE (!wait_for_jobs());
-		c->video->set_length (24);
-	}
+	auto r = make_shared<ImageContent>("test/data/flat_red.png");
+	auto g = make_shared<ImageContent>("test/data/flat_green.png");
+	auto b = make_shared<ImageContent>("test/data/flat_blue.png");
+	auto film = new_test_film2("reels_test2", { r, g, b });
+	r->video->set_length(24);
+	g->video->set_length(24);
+	b->video->set_length(24);
 
 	film->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	BOOST_CHECK_EQUAL (film->reels().size(), 3U);
@@ -153,9 +130,9 @@ BOOST_AUTO_TEST_CASE (reels_test2)
 	film2->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	film2->set_audio_channels(16);
 
-	auto r = film2->reels ();
-	BOOST_CHECK_EQUAL (r.size(), 3U);
-	auto i = r.begin ();
+	auto reels = film2->reels ();
+	BOOST_CHECK_EQUAL(reels.size(), 3U);
+	auto i = reels.begin();
 	BOOST_CHECK_EQUAL (i->from.get(), 0);
 	BOOST_CHECK_EQUAL (i->to.get(), 96000);
 	++i;
diff --git a/test/required_disk_space_test.cc b/test/required_disk_space_test.cc
index e26a09169..d2e2b4665 100644
--- a/test/required_disk_space_test.cc
+++ b/test/required_disk_space_test.cc
@@ -44,17 +44,12 @@ void check_within_n (int64_t a, int64_t b, int64_t n)
 
 BOOST_AUTO_TEST_CASE (required_disk_space_test)
 {
-	auto film = new_test_film ("required_disk_space_test");
+	auto content_a = content_factory("test/data/flat_blue.png")[0];
+	auto content_b = make_shared<DCPContent>("test/data/burnt_subtitle_test_dcp");
+	auto film = new_test_film2("required_disk_space_test", { content_a, content_b });
 	film->set_video_bit_rate(VideoEncoding::JPEG2000, 100000000);
 	film->set_audio_channels(8);
 	film->set_reel_type (ReelType::BY_VIDEO_CONTENT);
-	auto content_a = content_factory("test/data/flat_blue.png")[0];
-	BOOST_REQUIRE (content_a);
-	film->examine_and_add_content (content_a);
-	auto content_b = make_shared<DCPContent>("test/data/burnt_subtitle_test_dcp");
-	film->examine_and_add_content (content_b);
-	BOOST_REQUIRE (!wait_for_jobs());
-	film->write_metadata ();
 
 	check_within_n (
 		film->required_disk_space(),
diff --git a/test/scaling_test.cc b/test/scaling_test.cc
index 2d453600e..a1ccfb843 100644
--- a/test/scaling_test.cc
+++ b/test/scaling_test.cc
@@ -73,15 +73,9 @@ static void scaling_test_for (shared_ptr<Film> film, shared_ptr<Content> content
 
 BOOST_AUTO_TEST_CASE (scaling_test)
 {
-	auto film = new_test_film ("scaling_test");
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("FTR"));
-	film->set_name ("scaling_test");
 	auto imc = make_shared<ImageContent>("test/data/simple_testcard_640x480.png");
-
-	film->examine_and_add_content (imc);
-
-	BOOST_REQUIRE (!wait_for_jobs());
-
+	auto film = new_test_film2("scaling_test", { imc });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("FTR"));
 	imc->video->set_length (1);
 
 	/* F-133: 133 image in a flat container */
diff --git a/test/skip_frame_test.cc b/test/skip_frame_test.cc
index 8df2fa1d5..f72a1532a 100644
--- a/test/skip_frame_test.cc
+++ b/test/skip_frame_test.cc
@@ -42,17 +42,8 @@ using std::make_shared;
 
 BOOST_AUTO_TEST_CASE (skip_frame_test)
 {
-	auto film = new_test_film ("skip_frame_test");
-	film->set_name ("skip_frame_test");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
-	film->set_interop (false);
 	auto c = make_shared<FFmpegContent>("test/data/count300bd48.m2ts");
-	film->examine_and_add_content (c);
-
-	BOOST_REQUIRE (!wait_for_jobs());
-
-	film->write_metadata ();
+	auto film = new_test_film2("skip_frame_test", { c });
 
 	film->set_video_frame_rate (24);
 	make_and_verify_dcp (film);
diff --git a/test/srt_subtitle_test.cc b/test/srt_subtitle_test.cc
index bac0bedec..ce4ac3f6c 100644
--- a/test/srt_subtitle_test.cc
+++ b/test/srt_subtitle_test.cc
@@ -49,16 +49,11 @@ using namespace dcpomatic;
 /** Make a very short DCP with a single subtitle from .srt with no specified fonts */
 BOOST_AUTO_TEST_CASE (srt_subtitle_test)
 {
-	auto film = new_test_film ("srt_subtitle_test");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
-	film->set_audio_channels (6);
-	film->set_interop (false);
-	film->set_audio_channels(16);
 	auto content = make_shared<StringTextFileContent>("test/data/subrip2.srt");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("srt_subtitle_test", { content });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	film->set_name("frobozz");
+	film->set_audio_channels(16);
 
 	content->only_text()->set_use (true);
 	content->only_text()->set_burn (false);
@@ -79,15 +74,11 @@ BOOST_AUTO_TEST_CASE (srt_subtitle_test)
 /** Same again but with a `font' specified */
 BOOST_AUTO_TEST_CASE (srt_subtitle_test2)
 {
-	auto film = new_test_film ("srt_subtitle_test2");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
-	film->set_audio_channels (6);
-	film->set_interop (false);
 	auto content = make_shared<StringTextFileContent> ("test/data/subrip2.srt");
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("srt_subtitle_test2", { content });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	film->set_name("frobozz");
+	film->set_audio_channels (6);
 
 	content->only_text()->set_use (true);
 	content->only_text()->set_burn (false);
@@ -146,16 +137,12 @@ BOOST_AUTO_TEST_CASE (srt_subtitle_test3)
 /** Build a small DCP with no picture and a single subtitle overlaid onto it */
 BOOST_AUTO_TEST_CASE (srt_subtitle_test4)
 {
-	auto film = new_test_film ("srt_subtitle_test4");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
-	film->set_interop (false);
 	auto content = make_shared<StringTextFileContent>("test/data/subrip2.srt");
+	auto film = new_test_film2("srt_subtitle_test4", { content });
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	film->set_name("frobozz");
 	content->only_text()->set_use (true);
 	content->only_text()->set_burn (false);
-	film->examine_and_add_content (content);
-	BOOST_REQUIRE (!wait_for_jobs());
 	make_and_verify_dcp (
 		film,
 		{
@@ -172,10 +159,9 @@ BOOST_AUTO_TEST_CASE (srt_subtitle_test4)
 /** Check the subtitle XML when there are two subtitle files in the project */
 BOOST_AUTO_TEST_CASE (srt_subtitle_test5)
 {
-	auto film = new_test_film ("srt_subtitle_test5");
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	film->set_name ("frobozz");
+	auto film = new_test_film2("srt_subtitle_test5");
+	film->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	film->set_name("frobozz");
 	film->set_interop (true);
 	film->set_sequence (false);
 	film->set_audio_channels(6);
@@ -292,8 +278,8 @@ BOOST_AUTO_TEST_CASE(srt_subtitle_control_code)
 /** Test rendering of a SubRip subtitle */
 BOOST_AUTO_TEST_CASE (srt_subtitle_test4)
 {
-	shared_ptr<Film> film = new_test_film ("subrip_render_test");
 	shared_ptr<StringTextFile> content (new StringTextFile("test/data/subrip.srt"));
+	shared_ptr<Film> film = new_test_film2("subrip_render_test", { content });
 	content->examine (shared_ptr<Job> (), true);
 	BOOST_CHECK_EQUAL (content->full_length(), DCPTime::from_seconds ((3 * 60) + 56.471));
 
diff --git a/test/test.cc b/test/test.cc
index d214f1d39..147aac6bf 100644
--- a/test/test.cc
+++ b/test/test.cc
@@ -203,20 +203,6 @@ test_film_dir (string name)
 
 
 shared_ptr<Film>
-new_test_film (string name)
-{
-	auto p = test_film_dir (name);
-	if (boost::filesystem::exists (p)) {
-		boost::filesystem::remove_all (p);
-	}
-
-	auto film = make_shared<Film>(p);
-	film->write_metadata ();
-	return film;
-}
-
-
-shared_ptr<Film>
 new_test_film2 (string name, vector<shared_ptr<Content>> content, Cleanup* cleanup)
 {
 	auto p = test_film_dir (name);
diff --git a/test/test.h b/test/test.h
index 0776d6e5a..c4e6460cc 100644
--- a/test/test.h
+++ b/test/test.h
@@ -58,7 +58,6 @@ private:
 
 
 extern bool wait_for_jobs ();
-extern std::shared_ptr<Film> new_test_film (std::string);
 extern std::shared_ptr<Film> new_test_film2 (std::string, std::vector<std::shared_ptr<Content>> content = {}, Cleanup* cleanup = nullptr);
 extern void check_dcp(boost::filesystem::path, boost::filesystem::path, bool sound_can_differ = false);
 extern void check_dcp (boost::filesystem::path, std::shared_ptr<const Film>);
diff --git a/test/threed_test.cc b/test/threed_test.cc
index 38b8f36d4..82cc5dcc8 100644
--- a/test/threed_test.cc
+++ b/test/threed_test.cc
@@ -56,11 +56,8 @@ using std::shared_ptr;
 /** Basic sanity check of THREE_D_LEFT_RIGHT */
 BOOST_AUTO_TEST_CASE (threed_test1)
 {
-	auto film = new_test_film ("threed_test1");
-	film->set_name ("test_film1");
 	auto c = make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("threed_test1", { c });
 
 	c->video->set_frame_type (VideoFrameType::THREE_D_LEFT_RIGHT);
 
@@ -76,16 +73,10 @@ BOOST_AUTO_TEST_CASE (threed_test1)
  */
 BOOST_AUTO_TEST_CASE (threed_test2)
 {
-	auto film = new_test_film ("threed_test2");
-	film->set_name ("test_film2");
 	auto c = make_shared<FFmpegContent>("test/data/test.mp4");
-	film->examine_and_add_content (c);
-	BOOST_REQUIRE (!wait_for_jobs());
-
+	auto film = new_test_film2("threed_test2", { c });
 	c->video->set_frame_type (VideoFrameType::THREE_D_ALTERNATE);
 
-	film->set_container (Ratio::from_id ("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
 	film->set_three_d (true);
 	make_and_verify_dcp (film);
 }
diff --git a/test/time_calculation_test.cc b/test/time_calculation_test.cc
index 7ace7f8c2..e638cefa0 100644
--- a/test/time_calculation_test.cc
+++ b/test/time_calculation_test.cc
@@ -132,7 +132,7 @@ static string const xml = "<Content>"
 
 BOOST_AUTO_TEST_CASE (ffmpeg_time_calculation_test)
 {
-	auto film = new_test_film ("ffmpeg_time_calculation_test");
+	auto film = new_test_film2("ffmpeg_time_calculation_test");
 
 	auto doc = make_shared<cxml::Document>();
 	doc->read_string (xml);
@@ -186,7 +186,7 @@ BOOST_AUTO_TEST_CASE (ffmpeg_time_calculation_test)
 /** Test Player::dcp_to_content_video */
 BOOST_AUTO_TEST_CASE (player_time_calculation_test1)
 {
-	auto film = new_test_film ("player_time_calculation_test1");
+	auto film = new_test_film2("player_time_calculation_test1");
 
 	auto doc = make_shared<cxml::Document>();
 	doc->read_string (xml);
@@ -392,7 +392,7 @@ BOOST_AUTO_TEST_CASE (player_time_calculation_test1)
 /** Test Player::content_video_to_dcp */
 BOOST_AUTO_TEST_CASE (player_time_calculation_test2)
 {
-	auto film = new_test_film ("player_time_calculation_test2");
+	auto film = new_test_film2("player_time_calculation_test2");
 
 	auto doc = make_shared<cxml::Document>();
 	doc->read_string (xml);
@@ -568,7 +568,7 @@ BOOST_AUTO_TEST_CASE (player_time_calculation_test2)
 /** Test Player::dcp_to_content_audio */
 BOOST_AUTO_TEST_CASE (player_time_calculation_test3)
 {
-	auto film = new_test_film ("player_time_calculation_test3");
+	auto film = new_test_film2("player_time_calculation_test3");
 
 	auto doc = make_shared<cxml::Document>();
 	doc->read_string (xml);
diff --git a/test/upmixer_a_test.cc b/test/upmixer_a_test.cc
index af6c8b9e2..6c2c52ea8 100644
--- a/test/upmixer_a_test.cc
+++ b/test/upmixer_a_test.cc
@@ -68,15 +68,9 @@ write (shared_ptr<AudioBuffers> b, DCPTime)
 
 BOOST_AUTO_TEST_CASE (upmixer_a_test)
 {
-	auto film = new_test_film ("upmixer_a_test");
-	film->set_container (Ratio::from_id("185"));
-	film->set_dcp_content_type (DCPContentType::from_isdcf_name("TLR"));
-	film->set_name ("frobozz");
-	film->set_audio_processor (AudioProcessor::from_id("stereo-5.1-upmix-a"));
 	auto content = make_shared<FFmpegContent>("test/data/white.wav");
-	film->examine_and_add_content (content);
-
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("upmixer_a_test", { content });
+	film->set_audio_processor (AudioProcessor::from_id("stereo-5.1-upmix-a"));
 
 	SF_INFO info;
 	info.samplerate = 48000;
diff --git a/test/vf_kdm_test.cc b/test/vf_kdm_test.cc
index d8efa7ab7..5ab1761d3 100644
--- a/test/vf_kdm_test.cc
+++ b/test/vf_kdm_test.cc
@@ -51,16 +51,11 @@ BOOST_AUTO_TEST_CASE (vf_kdm_test)
 
 	/* Make an encrypted DCP from test.mp4 */
 
-	auto A = new_test_film ("vf_kdm_test_ov");
-	A->set_container (Ratio::from_id ("185"));
-	A->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	A->set_name ("frobozz");
-	A->set_interop (true);
-
 	auto c = make_shared<FFmpegContent>("test/data/test.mp4");
-	A->examine_and_add_content (c);
+	auto A = new_test_film2("vf_kdm_test_ov", { c });
+	A->set_interop (true);
+	A->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
 	A->set_encrypted (true);
-	BOOST_REQUIRE (!wait_for_jobs());
 	make_and_verify_dcp (A, {dcp::VerificationNote::Code::INVALID_STANDARD});
 
 	dcp::DCP A_dcp ("build/test/vf_kdm_test_ov/" + A->dcp_name());
@@ -76,18 +71,15 @@ BOOST_AUTO_TEST_CASE (vf_kdm_test)
 
 	/* Import A into a new project, with the required KDM, and make a VF that refers to it */
 
-	auto B = new_test_film ("vf_kdm_test_vf");
-	B->set_container (Ratio::from_id("185"));
-	B->set_dcp_content_type (DCPContentType::from_isdcf_name("TLR"));
-	B->set_name ("frobozz");
-	B->set_interop (true);
-
 	auto d = make_shared<DCPContent>("build/test/vf_kdm_test_ov/" + A->dcp_name());
-	d->add_kdm (A_kdm);
+	d->add_kdm(A_kdm);
+
+	auto B = new_test_film2("vf_kdm_test_vf", { d });
+	B->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+	B->set_interop(true);
+
 	d->set_reference_video (true);
-	B->examine_and_add_content (d);
 	B->set_encrypted (true);
-	BOOST_REQUIRE (!wait_for_jobs());
 	make_and_verify_dcp (B, {dcp::VerificationNote::Code::INVALID_STANDARD, dcp::VerificationNote::Code::EXTERNAL_ASSET});
 
 	dcp::DCP B_dcp ("build/test/vf_kdm_test_vf/" + B->dcp_name());
@@ -100,18 +92,14 @@ BOOST_AUTO_TEST_CASE (vf_kdm_test)
 	   This KDM should decrypt assets from the OV too.
 	*/
 
-	auto C = new_test_film ("vf_kdm_test_check");
-	C->set_container (Ratio::from_id ("185"));
-	C->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
-	C->set_name ("frobozz");
-	C->set_interop (true);
-
 	auto e = make_shared<DCPContent>("build/test/vf_kdm_test_vf/" + B->dcp_name());
-	e->add_kdm (B_kdm);
 	e->add_ov ("build/test/vf_kdm_test_ov/" + A->dcp_name());
-	C->examine_and_add_content (e);
+	e->add_kdm(B_kdm);
+	auto C = new_test_film2("vf_kdm_test_check", { e });
+	C->set_interop (true);
 	C->set_audio_channels(6);
-	BOOST_REQUIRE (!wait_for_jobs());
+	C->set_dcp_content_type(DCPContentType::from_isdcf_name("TLR"));
+
 	make_and_verify_dcp (C, {dcp::VerificationNote::Code::INVALID_STANDARD});
 
 	/* Should be 1s red, 1s green, 1s blue */
diff --git a/test/vf_test.cc b/test/vf_test.cc
index 051712deb..5fb1b9861 100644
--- a/test/vf_test.cc
+++ b/test/vf_test.cc
@@ -65,11 +65,8 @@ using namespace dcpomatic;
 /** Test the logic which decides whether a DCP can be referenced or not */
 BOOST_AUTO_TEST_CASE (vf_test1)
 {
-	auto film = new_test_film ("vf_test1");
-	film->set_interop (false);
 	auto dcp = make_shared<DCPContent>("test/data/reels_test2");
-	film->examine_and_add_content (dcp);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto film = new_test_film2("vf_test1", { dcp });
 
 	/* Multi-reel DCP can't be referenced if we are using a single reel for the project */
 	film->set_reel_type (ReelType::SINGLE);
@@ -111,31 +108,19 @@ BOOST_AUTO_TEST_CASE (vf_test1)
 BOOST_AUTO_TEST_CASE (vf_test2)
 {
 	/* Make the OV */
-	auto ov = new_test_film ("vf_test2_ov");
-	ov->set_dcp_content_type (DCPContentType::from_isdcf_name("TST"));
-	ov->set_name ("vf_test2_ov");
 	auto video = content_factory("test/data/flat_red.png")[0];
-	ov->examine_and_add_content (video);
-	BOOST_REQUIRE (!wait_for_jobs());
-	video->video->set_length (24 * 5);
 	auto audio = content_factory("test/data/white.wav")[0];
-	ov->examine_and_add_content (audio);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto ov = new_test_film2("vf_test2_ov", { video, audio });
+	video->video->set_length (24 * 5);
 	make_and_verify_dcp (ov);
 
 	/* Make the VF */
-	auto vf = new_test_film ("vf_test2_vf");
-	vf->set_name ("vf_test2_vf");
-	vf->set_dcp_content_type (DCPContentType::from_isdcf_name("TST"));
-	vf->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	auto dcp = make_shared<DCPContent>(ov->dir(ov->dcp_name()));
-	vf->examine_and_add_content (dcp);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto sub = content_factory("test/data/subrip4.srt")[0];
+	auto vf = new_test_film2("vf_test2_vf", { dcp, sub });
+	vf->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	dcp->set_reference_video (true);
 	dcp->set_reference_audio (true);
-	auto sub = content_factory("test/data/subrip4.srt")[0];
-	vf->examine_and_add_content (sub);
-	BOOST_REQUIRE (!wait_for_jobs());
 	make_and_verify_dcp (
 		vf,
 		{
@@ -175,29 +160,18 @@ BOOST_AUTO_TEST_CASE (vf_test2)
 BOOST_AUTO_TEST_CASE (vf_test3)
 {
 	/* Make the OV */
-	auto ov = new_test_film ("vf_test3_ov");
-	ov->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
-	ov->set_name ("vf_test3_ov");
 	auto video = content_factory("test/data/flat_red.png")[0];
-	ov->examine_and_add_content (video);
-	BOOST_REQUIRE (!wait_for_jobs());
-	video->video->set_length (24 * 5);
 	auto audio = content_factory("test/data/white.wav")[0];
-	ov->examine_and_add_content (audio);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto ov = new_test_film2("vf_test3_ov", { video, audio });
+	video->video->set_length (24 * 5);
 	make_and_verify_dcp (ov);
 
 	/* Make the VF */
-	auto vf = new_test_film ("vf_test3_vf");
-	vf->set_name ("vf_test3_vf");
-	vf->set_dcp_content_type (DCPContentType::from_isdcf_name("TST"));
-	vf->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	auto dcp = make_shared<DCPContent>(ov->dir(ov->dcp_name()));
-	BOOST_REQUIRE (dcp);
+	auto vf = new_test_film2("vf_test3_vf", { dcp });
+	vf->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	dcp->set_trim_start(vf, ContentTime::from_seconds (1));
 	dcp->set_trim_end (ContentTime::from_seconds (1));
-	vf->examine_and_add_content (dcp);
-	BOOST_REQUIRE (!wait_for_jobs());
 	dcp->set_reference_video (true);
 	dcp->set_reference_audio (true);
 	make_and_verify_dcp(vf, {dcp::VerificationNote::Code::EXTERNAL_ASSET}, false);
@@ -219,28 +193,17 @@ BOOST_AUTO_TEST_CASE (vf_test3)
 BOOST_AUTO_TEST_CASE (vf_test4)
 {
 	/* Make the OV */
-	auto ov = new_test_film ("vf_test4_ov");
-	ov->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
-	ov->set_name ("vf_test4_ov");
 	auto video = content_factory("test/data/flat_red.png")[0];
-	ov->examine_and_add_content (video);
-	BOOST_REQUIRE (!wait_for_jobs());
-	video->video->set_length (24 * 5);
 	auto audio = content_factory("test/data/white.wav")[0];
-	ov->examine_and_add_content (audio);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto ov = new_test_film2("vf_test4_ov", { video, audio });
+	video->video->set_length (24 * 5);
 	make_and_verify_dcp (ov);
 
 	/* Make the VF */
-	auto vf = new_test_film ("vf_test4_vf");
-	vf->set_name ("vf_test4_vf");
-	vf->set_dcp_content_type (DCPContentType::from_isdcf_name("TST"));
+	auto dcp = make_shared<DCPContent>(ov->dir(ov->dcp_name()));
+	auto vf = new_test_film2("vf_test4_vf", { dcp });
 	vf->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	vf->set_sequence (false);
-	auto dcp = make_shared<DCPContent>(ov->dir(ov->dcp_name()));
-	BOOST_REQUIRE (dcp);
-	vf->examine_and_add_content (dcp);
-	BOOST_REQUIRE (!wait_for_jobs());
 	dcp->set_position(vf, DCPTime::from_seconds(10));
 	dcp->set_reference_video (true);
 	dcp->set_reference_audio (true);
@@ -248,7 +211,6 @@ BOOST_AUTO_TEST_CASE (vf_test4)
 	vf->examine_and_add_content (more_video);
 	BOOST_REQUIRE (!wait_for_jobs());
 	more_video->set_position (vf, DCPTime());
-	vf->write_metadata ();
 	make_and_verify_dcp(vf, {dcp::VerificationNote::Code::EXTERNAL_ASSET}, false);
 
 	dcp::DCP ov_c (ov->dir(ov->dcp_name()));
@@ -276,8 +238,7 @@ BOOST_AUTO_TEST_CASE (vf_test4)
 BOOST_AUTO_TEST_CASE (vf_test5)
 {
 	/* Make the OV */
-	auto ov = new_test_film ("vf_test5_ov");
-	ov->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
+	auto ov = new_test_film2("vf_test5_ov");
 	ov->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	for (int i = 0; i < 3; ++i) {
 		auto video = content_factory("test/data/flat_red.png")[0];
@@ -290,15 +251,10 @@ BOOST_AUTO_TEST_CASE (vf_test5)
 	make_and_verify_dcp (ov);
 
 	/* Make the VF */
-	auto vf = new_test_film ("vf_test5_vf");
-	vf->set_name ("vf_test5_vf");
-	vf->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST"));
+	auto dcp = make_shared<DCPContent>(ov->dir(ov->dcp_name()));
+	auto vf = new_test_film2("vf_test5_vf", { dcp });
 	vf->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	vf->set_sequence (false);
-	auto dcp = make_shared<DCPContent>(ov->dir(ov->dcp_name()));
-	BOOST_REQUIRE (dcp);
-	vf->examine_and_add_content (dcp);
-	BOOST_REQUIRE (!wait_for_jobs());
 	dcp->set_reference_video (true);
 	dcp->set_reference_audio (true);
 	dcp->set_trim_end (ContentTime::from_seconds(15));
@@ -323,24 +279,17 @@ BOOST_AUTO_TEST_CASE (vf_test5)
 BOOST_AUTO_TEST_CASE (vf_test6)
 {
 	/* Make the OV */
-	auto ov = new_test_film ("vf_test6_ov");
-	ov->set_dcp_content_type (DCPContentType::from_isdcf_name("TST"));
-	ov->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	auto video = content_factory("test/data/flat_red.png")[0];
-	ov->examine_and_add_content (video);
-	BOOST_REQUIRE (!wait_for_jobs());
+	auto ov = new_test_film2("vf_test6_ov", { video });
+	ov->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	video->video->set_length (24 * 10);
 	make_and_verify_dcp (ov);
 
 	/* Make the VF */
-	auto vf = new_test_film ("vf_test6_vf");
-	vf->set_name ("vf_test6_vf");
-	vf->set_dcp_content_type (DCPContentType::from_isdcf_name("TST"));
+	auto dcp = make_shared<DCPContent>(ov->dir(ov->dcp_name()));
+	auto vf = new_test_film2("vf_test6_vf", { dcp });
 	vf->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 	vf->set_sequence (false);
-	auto dcp = make_shared<DCPContent>(ov->dir(ov->dcp_name()));
-	vf->examine_and_add_content (dcp);
-	BOOST_REQUIRE (!wait_for_jobs());
 	dcp->set_reference_video (true);
 	dcp->set_reference_audio (true);