Subversion Repositories s80186

// This file was GENERATED by command:

//     pump.py gtest-param-util-generated.h.pump

// DO NOT EDIT BY HAND!!!

// Copyright 2008 Google Inc.

// All Rights Reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Author: vladl@google.com (Vlad Losev)

// Type and function utilities for implementing parameterized tests.

// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!

//

// Currently Google Test supports at most 50 arguments in Values,

// and at most 10 arguments in Combine. Please contact

// googletestframework@googlegroups.com if you need more.

// Please note that the number of arguments to Combine is limited

// by the maximum arity of the implementation of tuple which is

// currently set at 10.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_

// scripts/fuse_gtest.py depends on gtest's own header being #included

// *unconditionally*.  Therefore these #includes cannot be moved

// inside #if GTEST_HAS_PARAM_TEST.

#include "gtest/internal/gtest-param-util.h"

#include "gtest/internal/gtest-port.h"

#if GTEST_HAS_PARAM_TEST

namespace testing {

// Forward declarations of ValuesIn(), which is implemented in

// include/gtest/gtest-param-test.h.

template <typename ForwardIterator>

internal::ParamGenerator<

  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>

ValuesIn(ForwardIterator begin, ForwardIterator end);

template <typename T, size_t N>

internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);

template <class Container>

internal::ParamGenerator<typename Container::value_type> ValuesIn(

    const Container& container);

namespace internal {

// Used in the Values() function to provide polymorphic capabilities.

template <typename T1>

class ValueArray1 {

 public:

  explicit ValueArray1(T1 v1) : v1_(v1) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray1& other);

  const T1 v1_;

};

template <typename T1, typename T2>

class ValueArray2 {

 public:

  ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray2& other);

  const T1 v1_;

  const T2 v2_;

};

template <typename T1, typename T2, typename T3>

class ValueArray3 {

 public:

  ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray3& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

};

template <typename T1, typename T2, typename T3, typename T4>

class ValueArray4 {

 public:

  ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),

      v4_(v4) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray4& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5>

class ValueArray5 {

 public:

  ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),

      v4_(v4), v5_(v5) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray5& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6>

class ValueArray6 {

 public:

  ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),

      v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray6& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7>

class ValueArray7 {

 public:

  ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),

      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray7& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8>

class ValueArray8 {

 public:

  ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,

      T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray8& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9>

class ValueArray9 {

 public:

  ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,

      T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray9& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9, typename T10>

class ValueArray10 {

 public:

  ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9), v10_(v10) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_), static_cast<T>(v10_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray10& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11>

class ValueArray11 {

 public:

  ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),

      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray11& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12>

class ValueArray12 {

 public:

  ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),

      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),

        static_cast<T>(v12_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray12& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13>

class ValueArray13 {

 public:

  ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),

      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),

      v12_(v12), v13_(v13) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),

        static_cast<T>(v12_), static_cast<T>(v13_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray13& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14>

class ValueArray14 {

 public:

  ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),

      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),

      v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),

        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray14& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15>

class ValueArray15 {

 public:

  ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),

      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),

      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),

        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),

        static_cast<T>(v15_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray15& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16>

class ValueArray16 {

 public:

  ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),

      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),

      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),

      v16_(v16) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),

        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),

        static_cast<T>(v15_), static_cast<T>(v16_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray16& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

};

template <typename T1, typename T2, typename T3, typename T4, typename T5,

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17>

class ValueArray17 {

 public:

  ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,

      T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),

      v15_(v15), v16_(v16), v17_(v17) {}

  template <typename T>

  operator ParamGenerator<T>() const {

    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),

        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),

        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),