private final String parentPropertyName;
    private final String typeName;

    public DefaultTypeValidationData(String pluginId, String propertyName, String parentPropertyName, String typeName) {
        this.pluginId = pluginId;
        this.propertyName = propertyName;
        this.parentPropertyName = parentPropertyName;
        this.typeName = typeName;
    }

    @Override
    public String getPluginId() {

  EXPECT_EQ(tensor.dims(), 0);
  EXPECT_EQ(tensor.dtype(), dtype);
  EXPECT_EQ(*reinterpret_cast<typename TypeParam::type*>(tensor.data()), 42);
  EXPECT_EQ(tensor.num_bytes(), sizeof(typename TypeParam::type));
  EXPECT_EQ(tensor.num_elements(), 1);
}

template <typename T>
class Construct1DTensorHandleTest : public ::testing::Test {};
TYPED_TEST_SUITE(Construct1DTensorHandleTest, SimpleTypes);

	if !mp.IsMap() {
		t.Error("map type not identifiable as map")
	}
	if mp.TypeName() != "map" {
		t.Errorf("got %s, wanted map", mp.TypeName())
	}
	if mp.DefaultValue() == nil {
		t.Error("got nil zero value for map type")
	}
	if mp.KeyType.TypeName() != "string" {
		t.Errorf("got %s, wanted key type of string", mp.KeyType.TypeName())
	}
	if mp.ElemType.TypeName() != "int" {

                    });
                }

                public static abstract class Extension {
                    private $typeName value;
                    public $typeName getInputProperty() { return value; }
                    public void setInputProperty($typeName value) { this.value = value; }
                }

                public static abstract class SomeTask extends ${ConventionTask.name} {

// 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(

  Renderer &CodeLines(const string &text);
  template <typename... Args>
  Renderer CodeLines(absl::string_view text, const Args &...args) {
    return CodeLines(absl::Substitute(text, args...));
  }

  // Indent and append a C++ statement.
  // Note: do *not* include a trailing semicolon in the statement text.
  Renderer &Statement(const string &text);
  template <typename... Args>

    }

    public MetaDataParseException(String typeName, ExternalResource resource, Throwable cause) {
        super(String.format("Could not parse %s %s", typeName, resource.getDisplayName()), cause);
    }

    public MetaDataParseException(String typeName, ExternalResource resource, String details, Throwable cause) {
        super(String.format("Could not parse %s %s: %s", typeName, resource.getDisplayName(), details), cause);
    }

package p

import _ "unsafe"

//go:linkname nonexistent nonexistent

//go:linkname constant constant
const constant = 42

//go:linkname typename typename

        return PRIMITIVE_TYPES_DEFAULT_VALUES_AS_STRING.getOrDefault(type, "null");
    }

    /**
     * Converts an ASM {@link Type} to a JavaPoet {@link TypeName}.
     */
    public static TypeName typeName(Type type) {
        if (type.equals(Type.VOID_TYPE)) {
            return ClassName.VOID;
        }
        if (type.equals(Type.BOOLEAN_TYPE)) {
            return ClassName.BOOLEAN;

    static TaskDetails of(Path path, String typeName, @Nullable String description) {
        return new DefaultTaskDetails(path, typeName, description);
    }

    final class DefaultTaskDetails implements TaskDetails {
        private final Path path;
        private final String typeName;
        @Nullable private final String description;

        private DefaultTaskDetails(Path path, String typeName, @Nullable String description) {