}

// find all the files that look like counter files or reports
// that need to be uploaded. (There may be unexpected leftover files
// and uploading is supposed to be idempotent.)
func (u *uploader) findWork() work {
	localdir, uploaddir := u.dir.LocalDir(), u.dir.UploadDir()
	var ans work
	fis, err := os.ReadDir(localdir)
	if err != nil {

    }

    @Issue([
        "https://github.com/gradle/gradle/issues/21857",
        "https://github.com/gradle/gradle/issues/22375"
    ])
    def "signing configuration should be idempotent"() {
        given:
        buildFile << """
            configurations {
                meta
            }

            signing {
                ${signingConfiguration()}

            "type": "string"
          },
          "generation": {
            "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.",

		if err := resource.Unmarshal(data); err != nil {
			t.Fatalf("Failed to unmarshal output: '%v': %v", input, err)
		}
		if !reflect.DeepEqual(input, resource) {
			t.Errorf("Marshal->Unmarshal is not idempotent: '%v' vs '%v'", input, resource)
		}
	}

   *   <li>uniqueness: unless {@code a.isEmpty()}, {@code ContiguousSet.create(a,
   *       domain).equals(ContiguousSet.create(b, domain))} implies {@code
   *       a.canonical(domain).equals(b.canonical(domain))}
   *   <li>idempotence: {@code a.canonical(domain).canonical(domain).equals(a.canonical(domain))}
   * </ul>
   *
   * <p>Furthermore, this method guarantees that the range returned will be one of the following
   * canonical forms:
   *

            "type": "string"
          },
          "generation": {
            "description": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.",

   *   <li>uniqueness: unless {@code a.isEmpty()}, {@code ContiguousSet.create(a,
   *       domain).equals(ContiguousSet.create(b, domain))} implies {@code
   *       a.canonical(domain).equals(b.canonical(domain))}
   *   <li>idempotence: {@code a.canonical(domain).canonical(domain).equals(a.canonical(domain))}
   * </ul>
   *
   * <p>Furthermore, this method guarantees that the range returned will be one of the following
   * canonical forms:
   *

// a plugin that are executed with a NewGoRoutineMap which
// prevents more than one operation from being triggered on the same socket path.
//
// These operations should be idempotent (for example, RegisterPlugin should
// still succeed if the plugin is already registered, etc.). However,
// they depend on the plugin handlers (for each plugin type) to implement this
// behavior.
//

	sort.Interface
	Push(x any) // add x as element Len()
	Pop() any   // remove and return element Len() - 1.
}

// Init establishes the heap invariants required by the other routines in this package.
// Init is idempotent with respect to the heap invariants
// and may be called whenever the heap invariants may have been invalidated.
// The complexity is O(n) where n = h.Len().
func Init(h Interface) {
	// heapify
	n := h.Len()

    // Replace the outer involutions output with inner's input.
    return argumentOp->getOperand(0);
  }

  return {};
}

}  // namespace detail

// This class adds property that the operation is idempotent.
// This means a unary to unary operation "f" that satisfies f(f(x)) = f(x),
// or a binary operation "g" that satisfies g(x, x) = x.
template <typename ConcreteType>