Add a PrintTo function for rtc::Optional to aid with testing.

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 <memory>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/optional.h"
 
 namespace rtc {
 
 namespace {
 
+struct MyUnprintableType {
+  MyUnprintableType() = default;
+  MyUnprintableType(int value) : value(value) {}
+
+  int value;

[kwiberg-webrtc, 2017/02/16 14:07:37]

You can make these classes several lines shorter by hardcoding the numerical
value...

[ossu, 2017/02/16 14:23:48]

That is true. I could also just use brace initialization down in the test. It's
probably cleanest.

+};
+
+struct MyPrintableType {
+  MyPrintableType() = default;
+  MyPrintableType(int value) : value(value) {}
+
+  int value;
+
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const MyPrintableType& mpt) {
+    os << mpt.value;
+    return os;
+  }
+};
+
 // 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
 // constructor) or given as an argument (explicit constructor).
 class Logger {
  public:
   Logger() : id_(g_next_id++), origin_(id_) { Log("default constructor"); }
   explicit Logger(int origin) : id_(g_next_id++), origin_(origin) {
@@ skipping 699 matching lines @@
     Logger moved = x.MoveValue();
     log->push_back("---");
   }
   EXPECT_EQ(
       V("0:42. explicit constructor", "1:42. move constructor (from 0:42)",
         "0:42. destructor", "---", "2:42. move constructor (from 1:42)", "---",
         "2:42. destructor", "1:42. destructor"),
       *log);
 }
 
+TEST(OptionalTest, TestPrintTo) {
+  constexpr char kEmptyOptionalMessage[] = "<empty optional>";
+  const Optional<MyUnprintableType> empty_unprintable;
+  const Optional<MyPrintableType> empty_printable;
+  static_assert(std::is_same<void, decltype(PrintTo(empty_printable,

[ossu, 2017/02/16 13:20:05]

Not really the greatest place to do a static_assert of this, but doing it
without having actual types in place is a mess. Also, it's probably unnecessary:
the compiler complains about reaching the end of PrintTo without returning a
value if its return type isn't void, so I might as well remove this. WDYT?

[kwiberg-webrtc, 2017/02/16 14:07:37]

Hmm. When would the return value not be void?

[ossu, 2017/02/16 14:23:48]

I put this here only to ensure that my cast in decltype() in optional.h actually
worked. And it did! :)

[kwiberg-webrtc, 2017/02/16 14:33:33]

Oh, OK, that explains why you were talking about warnings about reaching the end
of a non-void function... So yeah, remove the static_assert then.

+                                                    static_cast<std::ostream*>(
+                                                        nullptr)))>::value != 0,

[kwiberg-webrtc, 2017/02/16 14:07:37]

std::declval<std::ostream*>() ?

[ossu, 2017/02/16 14:23:48]

Ah, right! The last time I did this, I had a C++11 compiler but no C++11
standard library, so declval wasn't available. Will fix. 

+                "PrintTo should return void");
+  EXPECT_NE(kEmptyOptionalMessage, ::testing::PrintToString(empty_unprintable));
+  EXPECT_EQ(kEmptyOptionalMessage, ::testing::PrintToString(empty_printable));
+  EXPECT_NE("1", ::testing::PrintToString(Optional<MyUnprintableType>(1)));
+  EXPECT_EQ("1", ::testing::PrintToString(Optional<MyPrintableType>(1)));
+}
+
 }  // namespace rtc