Updated structures and functions for setting the max bitrate limit to take rtc::Optional<int>

webrtc/base/optional_unittest.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
+#include <sstream>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/optional.h"
+#include "webrtc/base/optional_ios.h"
 
 namespace rtc {
 
 namespace {
 
 // Class whose instances logs various method calls (constructor, destructor,
 // etc.). Each instance has a unique ID (a simple global sequence number) and
 // an origin ID. When a copy is made, the new object gets a fresh ID but copies
 // the origin ID from the original. When a new Logger is created from scratch,
 // it gets a fresh ID, and the origin ID is the same as the ID (default
@@ skipping 27 matching lines @@
     Log2("swap", a, b);
   }
   friend bool operator==(const Logger& a, const Logger& b) {
     Log2("operator==", a, b);
     return a.origin_ == b.origin_;
   }
   friend bool operator!=(const Logger& a, const Logger& b) {
     Log2("operator!=", a, b);
     return a.origin_ != b.origin_;
   }
+  friend std::ostream& operator<<(std::ostream& stream, const Logger& l);
   void Foo() { Log("Foo()"); }
   void Foo() const { Log("Foo() const"); }
   static rtc::scoped_ptr<std::vector<std::string>> Setup() {
     auto s = rtc_make_scoped_ptr(new std::vector<std::string>);
     g_log = s.get();
     g_next_id = 0;
     return s;
   }
 
  private:
@@ skipping 16 matching lines @@
     std::ostringstream oss;
     oss << msg << ' ' << a.id_ << ':' << a.origin_ << ", " << b.id_ << ':'
         << b.origin_;
     g_log->push_back(oss.str());
   }
 };
 
 std::vector<std::string>* Logger::g_log = nullptr;
 int Logger::g_next_id = 0;
 
+// Operator<< for Logger. EXPECT_EQ internally uses operator<< to format the
+// error message, which uses operator<< for Optional<T> which in turn depends
+// on operator<< for T.
+std::ostream& operator<<(std::ostream& stream, const Logger& logger) {
+  for (auto it = Logger::g_log->begin(); it != Logger::g_log->end(); ++it) {
+    if (it != Logger::g_log->begin()) {
+      stream << "; ";
+    }
+    stream << *it;
+  }
+  return stream;
+}
+
 // Append all the other args to the vector pointed to by the first arg.
 template <typename T>
 void VectorAppend(std::vector<T>* v) {}
 template <typename T, typename... Ts>
 void VectorAppend(std::vector<T>* v, const T& e, Ts... es) {
   v->push_back(e);
   VectorAppend(v, es...);
 }
 
 // Create a vector of strings. Because we're not allowed to use
@@ skipping 368 matching lines @@
               "3:42. copy constructor (from 1:42)",
               "4:17. copy constructor (from 0:17)", "5:5. default constructor",
               "6:6. default constructor", "7:7. default constructor", "---",
               "swap 2:42, 3:17", "swap 4:5, 5:17", "swap 6:7, 7:6", "---",
               "7:6. destructor", "6:7. destructor", "5:17. destructor",
               "4:5. destructor", "3:17. destructor", "2:42. destructor",
               "1:42. destructor", "0:17. destructor"),
             *log);
 }
 
+template <typename T>
+void ExpectWriteResult(const std::string& expected, rtc::Optional<T> value) {
+  std::ostringstream stream;
+  stream << value;
+  EXPECT_EQ(expected, stream.str());
+}
+
+TEST(OptionalTest, TestWriteToOstream) {
+  ExpectWriteResult("1", rtc::Optional<int>(1));
+  ExpectWriteResult("<not set>", rtc::Optional<int>());
+  ExpectWriteResult("", rtc::Optional<std::string>(std::string()));
+  ExpectWriteResult("<not set>", rtc::Optional<std::string>());
+}
+
 }  // namespace rtc