Subversion Repositories s80186

$$ -*- mode: c++; -*-

$var n = 50  $$ Maximum length of type lists we want to support.

// 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: wan@google.com (Zhanyong Wan)

// Type utilities needed for implementing typed and type-parameterized

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

//

// Currently we support at most $n types in a list, and at most $n

// type-parameterized tests in one type-parameterized test case.

// Please contact googletestframework@googlegroups.com if you need

// more.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_

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

// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using

// libstdc++ (which is where cxxabi.h comes from).

# if GTEST_HAS_CXXABI_H_

#  include 

# elif defined(__HP_aCC)

#  include 

# endif  // GTEST_HASH_CXXABI_H_

namespace testing {

namespace internal {

// GetTypeName() returns a human-readable name of type T.

// NB: This function is also used in Google Mock, so don't move it inside of

// the typed-test-only section below.

template 

std::string GetTypeName() {

# if GTEST_HAS_RTTI

  const char* const name = typeid(T).name();

#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)

  int status = 0;

  // gcc's implementation of typeid(T).name() mangles the type name,

  // so we have to demangle it.

#   if GTEST_HAS_CXXABI_H_

  using abi::__cxa_demangle;

#   endif  // GTEST_HAS_CXXABI_H_

  char* const readable_name = __cxa_demangle(name, 0, 0, &status);

  const std::string name_str(status == 0 ? readable_name : name);

  free(readable_name);

  return name_str;

#  else

  return name;

#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC

# else

  return "";

# endif  // GTEST_HAS_RTTI

}

#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P

// AssertyTypeEq::type is defined iff T1 and T2 are the same

// type.  This can be used as a compile-time assertion to ensure that

// two types are equal.

template 

struct AssertTypeEq;

template 

struct AssertTypeEq {

  typedef bool type;

};

// A unique type used as the default value for the arguments of class

// template Types.  This allows us to simulate variadic templates

// (e.g. Types, Type, and etc), which C++ doesn't

// support directly.

struct None {};

// The following family of struct and struct templates are used to

// represent type lists.  In particular, TypesN

// represents a type list with N types (T1, T2, ..., and TN) in it.

// Except for Types0, every struct in the family has two member types:

// Head for the first type in the list, and Tail for the rest of the

// list.

// The empty type list.

struct Types0 {};

// Type lists of length 1, 2, 3, and so on.

template 

struct Types1 {

  typedef T1 Head;

  typedef Types0 Tail;

};

$range i 2..n

$for i [[

$range j 1..i

$range k 2..i

template <$for j, [[typename T$j]]>

struct Types$i {

  typedef T1 Head;

  typedef Types$(i-1)<$for k, [[T$k]]> Tail;

};

]]

}  // namespace internal

// We don't want to require the users to write TypesN<...> directly,

// as that would require them to count the length.  Types<...> is much

// easier to write, but generates horrible messages when there is a

// compiler error, as gcc insists on printing out each template

// argument, even if it has the default value (this means Types

// will appear as Types in the compiler

// errors).

//

// Our solution is to combine the best part of the two approaches: a

// user would write Types, and Google Test will translate

// that to TypesN internally to make error messages

// readable.  The translation is done by the 'type' member of the

// Types template.

$range i 1..n

template <$for i, [[typename T$i = internal::None]]>

struct Types {

  typedef internal::Types$n<$for i, [[T$i]]> type;

};

template <>

struct Types<$for i, [[internal::None]]> {

  typedef internal::Types0 type;

};

$range i 1..n-1

$for i [[

$range j 1..i

$range k i+1..n

template <$for j, [[typename T$j]]>

struct Types<$for j, [[T$j]]$for k[[, internal::None]]> {

  typedef internal::Types$i<$for j, [[T$j]]> type;

};

]]

namespace internal {

# define GTEST_TEMPLATE_ template  class

// The template "selector" struct TemplateSel is used to

// represent Tmpl, which must be a class template with one type

// parameter, as a type.  TemplateSel::Bind::type is defined

// as the type Tmpl.  This allows us to actually instantiate the

// template "selected" by TemplateSel.

//

// This trick is necessary for simulating typedef for class templates,

// which C++ doesn't support directly.

template 

struct TemplateSel {

  template 

  struct Bind {

    typedef Tmpl type;

  };

};

# define GTEST_BIND_(TmplSel, T) \

  TmplSel::template Bind::type

// A unique struct template used as the default value for the

// arguments of class template Templates.  This allows us to simulate

// variadic templates (e.g. Templates, Templates,

// and etc), which C++ doesn't support directly.

template 

struct NoneT {};

// The following family of struct and struct templates are used to

// represent template lists.  In particular, TemplatesN

// TN> represents a list of N templates (T1, T2, ..., and TN).  Except

// for Templates0, every struct in the family has two member types:

// Head for the selector of the first template in the list, and Tail

// for the rest of the list.

// The empty template list.

struct Templates0 {};

// Template lists of length 1, 2, 3, and so on.

template 

struct Templates1 {

  typedef TemplateSel Head;

  typedef Templates0 Tail;

};

$range i 2..n

$for i [[

$range j 1..i

$range k 2..i

template <$for j, [[GTEST_TEMPLATE_ T$j]]>

struct Templates$i {

  typedef TemplateSel Head;

  typedef Templates$(i-1)<$for k, [[T$k]]> Tail;

};

]]

// We don't want to require the users to write TemplatesN<...> directly,

// as that would require them to count the length.  Templates<...> is much

// easier to write, but generates horrible messages when there is a

// compiler error, as gcc insists on printing out each template

// argument, even if it has the default value (this means Templates

// will appear as Templates in the compiler

// errors).

//

// Our solution is to combine the best part of the two approaches: a

// user would write Templates, and Google Test will translate

// that to TemplatesN internally to make error messages

// readable.  The translation is done by the 'type' member of the

// Templates template.

$range i 1..n

template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]>

struct Templates {

  typedef Templates$n<$for i, [[T$i]]> type;

};

template <>

struct Templates<$for i, [[NoneT]]> {

  typedef Templates0 type;

};

$range i 1..n-1

$for i [[

$range j 1..i

$range k i+1..n

template <$for j, [[GTEST_TEMPLATE_ T$j]]>

struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> {

  typedef Templates$i<$for j, [[T$j]]> type;

};

]]

// The TypeList template makes it possible to use either a single type

// or a Types<...> list in TYPED_TEST_CASE() and

// INSTANTIATE_TYPED_TEST_CASE_P().

template 

struct TypeList {

  typedef Types1 type;

};

$range i 1..n

template <$for i, [[typename T$i]]>

struct TypeList > {

  typedef typename Types<$for i, [[T$i]]>::type type;

};

#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P

}  // namespace internal

}  // namespace testing

#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_