Use output-only string streams instead of input-output string streams.

runtime/platform/assert.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef PLATFORM_ASSERT_H_
 #define PLATFORM_ASSERT_H_
 
 // TODO(5411406): include sstream for now, once we have a Utils::toString()
 // implemented for all the primitive types we can replace the usage of
 // sstream by Utils::toString()
@@ skipping 81 matching lines @@
       : DynamicAssertionHelper(file, line, EXPECT) { }
 };
 
 
 #if defined(TESTING)
 // Only allow the expensive (with respect to code size) assertions
 // in testing code.
 template<typename E, typename A>
 void DynamicAssertionHelper::Equals(const E& expected, const A& actual) {
   if (actual == expected) return;
-  std::stringstream ess, ass;
+  std::ostringstream ess, ass;
   ess << expected;
   ass << actual;
   std::string es = ess.str(), as = ass.str();
   Fail("expected: <%s> but was: <%s>", es.c_str(), as.c_str());
 }
 
 
 template<typename E, typename A>
 void DynamicAssertionHelper::NotEquals(const E& not_expected,
                                        const A& actual) {
   if (actual != not_expected) return;
-  std::stringstream ness;
+  std::ostringstream ness;
   ness << not_expected;
   std::string nes = ness.str();
   Fail("did not expect: <%s>", nes.c_str());
 }
 
 
 template<typename E, typename A, typename T>
 void DynamicAssertionHelper::FloatEquals(const E& expected,
                                          const A& actual,
                                          const T& tol) {
   if (((expected - tol) <= actual) && (actual <= (expected + tol))) {
     return;
   }
-  std::stringstream ess, ass, tolss;
+  std::ostringstream ess, ass, tolss;
   ess << expected;
   ass << actual;
   tolss << tol;
   std::string es = ess.str(), as = ass.str(), tols = tolss.str();
   Fail("expected: <%s> but was: <%s> (tolerance: <%s>)",
        es.c_str(),
        as.c_str(),
        tols.c_str());
 }
 
 
 template<typename E, typename A>
 void DynamicAssertionHelper::StringEquals(const E& expected, const A& actual) {
-  std::stringstream ess, ass;
+  std::ostringstream ess, ass;
   ess << expected;
   ass << actual;
   std::string es = ess.str(), as = ass.str();
   if (as == es) return;
   Fail("expected: <\"%s\"> but was: <\"%s\">", es.c_str(), as.c_str());
 }
 
 
 template<typename E, typename A>
 void DynamicAssertionHelper::IsSubstring(const E& needle, const A& haystack) {
-  std::stringstream ess, ass;
+  std::ostringstream ess, ass;
   ess << needle;
   ass << haystack;
   std::string es = ess.str(), as = ass.str();
   if (as.find(es) != std::string::npos) return;
   Fail("expected <\"%s\"> to be a substring of <\"%s\">",
        es.c_str(), as.c_str());
 }
 
 
 template<typename E, typename A>
 void DynamicAssertionHelper::IsNotSubstring(const E& needle,
                                             const A& haystack) {
-  std::stringstream ess, ass;
+  std::ostringstream ess, ass;
   ess << needle;
   ass << haystack;
   std::string es = ess.str(), as = ass.str();
   if (as.find(es) == std::string::npos) return;
   Fail("expected <\"%s\"> to not be a substring of <\"%s\">",
        es.c_str(), as.c_str());
 }
 
 
 template<typename E, typename A>
 void DynamicAssertionHelper::LessThan(const E& left, const A& right) {
   if (left < right) return;
-  std::stringstream ess, ass;
+  std::ostringstream ess, ass;
   ess << left;
   ass << right;
   std::string es = ess.str(), as = ass.str();
   Fail("expected: %s < %s", es.c_str(), as.c_str());
 }
 
 
 template<typename E, typename A>
 void DynamicAssertionHelper::LessEqual(const E& left, const A& right) {
   if (left <= right) return;
-  std::stringstream ess, ass;
+  std::ostringstream ess, ass;
   ess << left;
   ass << right;
   std::string es = ess.str(), as = ass.str();
   Fail("expected: %s <= %s", es.c_str(), as.c_str());
 }
 
 
 template<typename E, typename A>
 void DynamicAssertionHelper::GreaterThan(const E& left, const A& right) {
   if (left > right) return;
-  std::stringstream ess, ass;
+  std::ostringstream ess, ass;
   ess << left;
   ass << right;
   std::string es = ess.str(), as = ass.str();
   Fail("expected: %s > %s", es.c_str(), as.c_str());
 }
 
 
 template<typename E, typename A>
 void DynamicAssertionHelper::GreaterEqual(const E& left, const A& right) {
   if (left >= right) return;
-  std::stringstream ess, ass;
+  std::ostringstream ess, ass;
   ess << left;
   ass << right;
   std::string es = ess.str(), as = ass.str();
   Fail("expected: %s >= %s", es.c_str(), as.c_str());
 }
 
 
 template<typename T>
 void DynamicAssertionHelper::NotNull(const T p) {
   if (p != NULL) return;
@@ skipping 119 matching lines @@
 #define WARN(error)                                                           \
   dart::Expect(__FILE__, __LINE__).Fail("%s", error)
 
 #define WARN1(format, p1)                                                     \
   dart::Expect(__FILE__, __LINE__).Fail(format, (p1))
 
 #define WARN2(format, p1, p2)                                                 \
   dart::Expect(__FILE__, __LINE__).Fail(format, (p1), (p2))
 
 #endif  // PLATFORM_ASSERT_H_