class MyTask extends DefaultTask {
                @OutputFiles Set<File> out = new HashSet<File>()

                @TaskAction def exec() {
                    out.each { it.text = 'data' }
                }
            }

            task myTask(type: MyTask) {
                out.addAll([file("out1"), file("out2")])
            }
        """

        when:
        run ':myTask'

        then:

  if (TF_GetCode(s) != TF_OK) return;
  std::vector<TFE_TensorHandle*> unwrapped_outputs;
  unwrapped_outputs.reserve(op_outputs.size());
  for (auto* handle : op_outputs) {
    unwrapped_outputs.push_back(handle);
  }
  for (int i = 0; i < *num_outputs; ++i) {
    auto logged_tensor = std::make_unique<LoggedTensor>(unwrapped_outputs[i]);
    outputs[i] = MakeLoggedTensorHandle(context, dev->device_name,

    def "can serialize and deserialize metadata"() {
        def outputHashes = ImmutableListMultimap.<String, HashCode>builder()
            .putAll("out1", hashCodeFrom(0x1234), hashCodeFrom(0x2345))
            .putAll("out2", hashCodeFrom(0x3456))
            .build()

    for (int i = 0; i < expected_results.size(); ++i) {
      TF_Tensor* out = csession.output_tensor(i);
      ASSERT_TRUE(out != nullptr);
      EXPECT_EQ(TF_INT32, TF_TensorType(out));
      EXPECT_EQ(0, TF_NumDims(out));  // scalar
      ASSERT_EQ(sizeof(int32_t), TF_TensorByteSize(out));
      int32_t* output_contents = static_cast<int32_t*>(TF_TensorData(out));
      EXPECT_EQ(expected_results[i], *output_contents);
    }
  }

                task producer(type: OutputFilesTask) {
                    out1.convention(layout.buildDirectory.file("\${project.name}.out1.jar"))
                    out2.convention(layout.buildDirectory.file("\${project.name}.out2.jar"))
                }

                artifacts {
                    implementation producer.out1
                    implementation producer.out2
                }

        pack output,
            prop("out1", FILE, null),
            prop("out2", DIRECTORY, null)

        then:
        noExceptionThrown()

        when:
        def input = new ByteArrayInputStream(output.toByteArray())
        unpack input,
            prop("out1", FILE, null),
            prop("out2", DIRECTORY, null)

        then:
        noExceptionThrown()
    }

                        f.text = val
                    }
                }
            }

            apply plugin: "base"
            tasks.create("t", CustomTask).paths << "out1" << "out2"
        """

        settingsFile << localCache.localCacheConfiguration() << remoteCache.remoteCacheConfiguration()

        executer.beforeExecute { it.withBuildCacheEnabled() }
    }

	}
	sort.Strings(typedefNames)
	for _, name := range typedefNames {
		def := typedef[name]
		fmt.Fprintf(fgo2, "type %s ", name)
		// We don't have source info for these types, so write them out without source info.
		// Otherwise types would look like:
		//
		// type _Ctype_struct_cb struct {
		// //line :1
		//        on_test *[0]byte
		// //line :1
		// }
		//

Austin Clements <******@****.***> 1683216807 -0400

Laura Kassovic <******@****.***> 1701107622 -0800