when:
        def generatedType = generate(SomeTypeWithParameters)

        then:
        generatedType.getMethod("getValues").returnType == List
        generatedType.getMethod("getValues").genericReturnType.actualTypeArguments == [String]

        generatedType.getMethod("getOptional").returnType == Optional

    }

    def "path for dollar var expression ends with first non-property reference"() {
        when:
        buildScript '''
        @Managed
        interface Thing {
            List<String> getValues()
        }
        model {
            thing(Thing) {
                values.addAll(['', '2', '3'])
            }
            tasks {
                echo(Task) {
                    doLast {

        flags, storage_type, expressed_type, scales.getValues<float>()[0],
        zero_points.getValues<int32_t>()[0], storage_type_min,
        storage_type_max);
  } else {
    SmallVector<double> scales_vec;
    SmallVector<int64_t> zero_points_vec;
    for (auto elem : scales.getValues<float>()) scales_vec.push_back(elem);
    for (auto elem : zero_points.getValues<int32_t>())
      zero_points_vec.push_back(elem);

  ASSERT_TRUE(succeeded(dense_attr));
  EXPECT_THAT(dense_attr->getValues<int8_t>(), testing::SizeIs(4));
  EXPECT_EQ(dense_attr->getValues<int8_t>()[0], 1);
  EXPECT_EQ(dense_attr->getValues<int8_t>()[1], 2);
  EXPECT_EQ(dense_attr->getValues<int8_t>()[2], 3);
  EXPECT_EQ(dense_attr->getValues<int8_t>()[3], 4);
}

TEST(GetDenseAttrFromTensorProtoAttrTest, Qint8ToInt8Succeeds) {

        assertEquals("太郎", extractData.getValues("dc:creator")[0]);
        assertEquals("かいしゃ", extractData.getValues("extended-properties:Company")[0]);
        assertEquals("1", extractData.getValues("xmpTPg:NPages")[0]);
        assertEquals("2009-06-26T21:41:00Z", extractData.getValues("dcterms:created")[0]);
        assertEquals("2012-05-18T22:45:00Z", extractData.getValues("dcterms:modified")[0]);

        final PropertyDesc propDesc = beanDesc.getPropertyDesc("hhh");
        // propDesc.setValue(myBean, "2000/11/8 11:22:33");
        propDesc.setValue(myBean, "1/2/24, 12:08 PM");
        assertThat(myBean.getHhh(), is(notNullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testSetCalendarValue() throws Exception {
        final MyBean myBean = new MyBean();

        void notASetterOrGetter();
    }

    interface InvalidParameter2 {
        void setValue()
        String getValue()
    }

    interface InvalidParameter3 {
        void setValue(Integer value)
        String getValue()
    }

    interface InvalidParameter4 {
        void setValue(String value)
    }

    interface InvalidParameter5 {
        String getValue()
    }

    for (int32_t idx = 0; idx < perm1_const.getNumElements(); ++idx) {
      initial_permutation.push_back(idx);
    }
    for (auto perm : perm2_const.getValues<APInt>()) {
      new_permutation.push_back(
          initial_permutation[perm1_const
                                  .getValues<APInt>()[perm.getSExtValue()]
                                  .getSExtValue()]);
    }
  }

  return mlir::DenseElementsAttr::get(

    public File getDestinationDirectory() {
        return destinationDirectory.getValue();
    }

    @Override
    public void setDestinationDirectory(File directory) {
        this.destinationDirectory.setValue(directory);
    }

    @Override
    public StandardJavadocDocletOptions destinationDirectory(File destinationDirectory) {
        setDestinationDirectory(destinationDirectory);
        return this;
    }

  auto type = elements.getType();
  auto elemType = type.getElementType();
  if (elemType.isSignlessInteger(1)) {
    auto vec = llvm::to_vector(
        llvm::map_range(elements.getValues<bool>(),
                        [&](bool value) -> uint8_t { return value ? 1 : 0; }));
    return std::vector<bool>(vec.begin(), vec.end());
  }

  return std::vector<bool>();
}

template <>