gtest/internal/gtest-internal.h

114 ::std::string PrintToString(const T& value);
139             typename std::enable_if<!std::is_convertible<T, Sink>::value,
145 GTEST_API_ std::string AppendUserMessage(const std::string& gtest_msg,
155 // are enabled).  We derive it from std::runtime_error, which is for
157 // std::runtime_error inherits from std::exception, many testing
159 class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
175 GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
176     const std::vector<size_t>& left, const std::vector<size_t>& right);
179 GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
180     const std::vector<std::string>& left,
181     const std::vector<std::string>& right);
184 GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
185                                          const std::vector<std::string>& right,
207                                      const std::string& expected_value,
208                                      const std::string& actual_value,
212 GTEST_API_ std::string GetBoolAssertionFailureMessage(
259       std::numeric_limits<RawType>::digits - 1;
478   CodeLocation(const std::string& a_file, int a_line)
481   std::string file;
504       typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;
600         ::std::make_pair(test_name, CodeLocation(file, line)));
604   bool TestExists(const std::string& test_name) const {
608   const CodeLocation& GetCodeLocation(const std::string& test_name) const {
622   typedef ::std::map<std::string, CodeLocation, std::less<>> RegisteredTestsMap;
649 inline std::string GetPrefixUntilComma(const char* str) {
651   return comma == nullptr ? str : std::string(str, comma);
656 void SplitString(const ::std::string& str, char delimiter,
657                  ::std::vector<::std::string>* dest);
663   static std::string GetName(int i) {
674 void GenerateNamesRecursively(internal::None, std::vector<std::string>*, int) {}
677 void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) {
684 std::vector<std::string> GenerateNames() {
685   std::vector<std::string> result;
706                        const std::vector<std::string>& type_names =
715         (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
746                        const std::vector<std::string>& =
747                            std::vector<std::string>() /*type_names*/) {
767                        const std::vector<std::string>& type_names =
770     std::string test_name =
804                        const std::vector<std::string>& =
805                            std::vector<std::string>() /*type_names*/) {
810 // Returns the current OS stack trace as an std::string.
820 GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(int skip_count);
840 // Helper for declaring std::string within 'if' statement
845   explicit TrueWithString(const std::string& str) : value(str) {}
847   std::string value;
875   typename std::remove_const<typename std::remove_reference<T>::type>::type
879 // that return std::string.
884   static auto CheckDebugString(C*) -> typename std::is_same<
885       std::string, decltype(std::declval<const C>().DebugString())>::type;
887   static std::false_type CheckDebugString(...);
890   static auto CheckShortDebugString(C*) -> typename std::is_same<
891       std::string, decltype(std::declval<const C>().ShortDebugString())>::type;
893   static std::false_type CheckShortDebugString(...);
934           class Iterator = decltype(::std::declval<const C&>().begin()),
935           class = decltype(::std::declval<const C&>().end()),
936           class = decltype(++::std::declval<Iterator&>()),
937           class = decltype(*::std::declval<Iterator>()),
975 struct IsRecursiveContainerImpl<C, false> : public std::false_type {};
983   using value_type = decltype(*std::declval<typename C::const_iterator>());
985       std::is_same<typename std::remove_const<
986                        typename std::remove_reference<value_type>::type>::type,
1121   static_assert(!std::is_const<Element>::value, "Type must not be const");
1122   static_assert(!std::is_reference<Element>::value,
1146 // Backport of std::index_sequence.
1164 // Backport of std::make_index_sequence.
1218       : value(std::forward<Arg>(t)) {}
1233                                                 std::forward<Args>(args))... {}
1246   auto Apply(F&& f) -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
1247     return std::forward<F>(f)(Get<Idx>()...);
1251   auto Apply(F&& f) const -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
1252     return std::forward<F>(f)(Get<Idx>()...);
1256 // Analog to std::tuple but with different tradeoffs.
1258 // elements than std::tuple would. std::tuple has been seen to require an
1276       : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}
1312 namespace std {
1322     : std::integral_constant<size_t, sizeof...(Ts)> {};
1326 }  // namespace std
1380   std::string { "an std::exception-derived error" }
1385   catch (typename std::conditional<                                            \
1386          std::is_same<typename std::remove_cv<typename std::remove_reference<  \
1388                       std::exception>::value,                                  \
1389          const ::testing::internal::NeverThrown&, const std::exception&>::type \
1436   catch (std::exception const& e) {                               \