override fun action(taskPath: String, taskResult: TaskOperationResult) {
        if (taskResult is TaskSuccessResult && !taskResult.isFromCache && !taskResult.isUpToDate) {
            println("CACHE_MISS in task $taskPath")
            cacheMiss.set(true)
        }
    }
}


/**
 *  We monitor some tasks in non-seed builds. If a task executed in a non-seed build, we think it as "CACHE_MISS".
 */

  companion object {
    val logger: Logger = Logger.getLogger(Http2Server::class.java.name)

    @JvmStatic
    fun main(args: Array<String>) {
      if (args.size != 1 || args[0].startsWith("-")) {
        println("Usage: Http2Server <base directory>")
        return
      }
      val server =
        Http2Server(
          File(args[0]),
          localhost().sslContext().socketFactory,
        )
      server.run()

            off = ( off & 0xFFFF ) - converter;
            off = start + off;
            e.remark = readString( buffer, off, 128, false );

            if (log.level >= 4)
                log.println( e );
        }

        return bufferIndex - start;
    }
    public String toString() {
        return new String( "NetShareEnumResponse[" +
                super.toString() +

        assertTrue(set.size() == 4, "Set size should be 4, is " + set.size());

        while (iter.hasNext()) {
            Artifact artifact = (Artifact) iter.next();
            System.out.println("Artifact: " + artifact.getDependencyConflictId() + " " + artifact.getVersion()
                    + " Optional=" + (artifact.isOptional() ? "true" : "false"));
            assertTrue(

    public int run(String[] args) throws IOException {
        try (Invoker<R> invoker = createInvoker()) {
            return invoker.invoke(parseArguments(args));
        } catch (ParserException e) {
            System.err.println(e.getMessage());
            return 1;
        } catch (InvokerException e) {
            return 1;
        } finally {
            if (classWorldManaged) {
                classWorld.close();
            }

			if extracted {
				return keepFileErr{errors.New("multiple inspect.zip streams found")}
			}
			_, err := io.Copy(w, stream)
			if err != nil {
				return fmt.Errorf("reading inspect stream: %w", err)
			}
			fmt.Println(okMsg)
			extracted = true
			continue
		}
		if err := stream.Skip(); err != nil {
			return fmt.Errorf("stream skip: %w", err)
		}
	}

	d := bytes.NewReader([]byte("Hello, World"))
	n, err := clnt.PutObject(context.Background(), "my-bucketname", "my-objectname", d, d.Size(), minio.PutObjectOptions{})
	if err != nil {
		log.Fatalln(err)
	}

	log.Println("Uploaded", "my-objectname", " of size: ", n, "Successfully.")

        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

  public static void main(String... args) throws Exception {
    new RequestBodyCompression().run();
  }

  }

  @AfterExperiment
  void tearDown() {
    double req = requests.get();
    double hit = req - misses.get();

    // Currently, this is going into /dev/null, but I'll fix that
    System.out.println("hit rate: " + hit / req);
  }

  // for proper distributions later:
  // import JSci.maths.statistics.ProbabilityDistribution;
  // int key = (int) dist.inverse(random.nextDouble());

                """
                package org.apache.maven.samples.sample;

                public class App {
                    public static void main(String... args) {
                        System.out.println("Hello World!");
                    }
                }
                """;
        Path appJava = cwd.resolve("src/main/java/org/apache/maven/samples/sample/App.java");
        Files.createDirectories(appJava.getParent());