make clang-format using clang-format-3.6

1 files changed, 64 insertions, 56 deletions

diff --git a/test/ChunkedDecodingStreamFilterTest.cc b/test/ChunkedDecodingStreamFilterTest.cc
index 9031b9c7..2b2a8256 100644
--- a/test/ChunkedDecodingStreamFilterTest.cc
+++ b/test/ChunkedDecodingStreamFilterTest.cc
@@ -13,7 +13,7 @@
 
 namespace aria2 {
 
-class ChunkedDecodingStreamFilterTest:public CppUnit::TestFixture {
+class ChunkedDecodingStreamFilterTest : public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(ChunkedDecodingStreamFilterTest);
   CPPUNIT_TEST(testTransform);
@@ -29,10 +29,8 @@ class ChunkedDecodingStreamFilterTest:public CppUnit::TestFixture {
   std::shared_ptr<ByteArrayDiskWriter> writer_;
   std::shared_ptr<Segment> segment_;
 
-  void clearWriter()
-  {
-    writer_->setString("");
-  }
+  void clearWriter() { writer_->setString(""); }
+
 public:
   void setUp()
   {
@@ -53,32 +51,32 @@ public:
   void testGetName();
 };
 
-
-CPPUNIT_TEST_SUITE_REGISTRATION( ChunkedDecodingStreamFilterTest );
+CPPUNIT_TEST_SUITE_REGISTRATION(ChunkedDecodingStreamFilterTest);
 
 void ChunkedDecodingStreamFilterTest::testTransform()
 {
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("a\r\n1234567890\r\n");
+        reinterpret_cast<const unsigned char*>("a\r\n1234567890\r\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)10, r);
     CPPUNIT_ASSERT_EQUAL(std::string("1234567890"), writer_->getString());
     CPPUNIT_ASSERT_EQUAL((size_t)15, filter_->getBytesProcessed());
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   clearWriter();
   try {
     // Feed extension; see it is ignored.
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>
-      ("3;extensionIgnored\r\n123\r\n");
+        reinterpret_cast<const unsigned char*>("3;extensionIgnored\r\n123\r\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)3, r);
     CPPUNIT_ASSERT_EQUAL(std::string("123"), writer_->getString());
     CPPUNIT_ASSERT_EQUAL((size_t)25, filter_->getBytesProcessed());
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
 
@@ -86,113 +84,122 @@ void ChunkedDecodingStreamFilterTest::testTransform()
   // Feed 2extensions; see it is ignored.
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>
-      ("3;extension1;extension2;\r\n123\r\n");
+        reinterpret_cast<const unsigned char*>(
+            "3;extension1;extension2;\r\n123\r\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)3, r);
     CPPUNIT_ASSERT_EQUAL(std::string("123"), writer_->getString());
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   clearWriter();
   // Not all chunk size is available
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("1");
+        reinterpret_cast<const unsigned char*>("1");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)0, r);
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   clearWriter();
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("0\r\n1234567890123456\r\n");
+        reinterpret_cast<const unsigned char*>("0\r\n1234567890123456\r\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)16, r);
-    CPPUNIT_ASSERT_EQUAL(std::string("1234567890123456"),
-                         writer_->getString());
-  } catch(DlAbortEx& e) {
+    CPPUNIT_ASSERT_EQUAL(std::string("1234567890123456"), writer_->getString());
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   clearWriter();
   // Not all chunk data is available
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("10\r\n1234567890");
+        reinterpret_cast<const unsigned char*>("10\r\n1234567890");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)10, r);
     CPPUNIT_ASSERT_EQUAL(std::string("1234567890"), writer_->getString());
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   clearWriter();
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("123456\r\n");
+        reinterpret_cast<const unsigned char*>("123456\r\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)6, r);
     CPPUNIT_ASSERT_EQUAL(std::string("123456"), writer_->getString());
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   clearWriter();
   // no trailing CR LF.
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("10\r\n1234567890123456");
+        reinterpret_cast<const unsigned char*>("10\r\n1234567890123456");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)16, r);
-    CPPUNIT_ASSERT_EQUAL(std::string("1234567890123456"),
-                         writer_->getString());
-  } catch(DlAbortEx& e) {
+    CPPUNIT_ASSERT_EQUAL(std::string("1234567890123456"), writer_->getString());
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   clearWriter();
   // feed only CR
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("\r");
+        reinterpret_cast<const unsigned char*>("\r");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)0, r);
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   // feed next LF
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("\n");
+        reinterpret_cast<const unsigned char*>("\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)0, r);
     CPPUNIT_ASSERT_EQUAL(std::string(""), writer_->getString());
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   // feed 0 CR LF.
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("0\r\n");
+        reinterpret_cast<const unsigned char*>("0\r\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)0, r);
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   // feed trailer
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("trailer\r\n");
+        reinterpret_cast<const unsigned char*>("trailer\r\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)0, r);
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   // feed final CRLF
   try {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("\r\n");
+        reinterpret_cast<const unsigned char*>("\r\n");
     ssize_t r = filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_ASSERT_EQUAL((ssize_t)0, r);
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }
   // input is over
@@ -201,21 +208,20 @@ void ChunkedDecodingStreamFilterTest::testTransform()
 
 void ChunkedDecodingStreamFilterTest::testTransform_withoutTrailer()
 {
-  CPPUNIT_ASSERT_EQUAL
-    ((ssize_t)0,
-     filter_->transform
-     (writer_, segment_,
-      reinterpret_cast<const unsigned char*>("0\r\n\r\n"), 5));
+  CPPUNIT_ASSERT_EQUAL(
+      (ssize_t)0, filter_->transform(
+                      writer_, segment_,
+                      reinterpret_cast<const unsigned char*>("0\r\n\r\n"), 5));
   CPPUNIT_ASSERT(filter_->finished());
 }
 
 void ChunkedDecodingStreamFilterTest::testTransform_with2Trailers()
 {
-  CPPUNIT_ASSERT_EQUAL
-    ((ssize_t)0,
-     filter_->transform
-     (writer_, segment_,
-      reinterpret_cast<const unsigned char*>("0\r\nt1\r\nt2\r\n\r\n"), 13));
+  CPPUNIT_ASSERT_EQUAL(
+      (ssize_t)0,
+      filter_->transform(
+          writer_, segment_,
+          reinterpret_cast<const unsigned char*>("0\r\nt1\r\nt2\r\n\r\n"), 13));
   CPPUNIT_ASSERT(filter_->finished());
 }
 
@@ -224,7 +230,7 @@ void ChunkedDecodingStreamFilterTest::testTransform_largeChunkSize()
   // chunkSize should be under 2^63-1
   {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("7fffffffffffffff\r\n");
+        reinterpret_cast<const unsigned char*>("7fffffffffffffff\r\n");
     filter_->transform(writer_, segment_, msg.data(), msg.size());
   }
 }
@@ -234,11 +240,12 @@ void ChunkedDecodingStreamFilterTest::testTransform_tooLargeChunkSize()
   // chunkSize 2^64 causes error
   {
     std::basic_string<unsigned char> msg =
-      reinterpret_cast<const unsigned char*>("ffffffffffffffff\r\n");
+        reinterpret_cast<const unsigned char*>("ffffffffffffffff\r\n");
     try {
       filter_->transform(writer_, segment_, msg.data(), msg.size());
       CPPUNIT_FAIL("exception must be thrown.");
-    } catch(DlAbortEx& e) {
+    }
+    catch (DlAbortEx& e) {
       // success
     }
   }
@@ -247,19 +254,20 @@ void ChunkedDecodingStreamFilterTest::testTransform_tooLargeChunkSize()
 void ChunkedDecodingStreamFilterTest::testTransform_chunkSizeMismatch()
 {
   std::basic_string<unsigned char> msg =
-    reinterpret_cast<const unsigned char*>("3\r\n1234\r\n");
+      reinterpret_cast<const unsigned char*>("3\r\n1234\r\n");
   try {
     filter_->transform(writer_, segment_, msg.data(), msg.size());
     CPPUNIT_FAIL("exception must be thrown.");
-  } catch(DlAbortEx& e) {
+  }
+  catch (DlAbortEx& e) {
     // success
   }
 }
 
 void ChunkedDecodingStreamFilterTest::testGetName()
 {
-  CPPUNIT_ASSERT_EQUAL
-    (std::string("ChunkedDecodingStreamFilter"), filter_->getName());
+  CPPUNIT_ASSERT_EQUAL(std::string("ChunkedDecodingStreamFilter"),
+                       filter_->getName());
 }
 
 } // namespace aria2