Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // This file was GENERATED by command:
  2. //     pump.py gtest-tuple.h.pump
  3. // DO NOT EDIT BY HAND!!!
  4.  
  5. // Copyright 2009 Google Inc.
  6. // All Rights Reserved.
  7. //
  8. // Redistribution and use in source and binary forms, with or without
  9. // modification, are permitted provided that the following conditions are
  10. // met:
  11. //
  12. //     * Redistributions of source code must retain the above copyright
  13. // notice, this list of conditions and the following disclaimer.
  14. //     * Redistributions in binary form must reproduce the above
  15. // copyright notice, this list of conditions and the following disclaimer
  16. // in the documentation and/or other materials provided with the
  17. // distribution.
  18. //     * Neither the name of Google Inc. nor the names of its
  19. // contributors may be used to endorse or promote products derived from
  20. // this software without specific prior written permission.
  21. //
  22. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33. //
  34. // Author: wan@google.com (Zhanyong Wan)
  35.  
  36. // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
  37.  
  38. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
  39. #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
  40.  
  41. #include <utility>  // For ::std::pair.
  42.  
  43. // The compiler used in Symbian has a bug that prevents us from declaring the
  44. // tuple template as a friend (it complains that tuple is redefined).  This
  45. // hack bypasses the bug by declaring the members that should otherwise be
  46. // private as public.
  47. // Sun Studio versions < 12 also have the above bug.
  48. #if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
  49. # define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
  50. #else
  51. # define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
  52.     template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
  53.    private:
  54. #endif
  55.  
  56. // GTEST_n_TUPLE_(T) is the type of an n-tuple.
  57. #define GTEST_0_TUPLE_(T) tuple<>
  58. #define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
  59.     void, void, void>
  60. #define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
  61.     void, void, void>
  62. #define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
  63.     void, void, void>
  64. #define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
  65.     void, void, void>
  66. #define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
  67.     void, void, void>
  68. #define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
  69.     void, void, void>
  70. #define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
  71.     void, void, void>
  72. #define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
  73.     T##7, void, void>
  74. #define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
  75.     T##7, T##8, void>
  76. #define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
  77.     T##7, T##8, T##9>
  78.  
  79. // GTEST_n_TYPENAMES_(T) declares a list of n typenames.
  80. #define GTEST_0_TYPENAMES_(T)
  81. #define GTEST_1_TYPENAMES_(T) typename T##0
  82. #define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
  83. #define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
  84. #define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  85.     typename T##3
  86. #define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  87.     typename T##3, typename T##4
  88. #define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  89.     typename T##3, typename T##4, typename T##5
  90. #define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  91.     typename T##3, typename T##4, typename T##5, typename T##6
  92. #define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  93.     typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
  94. #define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  95.     typename T##3, typename T##4, typename T##5, typename T##6, \
  96.     typename T##7, typename T##8
  97. #define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  98.     typename T##3, typename T##4, typename T##5, typename T##6, \
  99.     typename T##7, typename T##8, typename T##9
  100.  
  101. // In theory, defining stuff in the ::std namespace is undefined
  102. // behavior.  We can do this as we are playing the role of a standard
  103. // library vendor.
  104. namespace std {
  105. namespace tr1 {
  106.  
  107. template <typename T0 = void, typename T1 = void, typename T2 = void,
  108.     typename T3 = void, typename T4 = void, typename T5 = void,
  109.     typename T6 = void, typename T7 = void, typename T8 = void,
  110.     typename T9 = void>
  111. class tuple;
  112.  
  113. // Anything in namespace gtest_internal is Google Test's INTERNAL
  114. // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
  115. namespace gtest_internal {
  116.  
  117. // ByRef<T>::type is T if T is a reference; otherwise it's const T&.
  118. template <typename T>
  119. struct ByRef { typedef const T& type; };  // NOLINT
  120. template <typename T>
  121. struct ByRef<T&> { typedef T& type; };  // NOLINT
  122.  
  123. // A handy wrapper for ByRef.
  124. #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
  125.  
  126. // AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
  127. // is the same as tr1::add_reference<T>::type.
  128. template <typename T>
  129. struct AddRef { typedef T& type; };  // NOLINT
  130. template <typename T>
  131. struct AddRef<T&> { typedef T& type; };  // NOLINT
  132.  
  133. // A handy wrapper for AddRef.
  134. #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
  135.  
  136. // A helper for implementing get<k>().
  137. template <int k> class Get;
  138.  
  139. // A helper for implementing tuple_element<k, T>.  kIndexValid is true
  140. // iff k < the number of fields in tuple type T.
  141. template <bool kIndexValid, int kIndex, class Tuple>
  142. struct TupleElement;
  143.  
  144. template <GTEST_10_TYPENAMES_(T)>
  145. struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
  146.   typedef T0 type;
  147. };
  148.  
  149. template <GTEST_10_TYPENAMES_(T)>
  150. struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
  151.   typedef T1 type;
  152. };
  153.  
  154. template <GTEST_10_TYPENAMES_(T)>
  155. struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
  156.   typedef T2 type;
  157. };
  158.  
  159. template <GTEST_10_TYPENAMES_(T)>
  160. struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
  161.   typedef T3 type;
  162. };
  163.  
  164. template <GTEST_10_TYPENAMES_(T)>
  165. struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
  166.   typedef T4 type;
  167. };
  168.  
  169. template <GTEST_10_TYPENAMES_(T)>
  170. struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
  171.   typedef T5 type;
  172. };
  173.  
  174. template <GTEST_10_TYPENAMES_(T)>
  175. struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
  176.   typedef T6 type;
  177. };
  178.  
  179. template <GTEST_10_TYPENAMES_(T)>
  180. struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
  181.   typedef T7 type;
  182. };
  183.  
  184. template <GTEST_10_TYPENAMES_(T)>
  185. struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
  186.   typedef T8 type;
  187. };
  188.  
  189. template <GTEST_10_TYPENAMES_(T)>
  190. struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
  191.   typedef T9 type;
  192. };
  193.  
  194. }  // namespace gtest_internal
  195.  
  196. template <>
  197. class tuple<> {
  198.  public:
  199.   tuple() {}
  200.   tuple(const tuple& /* t */)  {}
  201.   tuple& operator=(const tuple& /* t */) { return *this; }
  202. };
  203.  
  204. template <GTEST_1_TYPENAMES_(T)>
  205. class GTEST_1_TUPLE_(T) {
  206.  public:
  207.   template <int k> friend class gtest_internal::Get;
  208.  
  209.   tuple() : f0_() {}
  210.  
  211.   explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
  212.  
  213.   tuple(const tuple& t) : f0_(t.f0_) {}
  214.  
  215.   template <GTEST_1_TYPENAMES_(U)>
  216.   tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
  217.  
  218.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  219.  
  220.   template <GTEST_1_TYPENAMES_(U)>
  221.   tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
  222.     return CopyFrom(t);
  223.   }
  224.  
  225.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  226.  
  227.   template <GTEST_1_TYPENAMES_(U)>
  228.   tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
  229.     f0_ = t.f0_;
  230.     return *this;
  231.   }
  232.  
  233.   T0 f0_;
  234. };
  235.  
  236. template <GTEST_2_TYPENAMES_(T)>
  237. class GTEST_2_TUPLE_(T) {
  238.  public:
  239.   template <int k> friend class gtest_internal::Get;
  240.  
  241.   tuple() : f0_(), f1_() {}
  242.  
  243.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
  244.       f1_(f1) {}
  245.  
  246.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
  247.  
  248.   template <GTEST_2_TYPENAMES_(U)>
  249.   tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
  250.   template <typename U0, typename U1>
  251.   tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
  252.  
  253.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  254.  
  255.   template <GTEST_2_TYPENAMES_(U)>
  256.   tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
  257.     return CopyFrom(t);
  258.   }
  259.   template <typename U0, typename U1>
  260.   tuple& operator=(const ::std::pair<U0, U1>& p) {
  261.     f0_ = p.first;
  262.     f1_ = p.second;
  263.     return *this;
  264.   }
  265.  
  266.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  267.  
  268.   template <GTEST_2_TYPENAMES_(U)>
  269.   tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
  270.     f0_ = t.f0_;
  271.     f1_ = t.f1_;
  272.     return *this;
  273.   }
  274.  
  275.   T0 f0_;
  276.   T1 f1_;
  277. };
  278.  
  279. template <GTEST_3_TYPENAMES_(T)>
  280. class GTEST_3_TUPLE_(T) {
  281.  public:
  282.   template <int k> friend class gtest_internal::Get;
  283.  
  284.   tuple() : f0_(), f1_(), f2_() {}
  285.  
  286.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  287.       GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
  288.  
  289.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
  290.  
  291.   template <GTEST_3_TYPENAMES_(U)>
  292.   tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
  293.  
  294.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  295.  
  296.   template <GTEST_3_TYPENAMES_(U)>
  297.   tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
  298.     return CopyFrom(t);
  299.   }
  300.  
  301.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  302.  
  303.   template <GTEST_3_TYPENAMES_(U)>
  304.   tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
  305.     f0_ = t.f0_;
  306.     f1_ = t.f1_;
  307.     f2_ = t.f2_;
  308.     return *this;
  309.   }
  310.  
  311.   T0 f0_;
  312.   T1 f1_;
  313.   T2 f2_;
  314. };
  315.  
  316. template <GTEST_4_TYPENAMES_(T)>
  317. class GTEST_4_TUPLE_(T) {
  318.  public:
  319.   template <int k> friend class gtest_internal::Get;
  320.  
  321.   tuple() : f0_(), f1_(), f2_(), f3_() {}
  322.  
  323.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  324.       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
  325.       f3_(f3) {}
  326.  
  327.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
  328.  
  329.   template <GTEST_4_TYPENAMES_(U)>
  330.   tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  331.       f3_(t.f3_) {}
  332.  
  333.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  334.  
  335.   template <GTEST_4_TYPENAMES_(U)>
  336.   tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
  337.     return CopyFrom(t);
  338.   }
  339.  
  340.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  341.  
  342.   template <GTEST_4_TYPENAMES_(U)>
  343.   tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
  344.     f0_ = t.f0_;
  345.     f1_ = t.f1_;
  346.     f2_ = t.f2_;
  347.     f3_ = t.f3_;
  348.     return *this;
  349.   }
  350.  
  351.   T0 f0_;
  352.   T1 f1_;
  353.   T2 f2_;
  354.   T3 f3_;
  355. };
  356.  
  357. template <GTEST_5_TYPENAMES_(T)>
  358. class GTEST_5_TUPLE_(T) {
  359.  public:
  360.   template <int k> friend class gtest_internal::Get;
  361.  
  362.   tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
  363.  
  364.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  365.       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
  366.       GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
  367.  
  368.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  369.       f4_(t.f4_) {}
  370.  
  371.   template <GTEST_5_TYPENAMES_(U)>
  372.   tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  373.       f3_(t.f3_), f4_(t.f4_) {}
  374.  
  375.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  376.  
  377.   template <GTEST_5_TYPENAMES_(U)>
  378.   tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
  379.     return CopyFrom(t);
  380.   }
  381.  
  382.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  383.  
  384.   template <GTEST_5_TYPENAMES_(U)>
  385.   tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
  386.     f0_ = t.f0_;
  387.     f1_ = t.f1_;
  388.     f2_ = t.f2_;
  389.     f3_ = t.f3_;
  390.     f4_ = t.f4_;
  391.     return *this;
  392.   }
  393.  
  394.   T0 f0_;
  395.   T1 f1_;
  396.   T2 f2_;
  397.   T3 f3_;
  398.   T4 f4_;
  399. };
  400.  
  401. template <GTEST_6_TYPENAMES_(T)>
  402. class GTEST_6_TUPLE_(T) {
  403.  public:
  404.   template <int k> friend class gtest_internal::Get;
  405.  
  406.   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
  407.  
  408.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  409.       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  410.       GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
  411.       f5_(f5) {}
  412.  
  413.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  414.       f4_(t.f4_), f5_(t.f5_) {}
  415.  
  416.   template <GTEST_6_TYPENAMES_(U)>
  417.   tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  418.       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
  419.  
  420.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  421.  
  422.   template <GTEST_6_TYPENAMES_(U)>
  423.   tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
  424.     return CopyFrom(t);
  425.   }
  426.  
  427.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  428.  
  429.   template <GTEST_6_TYPENAMES_(U)>
  430.   tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
  431.     f0_ = t.f0_;
  432.     f1_ = t.f1_;
  433.     f2_ = t.f2_;
  434.     f3_ = t.f3_;
  435.     f4_ = t.f4_;
  436.     f5_ = t.f5_;
  437.     return *this;
  438.   }
  439.  
  440.   T0 f0_;
  441.   T1 f1_;
  442.   T2 f2_;
  443.   T3 f3_;
  444.   T4 f4_;
  445.   T5 f5_;
  446. };
  447.  
  448. template <GTEST_7_TYPENAMES_(T)>
  449. class GTEST_7_TUPLE_(T) {
  450.  public:
  451.   template <int k> friend class gtest_internal::Get;
  452.  
  453.   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
  454.  
  455.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  456.       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  457.       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
  458.       f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
  459.  
  460.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  461.       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
  462.  
  463.   template <GTEST_7_TYPENAMES_(U)>
  464.   tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  465.       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
  466.  
  467.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  468.  
  469.   template <GTEST_7_TYPENAMES_(U)>
  470.   tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
  471.     return CopyFrom(t);
  472.   }
  473.  
  474.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  475.  
  476.   template <GTEST_7_TYPENAMES_(U)>
  477.   tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
  478.     f0_ = t.f0_;
  479.     f1_ = t.f1_;
  480.     f2_ = t.f2_;
  481.     f3_ = t.f3_;
  482.     f4_ = t.f4_;
  483.     f5_ = t.f5_;
  484.     f6_ = t.f6_;
  485.     return *this;
  486.   }
  487.  
  488.   T0 f0_;
  489.   T1 f1_;
  490.   T2 f2_;
  491.   T3 f3_;
  492.   T4 f4_;
  493.   T5 f5_;
  494.   T6 f6_;
  495. };
  496.  
  497. template <GTEST_8_TYPENAMES_(T)>
  498. class GTEST_8_TUPLE_(T) {
  499.  public:
  500.   template <int k> friend class gtest_internal::Get;
  501.  
  502.   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
  503.  
  504.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  505.       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  506.       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
  507.       GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
  508.       f5_(f5), f6_(f6), f7_(f7) {}
  509.  
  510.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  511.       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
  512.  
  513.   template <GTEST_8_TYPENAMES_(U)>
  514.   tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  515.       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
  516.  
  517.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  518.  
  519.   template <GTEST_8_TYPENAMES_(U)>
  520.   tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
  521.     return CopyFrom(t);
  522.   }
  523.  
  524.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  525.  
  526.   template <GTEST_8_TYPENAMES_(U)>
  527.   tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
  528.     f0_ = t.f0_;
  529.     f1_ = t.f1_;
  530.     f2_ = t.f2_;
  531.     f3_ = t.f3_;
  532.     f4_ = t.f4_;
  533.     f5_ = t.f5_;
  534.     f6_ = t.f6_;
  535.     f7_ = t.f7_;
  536.     return *this;
  537.   }
  538.  
  539.   T0 f0_;
  540.   T1 f1_;
  541.   T2 f2_;
  542.   T3 f3_;
  543.   T4 f4_;
  544.   T5 f5_;
  545.   T6 f6_;
  546.   T7 f7_;
  547. };
  548.  
  549. template <GTEST_9_TYPENAMES_(T)>
  550. class GTEST_9_TUPLE_(T) {
  551.  public:
  552.   template <int k> friend class gtest_internal::Get;
  553.  
  554.   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
  555.  
  556.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  557.       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  558.       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
  559.       GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
  560.       f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
  561.  
  562.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  563.       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
  564.  
  565.   template <GTEST_9_TYPENAMES_(U)>
  566.   tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  567.       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
  568.  
  569.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  570.  
  571.   template <GTEST_9_TYPENAMES_(U)>
  572.   tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
  573.     return CopyFrom(t);
  574.   }
  575.  
  576.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  577.  
  578.   template <GTEST_9_TYPENAMES_(U)>
  579.   tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
  580.     f0_ = t.f0_;
  581.     f1_ = t.f1_;
  582.     f2_ = t.f2_;
  583.     f3_ = t.f3_;
  584.     f4_ = t.f4_;
  585.     f5_ = t.f5_;
  586.     f6_ = t.f6_;
  587.     f7_ = t.f7_;
  588.     f8_ = t.f8_;
  589.     return *this;
  590.   }
  591.  
  592.   T0 f0_;
  593.   T1 f1_;
  594.   T2 f2_;
  595.   T3 f3_;
  596.   T4 f4_;
  597.   T5 f5_;
  598.   T6 f6_;
  599.   T7 f7_;
  600.   T8 f8_;
  601. };
  602.  
  603. template <GTEST_10_TYPENAMES_(T)>
  604. class tuple {
  605.  public:
  606.   template <int k> friend class gtest_internal::Get;
  607.  
  608.   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
  609.       f9_() {}
  610.  
  611.   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  612.       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  613.       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
  614.       GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
  615.       f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
  616.  
  617.   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  618.       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
  619.  
  620.   template <GTEST_10_TYPENAMES_(U)>
  621.   tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  622.       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
  623.       f9_(t.f9_) {}
  624.  
  625.   tuple& operator=(const tuple& t) { return CopyFrom(t); }
  626.  
  627.   template <GTEST_10_TYPENAMES_(U)>
  628.   tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
  629.     return CopyFrom(t);
  630.   }
  631.  
  632.   GTEST_DECLARE_TUPLE_AS_FRIEND_
  633.  
  634.   template <GTEST_10_TYPENAMES_(U)>
  635.   tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
  636.     f0_ = t.f0_;
  637.     f1_ = t.f1_;
  638.     f2_ = t.f2_;
  639.     f3_ = t.f3_;
  640.     f4_ = t.f4_;
  641.     f5_ = t.f5_;
  642.     f6_ = t.f6_;
  643.     f7_ = t.f7_;
  644.     f8_ = t.f8_;
  645.     f9_ = t.f9_;
  646.     return *this;
  647.   }
  648.  
  649.   T0 f0_;
  650.   T1 f1_;
  651.   T2 f2_;
  652.   T3 f3_;
  653.   T4 f4_;
  654.   T5 f5_;
  655.   T6 f6_;
  656.   T7 f7_;
  657.   T8 f8_;
  658.   T9 f9_;
  659. };
  660.  
  661. // 6.1.3.2 Tuple creation functions.
  662.  
  663. // Known limitations: we don't support passing an
  664. // std::tr1::reference_wrapper<T> to make_tuple().  And we don't
  665. // implement tie().
  666.  
  667. inline tuple<> make_tuple() { return tuple<>(); }
  668.  
  669. template <GTEST_1_TYPENAMES_(T)>
  670. inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
  671.   return GTEST_1_TUPLE_(T)(f0);
  672. }
  673.  
  674. template <GTEST_2_TYPENAMES_(T)>
  675. inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
  676.   return GTEST_2_TUPLE_(T)(f0, f1);
  677. }
  678.  
  679. template <GTEST_3_TYPENAMES_(T)>
  680. inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
  681.   return GTEST_3_TUPLE_(T)(f0, f1, f2);
  682. }
  683.  
  684. template <GTEST_4_TYPENAMES_(T)>
  685. inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  686.     const T3& f3) {
  687.   return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
  688. }
  689.  
  690. template <GTEST_5_TYPENAMES_(T)>
  691. inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  692.     const T3& f3, const T4& f4) {
  693.   return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
  694. }
  695.  
  696. template <GTEST_6_TYPENAMES_(T)>
  697. inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  698.     const T3& f3, const T4& f4, const T5& f5) {
  699.   return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
  700. }
  701.  
  702. template <GTEST_7_TYPENAMES_(T)>
  703. inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  704.     const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
  705.   return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
  706. }
  707.  
  708. template <GTEST_8_TYPENAMES_(T)>
  709. inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  710.     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
  711.   return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
  712. }
  713.  
  714. template <GTEST_9_TYPENAMES_(T)>
  715. inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  716.     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
  717.     const T8& f8) {
  718.   return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
  719. }
  720.  
  721. template <GTEST_10_TYPENAMES_(T)>
  722. inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  723.     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
  724.     const T8& f8, const T9& f9) {
  725.   return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
  726. }
  727.  
  728. // 6.1.3.3 Tuple helper classes.
  729.  
  730. template <typename Tuple> struct tuple_size;
  731.  
  732. template <GTEST_0_TYPENAMES_(T)>
  733. struct tuple_size<GTEST_0_TUPLE_(T) > {
  734.   static const int value = 0;
  735. };
  736.  
  737. template <GTEST_1_TYPENAMES_(T)>
  738. struct tuple_size<GTEST_1_TUPLE_(T) > {
  739.   static const int value = 1;
  740. };
  741.  
  742. template <GTEST_2_TYPENAMES_(T)>
  743. struct tuple_size<GTEST_2_TUPLE_(T) > {
  744.   static const int value = 2;
  745. };
  746.  
  747. template <GTEST_3_TYPENAMES_(T)>
  748. struct tuple_size<GTEST_3_TUPLE_(T) > {
  749.   static const int value = 3;
  750. };
  751.  
  752. template <GTEST_4_TYPENAMES_(T)>
  753. struct tuple_size<GTEST_4_TUPLE_(T) > {
  754.   static const int value = 4;
  755. };
  756.  
  757. template <GTEST_5_TYPENAMES_(T)>
  758. struct tuple_size<GTEST_5_TUPLE_(T) > {
  759.   static const int value = 5;
  760. };
  761.  
  762. template <GTEST_6_TYPENAMES_(T)>
  763. struct tuple_size<GTEST_6_TUPLE_(T) > {
  764.   static const int value = 6;
  765. };
  766.  
  767. template <GTEST_7_TYPENAMES_(T)>
  768. struct tuple_size<GTEST_7_TUPLE_(T) > {
  769.   static const int value = 7;
  770. };
  771.  
  772. template <GTEST_8_TYPENAMES_(T)>
  773. struct tuple_size<GTEST_8_TUPLE_(T) > {
  774.   static const int value = 8;
  775. };
  776.  
  777. template <GTEST_9_TYPENAMES_(T)>
  778. struct tuple_size<GTEST_9_TUPLE_(T) > {
  779.   static const int value = 9;
  780. };
  781.  
  782. template <GTEST_10_TYPENAMES_(T)>
  783. struct tuple_size<GTEST_10_TUPLE_(T) > {
  784.   static const int value = 10;
  785. };
  786.  
  787. template <int k, class Tuple>
  788. struct tuple_element {
  789.   typedef typename gtest_internal::TupleElement<
  790.       k < (tuple_size<Tuple>::value), k, Tuple>::type type;
  791. };
  792.  
  793. #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
  794.  
  795. // 6.1.3.4 Element access.
  796.  
  797. namespace gtest_internal {
  798.  
  799. template <>
  800. class Get<0> {
  801.  public:
  802.   template <class Tuple>
  803.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
  804.   Field(Tuple& t) { return t.f0_; }  // NOLINT
  805.  
  806.   template <class Tuple>
  807.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
  808.   ConstField(const Tuple& t) { return t.f0_; }
  809. };
  810.  
  811. template <>
  812. class Get<1> {
  813.  public:
  814.   template <class Tuple>
  815.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
  816.   Field(Tuple& t) { return t.f1_; }  // NOLINT
  817.  
  818.   template <class Tuple>
  819.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
  820.   ConstField(const Tuple& t) { return t.f1_; }
  821. };
  822.  
  823. template <>
  824. class Get<2> {
  825.  public:
  826.   template <class Tuple>
  827.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
  828.   Field(Tuple& t) { return t.f2_; }  // NOLINT
  829.  
  830.   template <class Tuple>
  831.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
  832.   ConstField(const Tuple& t) { return t.f2_; }
  833. };
  834.  
  835. template <>
  836. class Get<3> {
  837.  public:
  838.   template <class Tuple>
  839.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
  840.   Field(Tuple& t) { return t.f3_; }  // NOLINT
  841.  
  842.   template <class Tuple>
  843.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
  844.   ConstField(const Tuple& t) { return t.f3_; }
  845. };
  846.  
  847. template <>
  848. class Get<4> {
  849.  public:
  850.   template <class Tuple>
  851.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
  852.   Field(Tuple& t) { return t.f4_; }  // NOLINT
  853.  
  854.   template <class Tuple>
  855.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
  856.   ConstField(const Tuple& t) { return t.f4_; }
  857. };
  858.  
  859. template <>
  860. class Get<5> {
  861.  public:
  862.   template <class Tuple>
  863.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
  864.   Field(Tuple& t) { return t.f5_; }  // NOLINT
  865.  
  866.   template <class Tuple>
  867.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
  868.   ConstField(const Tuple& t) { return t.f5_; }
  869. };
  870.  
  871. template <>
  872. class Get<6> {
  873.  public:
  874.   template <class Tuple>
  875.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
  876.   Field(Tuple& t) { return t.f6_; }  // NOLINT
  877.  
  878.   template <class Tuple>
  879.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
  880.   ConstField(const Tuple& t) { return t.f6_; }
  881. };
  882.  
  883. template <>
  884. class Get<7> {
  885.  public:
  886.   template <class Tuple>
  887.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
  888.   Field(Tuple& t) { return t.f7_; }  // NOLINT
  889.  
  890.   template <class Tuple>
  891.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
  892.   ConstField(const Tuple& t) { return t.f7_; }
  893. };
  894.  
  895. template <>
  896. class Get<8> {
  897.  public:
  898.   template <class Tuple>
  899.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
  900.   Field(Tuple& t) { return t.f8_; }  // NOLINT
  901.  
  902.   template <class Tuple>
  903.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
  904.   ConstField(const Tuple& t) { return t.f8_; }
  905. };
  906.  
  907. template <>
  908. class Get<9> {
  909.  public:
  910.   template <class Tuple>
  911.   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
  912.   Field(Tuple& t) { return t.f9_; }  // NOLINT
  913.  
  914.   template <class Tuple>
  915.   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
  916.   ConstField(const Tuple& t) { return t.f9_; }
  917. };
  918.  
  919. }  // namespace gtest_internal
  920.  
  921. template <int k, GTEST_10_TYPENAMES_(T)>
  922. GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
  923. get(GTEST_10_TUPLE_(T)& t) {
  924.   return gtest_internal::Get<k>::Field(t);
  925. }
  926.  
  927. template <int k, GTEST_10_TYPENAMES_(T)>
  928. GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_10_TUPLE_(T)))
  929. get(const GTEST_10_TUPLE_(T)& t) {
  930.   return gtest_internal::Get<k>::ConstField(t);
  931. }
  932.  
  933. // 6.1.3.5 Relational operators
  934.  
  935. // We only implement == and !=, as we don't have a need for the rest yet.
  936.  
  937. namespace gtest_internal {
  938.  
  939. // SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
  940. // first k fields of t1 equals the first k fields of t2.
  941. // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
  942. // k1 != k2.
  943. template <int kSize1, int kSize2>
  944. struct SameSizeTuplePrefixComparator;
  945.  
  946. template <>
  947. struct SameSizeTuplePrefixComparator<0, 0> {
  948.   template <class Tuple1, class Tuple2>
  949.   static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
  950.     return true;
  951.   }
  952. };
  953.  
  954. template <int k>
  955. struct SameSizeTuplePrefixComparator<k, k> {
  956.   template <class Tuple1, class Tuple2>
  957.   static bool Eq(const Tuple1& t1, const Tuple2& t2) {
  958.     return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
  959.         ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
  960.   }
  961. };
  962.  
  963. }  // namespace gtest_internal
  964.  
  965. template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
  966. inline bool operator==(const GTEST_10_TUPLE_(T)& t,
  967.                        const GTEST_10_TUPLE_(U)& u) {
  968.   return gtest_internal::SameSizeTuplePrefixComparator<
  969.       tuple_size<GTEST_10_TUPLE_(T) >::value,
  970.       tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
  971. }
  972.  
  973. template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
  974. inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
  975.                        const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
  976.  
  977. // 6.1.4 Pairs.
  978. // Unimplemented.
  979.  
  980. }  // namespace tr1
  981. }  // namespace std
  982.  
  983. #undef GTEST_0_TUPLE_
  984. #undef GTEST_1_TUPLE_
  985. #undef GTEST_2_TUPLE_
  986. #undef GTEST_3_TUPLE_
  987. #undef GTEST_4_TUPLE_
  988. #undef GTEST_5_TUPLE_
  989. #undef GTEST_6_TUPLE_
  990. #undef GTEST_7_TUPLE_
  991. #undef GTEST_8_TUPLE_
  992. #undef GTEST_9_TUPLE_
  993. #undef GTEST_10_TUPLE_
  994.  
  995. #undef GTEST_0_TYPENAMES_
  996. #undef GTEST_1_TYPENAMES_
  997. #undef GTEST_2_TYPENAMES_
  998. #undef GTEST_3_TYPENAMES_
  999. #undef GTEST_4_TYPENAMES_
  1000. #undef GTEST_5_TYPENAMES_
  1001. #undef GTEST_6_TYPENAMES_
  1002. #undef GTEST_7_TYPENAMES_
  1003. #undef GTEST_8_TYPENAMES_
  1004. #undef GTEST_9_TYPENAMES_
  1005. #undef GTEST_10_TYPENAMES_
  1006.  
  1007. #undef GTEST_DECLARE_TUPLE_AS_FRIEND_
  1008. #undef GTEST_BY_REF_
  1009. #undef GTEST_ADD_REF_
  1010. #undef GTEST_TUPLE_ELEMENT_
  1011.  
  1012. #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
  1013.