reflect.TypeOf(([]byte)("")):  true,
	reflect.TypeOf((string)("")):  true,
	reflect.TypeOf((bool)(false)): true,
	reflect.TypeOf((byte)(0)):     true,
	reflect.TypeOf((rune)(0)):     true,
	reflect.TypeOf((float32)(0)):  true,
	reflect.TypeOf((float64)(0)):  true,
	reflect.TypeOf((int)(0)):      true,
	reflect.TypeOf((int8)(0)):     true,
	reflect.TypeOf((int16)(0)):    true,

  typedef T3 type;
};

template <GTEST_10_TYPENAMES_(T)>
struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
  typedef T4 type;
};

template <GTEST_10_TYPENAMES_(T)>
struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
  typedef T5 type;
};

template <GTEST_10_TYPENAMES_(T)>
struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
  typedef T6 type;
};

template <GTEST_10_TYPENAMES_(T)>

}

func test14reflect2() {
	f := reflect.TypeOf(T6{}).Method(0).Func.Interface().(func(T6))
	defer f(T6{})
	panic(14)
}

// function created by reflect.MakeFunc

func reflectFunc(args []reflect.Value) (results []reflect.Value) {
	mustRecoverBody(doubleRecover(), recover(), recover(), 15)
	return nil
}

func test15() {
	f := reflect.MakeFunc(reflect.TypeOf((func())(nil)), reflectFunc).Interface().(func())

			}
		}
	}
	return list, nil
}

var (
	// objectSliceType is the type of a slice of Objects
	objectSliceType        = reflect.TypeOf([]runtime.Object{})
	objectType             = reflect.TypeOf((*runtime.Object)(nil)).Elem()
	rawExtensionObjectType = reflect.TypeOf(runtime.RawExtension{})
)

// LenList returns the length of this list or 0 if it is not a list.
func LenList(list runtime.Object) int {

	_, err = csiMapper.SetUpDevice()
	if err == nil {
		t.Errorf("test should fail, but no error occurred")
	} else if reflect.TypeOf(transientError) != reflect.TypeOf(err) {
		t.Fatalf("expected exitError type: %v got: %v (%v)", reflect.TypeOf(transientError), reflect.TypeOf(err), err)
	}
}

func TestBlockMapperMapPodDevice(t *testing.T) {
	plug, tmpDir := newTestPlugin(t, nil)
	defer os.RemoveAll(tmpDir)

	lv := NewListValue()
	none, err := lv.ConvertToNative(reflect.TypeOf([]interface{}{}))
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(none, []interface{}{}) {
		t.Errorf("got %v, wanted empty list", none)
	}
	lv.Append(testValue(t, 1, "first"))
	one, err := lv.ConvertToNative(reflect.TypeOf([]string{}))
	oneList := one.([]string)
	if err != nil {
		t.Fatal(err)
	}

 *
 *  @version 2.3.77
 *  @website http://formvalidator.net/
 *  @author Victor Jonsson, http://victorjonsson.se
 *  @license MIT
 */

                else -> false
            }

        fun createFor(typeRef: FirResolvedTypeRef): TypeQualifier? {
            if (!typeRef.isPresentInSource) return null

            val wholeClassId = typeRef.resolvedClassId ?: return null
            val psi = typeRef.psi as? KtTypeReference ?: return null

	}
	key := key{pkg: pkg, t: reflect.TypeOf(ptr)}
	s.mu.Lock()
	defer s.mu.Unlock()
	if v, ok := s.m[key]; ok {
		reflect.ValueOf(ptr).Elem().Set(reflect.ValueOf(v).Elem())
		return true
	}
	return false
}

// ExportPackageFact implements analysis.Pass.ExportPackageFact.
func (s *Set) ExportPackageFact(fact analysis.Fact) {
	key := key{pkg: s.pkg, t: reflect.TypeOf(fact)}
	s.mu.Lock()

			cArgs[i] = fmt.Sprintf("(uint8Pair_t){%d,1}", i)
		} else {
			cArgs[i] = fmt.Sprintf("%d", i+1)
		}
	}
	fmt.Fprintf(w, `
typedef uintptr_t %s (*%s)(%s);
uintptr_t %s(%s f) {
	return f(%s);
}
	`, attr, typename, strings.Join(cTypes, ","), funcname, typename, strings.Join(cArgs, ","))
}

func (f cbFunc) testOne(t *testing.T, dll *syscall.DLL, cdecl bool, cb uintptr) {