AK: Remove fatal() from InputStream.

Fatal errors can not be handeled and lead to an assertion error when the
stream is destroyed. It makes no sense to delay the assertion failure,
instead of setting m_fatal, an assertion should be done directly.

2 files changed, 10 insertions, 12 deletions

diff --git a/AK/Stream.h b/AK/Stream.h
index ff6d32d979..daa0c11227 100644
--- a/AK/Stream.h
+++ b/AK/Stream.h
@@ -37,17 +37,15 @@ class Stream {
 public:
     virtual ~Stream()
     {
-        ASSERT(!error() && !fatal());
+        ASSERT(!error());
     }
 
     bool error() const { return m_error; }
-    bool fatal() const { return m_fatal; }
 
     bool handle_error() { return exchange(m_error, false); }
 
 protected:
     mutable bool m_error { false };
-    mutable bool m_fatal { false };
 };
 
 }
diff --git a/AK/Tests/TestStream.cpp b/AK/Tests/TestStream.cpp
index a8b581e988..09cc1ea259 100644
--- a/AK/Tests/TestStream.cpp
+++ b/AK/Tests/TestStream.cpp
@@ -48,7 +48,7 @@ TEST_CASE(read_an_integer)
     InputMemoryStream stream { { &expected, sizeof(expected) } };
     stream >> actual;
 
-    EXPECT(!stream.error() && !stream.fatal() && stream.eof());
+    EXPECT(!stream.error() && stream.eof());
     EXPECT_EQ(expected, actual);
 }
 
@@ -59,15 +59,15 @@ TEST_CASE(recoverable_error)
 
     InputMemoryStream stream { { &expected, sizeof(expected) } };
 
-    EXPECT(!stream.error() && !stream.fatal() && !stream.eof());
+    EXPECT(!stream.error() && !stream.eof());
     stream >> to_large_value;
-    EXPECT(stream.error() && !stream.fatal() && !stream.eof());
+    EXPECT(stream.error() && !stream.eof());
 
     EXPECT(stream.handle_error());
-    EXPECT(!stream.error() && !stream.fatal() && !stream.eof());
+    EXPECT(!stream.error() && !stream.eof());
 
     stream >> actual;
-    EXPECT(!stream.error() && !stream.fatal() && stream.eof());
+    EXPECT(!stream.error() && stream.eof());
     EXPECT_EQ(expected, actual);
 }
 
@@ -78,7 +78,7 @@ TEST_CASE(chain_stream_operator)
     InputMemoryStream stream { { expected, sizeof(expected) } };
 
     stream >> actual[0] >> actual[1] >> actual[2] >> actual[3];
-    EXPECT(!stream.error() && !stream.fatal() && stream.eof());
+    EXPECT(!stream.error() && stream.eof());
 
     EXPECT(compare({ expected, sizeof(expected) }, { actual, sizeof(actual) }));
 }
@@ -94,17 +94,17 @@ TEST_CASE(seeking_slicing_offset)
     InputMemoryStream stream { { input, sizeof(input) } };
 
     stream >> Bytes { actual0, sizeof(actual0) };
-    EXPECT(!stream.error() && !stream.fatal() && !stream.eof());
+    EXPECT(!stream.error() && !stream.eof());
     EXPECT(compare({ expected0, sizeof(expected0) }, { actual0, sizeof(actual0) }));
 
     stream.seek(4);
     stream >> Bytes { actual1, sizeof(actual1) };
-    EXPECT(!stream.error() && !stream.fatal() && stream.eof());
+    EXPECT(!stream.error() && stream.eof());
     EXPECT(compare({ expected1, sizeof(expected1) }, { actual1, sizeof(actual1) }));
 
     stream.seek(1);
     stream >> Bytes { actual2, sizeof(actual2) };
-    EXPECT(!stream.error() && !stream.fatal() && !stream.eof());
+    EXPECT(!stream.error() && !stream.eof());
     EXPECT(compare({ expected2, sizeof(expected2) }, { actual2, sizeof(actual2) }));
 }