}

// Checks for PutObjectPart arguments validity, also validates if bucket exists.
func checkPutObjectPartArgs(ctx context.Context, bucket, object, uploadID string) error {
	return checkMultipartObjectArgs(ctx, bucket, object, uploadID)
}

// Checks for ListParts arguments validity, also validates if bucket exists.
func checkListPartsArgs(ctx context.Context, bucket, object, uploadID string) error {

        !(
          variables.isTelemetry && (
            (has(object.spec.tracing) ? object.spec.tracing : {}).exists(t, has(t.useRequestIdForTraceSampling)) ||
            (has(object.spec.metrics) ? object.spec.metrics : {}).exists(m, has(m.reportingInterval)) ||
            (has(object.spec.accessLogging) ? object.spec.accessLogging : {}).exists(l, has(l.filter))
          )
        )
---
apiVersion: admissionregistration.k8s.io/v1

            if ((webinfPath != null) && Files.exists(Paths.get(webinfPath))) {
                return Paths.get(webinfPath, names);
            }
        } catch (final Throwable e) {
            // ignore
        }
        final String webinfBase = root + base;
        if (Files.exists(Paths.get(webinfBase))) {
            return Paths.get(webinfBase, names);
        }

        }

        if (outputFile.exists()) {
            if (logger.isDebugEnabled()) {
                logger.debug("The thumbnail file exists: {}", outputFile.getAbsolutePath());
            }
            return true;
        }

        final File parentFile = outputFile.getParentFile();
        if (!parentFile.exists()) {
            parentFile.mkdirs();
        }

    public void assertFileExistence(File dir, String filename, boolean shouldExist) {
        File file = new File(dir, filename);

        if (shouldExist) {
            assertTrue(file.exists());
        } else {
            assertFalse(file.exists());
        }
    }

    public void assertFileContents(File dir, String filename, String contentsTest, String encoding) throws IOException {

                boolean exists = installed.stream().map(this::getArtifactFromMap)
                        .anyMatch(a -> a.getName().equals(target.getName()) && a.getVersion().equals(target.getVersion()));
                if (!exists) {
                    ThreadUtil.sleep(500);
                    continue;
                }
                assertTrue(exists);
                done = true;
                break;

                .globalSettingsSource(
                        globalSettingsPath != null && Files.exists(globalSettingsPath)
                                ? Source.fromPath(globalSettingsPath)
                                : null)
                .projectSettingsSource(
                        projectSettingsPath != null && Files.exists(projectSettingsPath)
                                ? Source.fromPath(projectSettingsPath)

        assertNull(
                updateCheckManager.readLastUpdated(touchFile, updateCheckManager.getRepositoryKey(remoteRepository)));

        assertFalse(updateCheckManager.getTouchfile(a).exists());
    }

    @Test
    void testMissingArtifact() throws Exception {
        ArtifactRepository remoteRepository = remoteRepository();

        ArtifactRepository localRepository = localRepository();

                .globalToolchainsSource(
                        globalToolchainsPath != null && Files.exists(globalToolchainsPath)
                                ? Source.fromPath(globalToolchainsPath)
                                : null)
                .userToolchainsSource(
                        userToolchainsPath != null && Files.exists(userToolchainsPath)
                                ? Source.fromPath(userToolchainsPath)

	for _, target := range targets {
		if _, ok := list.targets[target.ID()]; ok {
			return fmt.Errorf("target %v already exists", target.ID())
		}
		list.targets[target.ID()] = target
	}

	return nil
}

// Exists - checks whether target by target ID exists or not.
func (list *TargetList) Exists(id TargetID) bool {
	list.RLock()
	defer list.RUnlock()

	_, found := list.targets[id]
	return found
}