Lines Matching refs:Tuple
162 // GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple
172 // Test's own tr1 tuple implementation should be
588 // Determines whether Google Test can use tr1/tuple. You can define
589 // this macro to 0 to prevent Google Test from using tuple (any
590 // feature depending on tuple with be disabled in this mode).
593 // STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
601 // Determines whether Google Test's own tr1 tuple implementation
606 // We use our own TR1 tuple if we aren't sure the user has an
609 // with a TR1 tuple implementation. NVIDIA's CUDA NVCC compiler
611 // compile GCC's tuple implementation. MSVC 2008 (9.0) provides TR1
612 // tuple in a 323 MB Feature Pack download, which we cannot assume the
614 // support TR1 tuple. libc++ only provides std::tuple, in C++11 mode,
621 // C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
638 // tr1/tuple.
643 // pump.py gtest-tuple.h.pump
677 // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
685 // tuple template as a friend (it complains that tuple is redefined). This
693 template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
697 // GTEST_n_TUPLE_(T) is the type of an n-tuple.
698 #define GTEST_0_TUPLE_(T) tuple<>
699 #define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
701 #define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
703 #define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
705 #define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
707 #define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
709 #define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
711 #define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
713 #define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
715 #define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
717 #define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
752 class tuple;
781 // iff k < the number of fields in tuple type T.
782 template <bool kIndexValid, int kIndex, class Tuple>
838 class tuple<> {
840 tuple() {}
841 tuple(const tuple& /* t */) {}
842 tuple& operator=(const tuple& /* t */) { return *this; }
850 tuple() : f0_() {}
852 explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
854 tuple(const tuple& t) : f0_(t.f0_) {}
857 tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
859 tuple& operator=(const tuple& t) { return CopyFrom(t); }
862 tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
869 tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
882 tuple() : f0_(), f1_() {}
884 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
887 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
890 tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
892 tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
894 tuple& operator=(const tuple& t) { return CopyFrom(t); }
897 tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
901 tuple& operator=(const ::std::pair<U0, U1>& p) {
910 tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
925 tuple() : f0_(), f1_(), f2_() {}
927 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
930 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
933 tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
935 tuple& operator=(const tuple& t) { return CopyFrom(t); }
938 tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
945 tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
962 tuple() : f0_(), f1_(), f2_(), f3_() {}
964 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
968 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
971 tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
974 tuple& operator=(const tuple& t) { return CopyFrom(t); }
977 tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
984 tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
1003 tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
1005 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1009 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1013 tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1016 tuple& operator=(const tuple& t) { return CopyFrom(t); }
1019 tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
1026 tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
1047 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
1049 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1054 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1058 tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1061 tuple& operator=(const tuple& t) { return CopyFrom(t); }
1064 tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
1071 tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
1094 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
1096 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1101 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1105 tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1108 tuple& operator=(const tuple& t) { return CopyFrom(t); }
1111 tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
1118 tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
1143 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
1145 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1151 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1155 tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1158 tuple& operator=(const tuple& t) { return CopyFrom(t); }
1161 tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
1168 tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
1195 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
1197 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1203 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1207 tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1210 tuple& operator=(const tuple& t) { return CopyFrom(t); }
1213 tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
1220 tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
1245 class tuple {
1249 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
1252 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1258 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1262 tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1266 tuple& operator=(const tuple& t) { return CopyFrom(t); }
1269 tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
1276 tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
1302 // 6.1.3.2 Tuple creation functions.
1308 inline tuple<> make_tuple() { return tuple<>(); }
1369 // 6.1.3.3 Tuple helper classes.
1371 template <typename Tuple> struct tuple_size;
1428 template <int k, class Tuple>
1431 k < (tuple_size<Tuple>::value), k, Tuple>::type type;
1434 #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
1443 template <class Tuple>
1444 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
1445 Field(Tuple& t) { return t.f0_; } // NOLINT
1447 template <class Tuple>
1448 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
1449 ConstField(const Tuple& t) { return t.f0_; }
1455 template <class Tuple>
1456 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
1457 Field(Tuple& t) { return t.f1_; } // NOLINT
1459 template <class Tuple>
1460 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
1461 ConstField(const Tuple& t) { return t.f1_; }
1467 template <class Tuple>
1468 Tuple))
1469 Field(Tuple& t) { return t.f2_; } // NOLINT
1471 template <class Tuple>
1472 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
1473 ConstField(const Tuple& t) { return t.f2_; }
1479 template <class Tuple>
1480 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
1481 Field(Tuple& t) { return t.f3_; } // NOLINT
1483 template <class Tuple>
1484 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
1485 ConstField(const Tuple& t) { return t.f3_; }
1491 template <class Tuple>
1492 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
1493 Field(Tuple& t) { return t.f4_; } // NOLINT
1495 template <class Tuple>
1496 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
1497 ConstField(const Tuple& t) { return t.f4_; }
1503 template <class Tuple>
1504 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
1505 Field(Tuple& t) { return t.f5_; } // NOLINT
1507 template <class Tuple>
1508 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
1509 ConstField(const Tuple& t) { return t.f5_; }
1515 template <class Tuple>
1516 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
1517 Field(Tuple& t) { return t.f6_; } // NOLINT
1519 template <class Tuple>
1520 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
1521 ConstField(const Tuple& t) { return t.f6_; }
1527 template <class Tuple>
1528 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
1529 Field(Tuple& t) { return t.f7_; } // NOLINT
1531 template <class Tuple>
1532 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
1533 ConstField(const Tuple& t) { return t.f7_; }
1539 template <class Tuple>
1540 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
1541 Field(Tuple& t) { return t.f8_; } // NOLINT
1543 template <class Tuple>
1544 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
1545 ConstField(const Tuple& t) { return t.f8_; }
1551 template <class Tuple>
1552 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
1553 Field(Tuple& t) { return t.f9_; } // NOLINT
1555 template <class Tuple>
1556 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
1557 ConstField(const Tuple& t) { return t.f9_; }
1655 # include <tuple>
1656 // C++11 puts its tuple into the ::std namespace rather than
1657 // ::std::tr1. gtest expects tuple to live in ::std::tr1, so put it there.
1664 using ::std::tuple;
1672 // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
1673 // use STLport's tuple implementation, which unfortunately doesn't
1676 // use its own tuple implementation.
1682 // BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
1684 # include <tuple>
1687 // GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does
1688 // not conform to the TR1 spec, which requires the header to be <tuple>.
1692 // which is #included by <tr1/tuple>, to not compile when RTTI is
1697 # include <tr1/tuple>
1701 # include <tr1/tuple> // NOLINT
1707 # include <tuple> // NOLINT
9269 // // Prints the fields of a tuple tersely to a string vector, one
9270 // // element for each field. Tuple support must be enabled in
9273 // const Tuple& value);
9675 // Overload for ::std::tr1::tuple. Needed for printing function arguments,
9678 // Helper function for printing a tuple. T must be instantiated with
9679 // a tuple type.
9685 // regardless of whether tr1::tuple is implemented using the
9688 inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
9693 void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
9698 void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
9703 void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
9708 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
9713 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
9720 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
9727 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
9734 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
9741 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
9749 const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
9955 // induction on the number of tuple fields. The idea is that
9957 // fields in tuple t, and can be defined in terms of
9963 // Prints the first N fields of a tuple.
9964 template <typename Tuple>
9965 static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
9968 UniversalPrinter<typename ::std::tr1::tuple_element<N - 1, Tuple>::type>
9972 // Tersely prints the first N fields of a tuple to a string vector,
9974 template <typename Tuple>
9975 static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
9986 template <typename Tuple>
9987 static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
9989 template <typename Tuple>
9990 static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
9999 template <typename Tuple>
10000 static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
10001 UniversalPrinter<typename ::std::tr1::tuple_element<0, Tuple>::type>::
10005 template <typename Tuple>
10006 static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
10013 // Helper function for printing a tuple. T must be instantiated with
10014 // a tuple type.
10023 // Prints the fields of a tuple tersely to a string vector, one
10026 template <typename Tuple>
10027 Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
10029 TuplePrefixPrinter< ::std::tr1::tuple_size<Tuple>::value>::
10661 // by the maximum arity of the implementation of tr1::tuple which is
13776 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2> > {
13778 typedef ::std::tr1::tuple<T1, T2> ParamType;
13891 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3> > {
13893 typedef ::std::tr1::tuple<T1, T2, T3> ParamType;
14023 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4> > {
14025 typedef ::std::tr1::tuple<T1, T2, T3, T4> ParamType;
14174 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5> > {
14176 typedef ::std::tr1::tuple<T1, T2, T3, T4, T5> ParamType;
14342 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5,
14345 typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> ParamType;
14528 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
14531 typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
14731 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
14734 typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
14953 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
14956 typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
15192 : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
15195 typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType;
15457 operator ParamGenerator< ::std::tr1::tuple<T1, T2> >() const {
15458 return ParamGenerator< ::std::tr1::tuple<T1, T2> >(
15479 operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >() const {
15480 return ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >(
15504 operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >() const {
15505 return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >(
15531 operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >() const {
15532 return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >(
15562 operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >() const {
15563 return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >(
15595 operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
15597 return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> >(
15633 operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7,
15635 return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
15674 operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
15676 return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
15718 operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
15720 return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
16799 // tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
16803 // by the maximum number of elements in the tuple implementation used by Google
16809 // the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
16810 // tuple("dog", BLACK), and tuple("dog", WHITE):
16814 // : public testing::TestWithParam<tuple<const char*, Color> > {...};
16826 // : public testing::TestWithParam<tuple<bool, bool> > {
16828 // // Assigns external_flag_1 and external_flag_2 values from the tuple.
