Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

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