echo "verified sitea-> COMPLETED, siteb-> REPLICA"
fi

if diff -pruN <(./mc stat --json sitea/bucket/hosts | jq .) <(./mc stat --json sitec/bucket/hosts | jq .) | grep -q 'COMPLETED\|REPLICA'; then
	echo "verified sitea-> COMPLETED, sitec-> REPLICA"
fi

echo "Verifying the metadata difference between source and target"

# tests are not tested by unit tests already. This is useful for verifying some
# runtime behavior, but the majority of runtime tests should be TFLite side and
# invariants only verified in the converter/compiler.

load("//tensorflow:tensorflow.default.bzl", "filegroup")
load("//tensorflow/compiler/mlir:glob_lit_test.bzl", "glob_lit_tests")

	Long: `
Verify checks that the dependencies of the current module,
which are stored in a local downloaded source cache, have not been
modified since being downloaded. If all the modules are unmodified,
verify prints "all modules verified." Otherwise it reports which
modules have been changed and causes 'go mod' to exit with a
non-zero status.

See https://golang.org/ref/mod#go-mod-verify for more about 'go mod verify'.
	`,
	Run: runVerify,
}

// tag::custom-task-implementation[]
import org.gradle.api.tasks.options.Option;

public class UrlVerify extends DefaultTask {
    private String url;

    @Option(option = "url", description = "Configures the URL to be verified.")
    public void setUrl(String url) {
        this.url = url;
    }

    @Input
    public String getUrl() {
        return url;
    }

    @TaskAction
    public void verify() {

				"-y",
			}
			istioCtl.InvokeOrFail(t, installCmd)

			verifyCmd := []string{
				"verify-install",
			}
			out, _ := istioCtl.InvokeOrFail(t, verifyCmd)
			if !strings.Contains(out, "verified successfully") {
				t.Fatalf("verify-install failed: %v", out)
			}
		})

        this.entry = entry;
    }

    @Override
    public void missingKey(String keyId) {
        ignoredKeys.add(keyId);
        entry.missing();
    }

    @Override
    public void verified(PGPPublicKey key, boolean trusted) {
        String keyId = Fingerprint.of(key).toString();
        entry.addVerifiedKey(keyId);
    }

    @Override
    public void failed(PGPPublicKey key) {

}

// A Verifiers is a collection of known verifier keys.
type Verifiers interface {
	// Verifier returns the Verifier associated with the key
	// identified by the name and hash.
	// If the name, hash pair is unknown, Verifier should return
	// an UnknownVerifierError.
	Verifier(name string, hash uint32) (Verifier, error)
}

        assertTrue(cache.asMap().containsKey(entry.getKey()));
        assertTrue(cache.asMap().containsValue(entry.getValue()));
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey()));
      }
      assertEquals(WARMUP_SIZE, cache.stats().missCount());
      checkValidState(cache);
    }
  }

	}

	if err = checkPathLength(dirPath); err != nil {
		return err
	}

	if err = reliableRemoveAll(dirPath); err != nil {
		switch {
		case isSysErrNotDir(err):
			// File path cannot be verified since one of
			// the parents is a file.
			return errFileAccessDenied
		case isSysErrPathNotFound(err):
			// This is a special case should be handled only for
			// windows, because windows API does not return "not a

     * and the resolution result must exactly match the set of locked dependencies.
     *
     * If {@code false}, each locked dependency is added a regular (lenient) constraint,
     * and the resolution result is not verified against the set of locked dependencies.
     *
     * @return {@code true} if lock state was found, {@code false} otherwise
     */
    boolean mustValidateLockState();

    /**