assert response.json() == "Listen to the Bar Fighters"
    response = client.put("/get-or-create-task/bar")
    assert response.status_code == 201, response.text

  private File testDir;
  private File tempDir;

  private final Set<File> filesToDelete = new HashSet<>();

  @Override
  protected void tearDown() {
    for (File file : filesToDelete) {
      if (file.exists()) {
        delete(file);
      }
    }
    filesToDelete.clear();
  }

  private File getTestDir() throws IOException {
    if (testDir != null) {
      return testDir;
    }

        for (final UrlQueue<Long> urlInQueue : urlQueueList) {
            if (url.equals(urlInQueue.getUrl())) {
                if (logger.isDebugEnabled()) {
                    logger.debug("URL exists in a queue: {}", url);
                }
                return false;
            }
        }

        // check it in result

tasks = {"foo": "Listen to the Bar Fighters"}


@app.put("/get-or-create-task/{task_id}", status_code=200)
def get_or_create_task(task_id: str, response: Response):
    if task_id not in tasks:
        tasks[task_id] = "This didn't exist before"
        response.status_code = status.HTTP_201_CREATED

fun Directory.parentOrRoot(): Directory = if (this.file("version.txt").asFile.exists()) {
    this
} else {
    val parent = dir("..")
    when {
        parent.file("version.txt").asFile.exists() -> parent
        this == parent -> error("Cannot find 'version.txt' file in root of repository")
        else -> parent.parentOrRoot()
    }
}

  // Restricts the check for exit codes to the container with the
  // specified name. When null, the rule applies to all containers.
  // When specified, it should match one the container or initContainer
  // names in the pod template.
  // +optional
  optional string containerName = 1;

  // Represents the relationship between the container exit code(s) and the
  // specified values. Containers completed with success (exit code 0) are

	fmt.Fprintf(w, "\tfile:line\n")
}

func usage() {
	printUsage(os.Stderr)
	os.Exit(2)
}

func main() {
	log.SetFlags(0)
	log.SetPrefix("addr2line: ")
	counter.Open()

	// pprof expects this behavior when checking for addr2line
	if len(os.Args) > 1 && os.Args[1] == "--help" {
		printUsage(os.Stdout)
		os.Exit(0)
	}

	flag.Usage = usage
	flag.Parse()
	counter.Inc("addr2line/invocations")

                try (final InputStream in = response.getContentAsStream()) {
                    CopyUtil.copy(in, tempFile);
                } catch (final Exception e1) {
                    if (tempFile != null && tempFile.exists() && !tempFile.delete()) {
                        logger.warn("Failed to delete {}", tempFile.getAbsolutePath());
                    }
                    throw e1;
                }

                    crawlerContext.decrementAndGetAccessCount();
                    if (urlQueueService.visited(urlQueue)) {
                        // document already exists
                        if (logger.isDebugEnabled()) {
                            logger.debug("{} exists.", urlQueue.getUrl(), e);
                        }
                        return;
                    }
                    throw e;
                }

*   `tf.cond` emits a StatelessIf op if the branch functions are stateless and
    do not touch any resources.
*   `tf.cond`, `tf.while` and `if` and `while` in AutoGraph now accept a
    nonscalar predicate if has a single element. This does not affect non-V2
    control flow.
*   `tf.while_loop` emits a StatelessWhile op if the cond and body functions are