diff --git a/test/dartdoc_test.dart b/test/dartdoc_test.dart
index 30d6fef..f9282ec 100644
--- a/test/dartdoc_test.dart
+++ b/test/dartdoc_test.dart
@@ -178,17 +178,6 @@
             throwsA(const TypeMatcher<ProcessException>()));
       });
 
-      test('errors cause non-zero exit when warnings are on', () async {
-        expect(
-            () => subprocessLauncher.runStreamed(Platform.resolvedExecutable, [
-                  dartdocPath,
-                  '--input=${testPackageToolError.path}',
-                  '--output=${pathLib.join(tempDir.absolute.path, 'test_package_tool_error')}',
-                  '--show-warnings',
-                ]),
-            throwsA(const TypeMatcher<ProcessException>()));
-      });
-
       test('help prints command line args', () async {
         List<String> outputLines = [];
         await subprocessLauncher.runStreamed(
