name: Notify Translations

on:
  pull_request_target:
    types:
      - labeled
      - closed
  workflow_dispatch:
    inputs:
      number:
        description: PR number
        required: true
      debug_enabled:
        description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
        required: false
        default: 'false'

jobs:
  notify-translations:

    }

    @Override
    public void execute(T subject, List<?> inputs) {
        Closure<?> copy = (Closure<?>) closure.clone();
        copy.setResolveStrategy(Closure.DELEGATE_FIRST);
        copy.setDelegate(subject);

        if (closure.getMaximumNumberOfParameters() == 0) {
            copy.call();
        } else {
            Object[] argList = new Object[inputs.size() + 1];
            argList[0] = subject;
            int i = 1;

package etcd

import (
	"reflect"
	"testing"
)

// TestParseEndpoints - tests parseEndpoints function with valid and invalid inputs.
func TestParseEndpoints(t *testing.T) {
	testCases := []struct {
		s         string
		endpoints []string
		secure    bool
		success   bool
	}{
		// Invalid inputs
		{"https://localhost:2379,http://localhost:2380", nil, false, false},
		{",,,", nil, false, false},
		{"", nil, false, false},

     */
    ImmutableList<ImplementationSnapshot> getAdditionalImplementations();

    /**
     * The non-file inputs.
     */
    ImmutableSortedMap<String, ValueSnapshot> getInputProperties();

    /**
     * The file inputs.
     */
    ImmutableSortedMap<String, ? extends FileCollectionFingerprint> getInputFileProperties();

        given:
        file("input.txt").createFile()
        buildFile << """
            task custom {
                inputs.file("input.txt")
                outputs.file("output.txt")
                doLast {
                    file("output.txt").text = "output"
                }
            }
        """
        propertiesFile << "org.gradle.caching=true"

  ~XlaLocalLaunchBase() override = default;

  void ComputeAsync(OpKernelContext* ctx, DoneCallback done) override;

 protected:
  // Indexes of compile-time constant inputs
  const std::vector<int> constants_;
  // Indexes of resource inputs
  const std::vector<int> resources_;

  const NameAttrList function_;
  const XlaPlatformInfo platform_info_;

  bool has_ref_vars_;
};

tasks.register("showTestClasspath") {
    val testCompileClasspath: FileCollection = configurations.testCompileClasspath.get()
    val testRuntimeClasspath: FileCollection = configurations.testRuntimeClasspath.get()
    inputs.files(testCompileClasspath)
    inputs.files(testRuntimeClasspath)
    doLast {
        println(testCompileClasspath.files.map(File::getName))
        println(testRuntimeClasspath.files.map(File::getName))
    }

// RUN: odml-to-stablehlo-opt %s -tfl-parse-stablehlo-ops | FileCheck %s

module {
func.func @main(%arg0: tensor<2xi32>) -> tensor<2xi32> attributes {tf.entry_function = {inputs = "arg0", outputs = "tfl.custom1"}} {
  %0 = "tfl.custom"(%arg0, %arg0) {custom_code = "stablehlo.add", custom_option = #tfl<const_bytes : "0x00000100002401">} : (tensor<2xi32>, tensor<2xi32>) -> tensor<2xi32>

tasks.register("showTestClasspath") {
    FileCollection testCompileClasspath = configurations.testCompileClasspath
    FileCollection testRuntimeClasspath = configurations.testRuntimeClasspath
    inputs.files(testCompileClasspath)
    inputs.files(testRuntimeClasspath)
    doLast {
        println testCompileClasspath.files.name
        println testRuntimeClasspath.files.name
    }

LogicalResult FoldOperation(OpBuilder& builder, Operation* op,
                            SmallVector<Value>& results) {
  SmallVector<ElementsAttr> inputs;
  for (auto operand : op->getOperands()) {
    auto preceding_const_op = operand.getDefiningOp<TF::ConstOp>();
    if (preceding_const_op) {
      inputs.push_back(preceding_const_op.getValue());
      continue;
    }

    Operation* preceding_op = operand.getDefiningOp();