}

struct CustomQuantizationT : public ::flatbuffers::NativeTable {
  typedef CustomQuantization TableType;
  std::vector<uint8_t> custom{};
};

struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CustomQuantizationT NativeTableType;
  typedef CustomQuantizationBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {

        typeOf((Type) String) == new TypeOf<String>() {}
        parameterizedTypeOf(new TypeOf<List<?>>() {}, typeOf(String)) == new TypeOf<List<String>>() {}
        parameterizedTypeOf(new TypeOf<Map<?, ?>>() {}, typeOf(String), typeOf(Integer)) == new TypeOf<Map<String, Integer>>() {}
    }

    def "componentType is null on non-array types"() {
        expect:
        typeOf(String).componentType == null

			switch n.Op {
			case token.EQL, token.NEQ: // TODO: more cases. This is enough for the cftype fix.
				if typeof[n.X] != "" && typeof[n.Y] == "" {
					typeof[n.Y] = typeof[n.X]
				}
				if typeof[n.X] == "" && typeof[n.Y] != "" {
					typeof[n.X] = typeof[n.Y]
				}
			}
		}
	}
	walkBeforeAfter(f, before, after)
}

// Convert between function type strings and lists of types.

 * Licensed MIT © Zeno Rocha
 */

TF_CAPI_EXPORT extern uint64_t TFE_GetContextId(TFE_Context* ctx);

// -----------------------------------------------------------------------------
// Cancellation APIs.

typedef struct TFE_CancellationManager TFE_CancellationManager;
typedef int64_t TFE_CancellationToken;
typedef struct TFE_CancelCallback {
  void (*callback)(void* context);
  void* context;
} TFE_CancelCallback;

        val extensions = mock<ExtensionContainer>()
        doNothing().`when`(extensions).add(any<TypeOf<SomeExtension<*>>>(), any(), any())

        val instance = SomeExtension("some")
        extensions.add<SomeExtension<String>>("name", instance)

        inOrder(extensions) {
            verify(extensions).add(typeOf<SomeExtension<String>>(), "name", instance)
            verifyNoMoreInteractions()
        }
    }

	// exercising https://golang.org/issues/17594
	reflect.TypeOf(os.Stdout).Elem()
	runtime.GC()
	depBase.V = depBase.F() + 1

	var c *C
	if reflect.TypeOf(F).Out(0) != reflect.TypeOf(c) {
		panic("bad reflection results, see golang.org/issue/18252")
	}

	sp := reflect.New(reflect.TypeOf(slicePtr).Elem())
	s := sp.Interface()

	if reflect.TypeOf(s) != reflect.TypeOf(slicePtr) {

 */
package org.gradle.kotlin.dsl

import org.gradle.api.reflect.TypeOf


/**
 * Creates an instance of [TypeOf] for the given parameterized type.
 *
 * @param T the type
 * @return the [TypeOf] that captures the generic type of the given parameterized type
 */
inline fun <reified T> typeOf(): TypeOf<T> =

template <typename T>
class FooTest : public testing::Test {
 public:
  ...
  typedef std::list<T> List;
  static T shared_;
  T value_;
};

// Next, associate a list of types with the test case, which will be
// repeated for each type in the list.  The typedef is necessary for
// the macro to parse correctly.
typedef testing::Types<char, int, unsigned int> MyTypes;
TYPED_TEST_CASE(FooTest, MyTypes);

	// This function returns false if the name does not refer to a known object type.
	Resolve(name string) (TypeRef, bool)
}

// TypeRef refers an object type that can be looked up for its fields.
type TypeRef interface {
	ref.Type

	// CELType wraps the TypeRef to be a type that is understood by CEL.
	CELType() *types.Type

	// Field finds the field by the field name, or false if the field is not known.