Add files using upload-large-folder tool

local-test-commons-compress-delta-03/fuzz-tooling/docs/getting-started/new-project-guide/bazel.md

@@ -0,0 +1,97 @@
+---
+layout: default
+title: Integrating a Bazel project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 5
+permalink: /getting-started/new-project-guide/bazel/
+---
+
+# Integrating a Bazel project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+## Bazel projects
+
+The process of integrating a project using the [Bazel](https://bazel.build/)
+build system with OSS-Fuzz is very similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Bazel project are outlined below.
+
+## Fuzzing support in Bazel
+
+For Bazel-based projects, we recommend using the
+[`rules_fuzzing`](https://github.com/bazelbuild/rules_fuzzing) extension library
+for defining fuzz tests. `rules_fuzzing` provides support for building and running
+fuzz tests under
+[multiple sanitizer and fuzzing engine configurations][rules-fuzzing-usage].
+It also supports specifying corpora and dictionaries as part of the fuzz test
+definition.
+
+The fuzzing rules provide out-of-the-box support for building and packaging fuzz
+test artifacts in the OSS-Fuzz format. Each `//path/to:fuzz_test` fuzz test
+target automatically has a `//path/to:fuzz_test_oss_fuzz` packaging target that
+(a) builds the fuzz test using the instrumentation and engine library specified
+in the OSS-Fuzz environment variables, and (b) generates an archive containing
+the binary and its associated artifacts (corpus, dictionary, etc.). Moreover,
+OSS-Fuzz provides a standard tool to automatically process these targets,
+substantially simplifying the `build.sh` script (see below).
+
+[rules-fuzzing-usage]: https://github.com/bazelbuild/rules_fuzzing#using-the-rules-in-your-project
+
+## Project files
+
+This section explains how to integrate the fuzz tests written using the
+`rules_fuzzing` library with OSS-Fuzz. You can also see a complete example in the
+[`bazel-rules-fuzzing-test`](https://github.com/google/oss-fuzz/tree/master/projects/bazel-rules-fuzzing-test)
+project.
+
+The structure of the project directory in the OSS-Fuzz repository does not
+differ for Bazel-based projects. The project files have the following specific
+aspects.
+
+### project.yaml
+
+Only C++ projects are currently supported.
+
+Since the OSS-Fuzz target builds the fuzz test using the instrumentation and
+engine specified in the OSS-Fuzz environment variables, all the engine and
+sanitizer configurations supported in the `project.yaml` file are automatically
+supported by the fuzzing rules.
+
+### Dockerfile
+
+There is no need to install Bazel in your Docker image. The OSS-Fuzz builder
+image provides the `bazel` executable through the
+[Bazelisk](https://github.com/bazelbuild/bazelisk) launcher, which will fetch
+and use the latest Bazel release. If your project requires a particular Bazel
+version, create a
+[`.bazelversion`](https://docs.bazel.build/versions/master/updating-bazel.html)
+file in your repository root with the desired version string.
+
+### build.sh
+
+Your `build.sh` script essentially needs to perform three steps: (1) selecting
+which fuzz tests to build, (2) building their OSS-Fuzz package targets in the
+right configuration, and (3) copying the build artifacts to the `${OUT}/`
+destination.
+
+OSS-Fuzz provides a
+[`bazel_build_fuzz_tests`](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/bazel_build_fuzz_tests)
+tool that implements these steps in a standard way, so in most cases your
+build script only needs to invoke this command with no arguments.
+
+If necessary, the behavior of the tool can be customized through a set of
+environment variables. The most common are:
+
+* `BAZEL_EXTRA_BUILD_FLAGS` are extra build flags passed on the Bazel command
+   line.
+* `BAZEL_FUZZ_TEST_TAG` and `BAZEL_FUZZ_TEST_EXCLUDE_TAG` can be overridden to
+  specify which target tags to use when determining what fuzz tests to include.
+  By default, the tool selects all the fuzz tests except for those tagged as
+  `"no-oss-fuzz"`.
+* `BAZEL_FUZZ_TEST_QUERY` overrides the Bazel query the tool uses to identify
+  the fuzz tests to build, if the tag-based approach is not sufficient.

local-test-commons-compress-delta-03/fuzz-tooling/docs/getting-started/new-project-guide/go_lang.md

@@ -0,0 +1,125 @@
+---
+layout: default
+title: Integrating a Go project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 1
+permalink: /getting-started/new-project-guide/go-lang/
+---
+
+# Integrating a Go project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Go with OSS-Fuzz is very similar
+to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Go project are outlined below.
+
+## Go-fuzz support
+
+OSS-Fuzz supports **go-fuzz** in the
+[libFuzzer compatible mode](https://github.com/mdempsky/go114-fuzz-build)
+only. In that mode, fuzz targets for Go use the libFuzzer engine with native Go
+coverage instrumentation. Binaries compiled in this mode provide the same
+libFuzzer command line interface as non-Go fuzz targets.
+
+## Native Go Fuzzing support
+
+OSS-fuzz supports [fuzzers written for the native Go 1.18 engine](https://go.dev/doc/fuzz/). These fuzzers are built as libFuzzer binaries in a similar fashion as fuzzers written for the go-fuzz engine. Because of that, dictionaries and seed corpora should be handled in accordance with [the OSS-fuzz documentation](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#seed-corpus).
+Unlike libFuzzer/go-fuzz targets which must accept one data buffer, fuzz targets written for the Native Go engine can accept any number of arguments of any type. Here is an example of a valid fuzzer with multiple arguments:
+
+```go
+package demofuzzing
+
+import (
+    "fmt"
+    "testing"
+)
+
+func FuzzDemo(f *testing.F) {
+    f.Fuzz(func(t *testing.T, data1 string, data2 uint32, data3 float64) {
+        fmt.Println(data1)
+        fmt.Println(data2)
+        fmt.Println(data3)
+    })
+}
+```
+
+Some requirements for native Go 1.18 fuzzers are:
+* The only `testing.F` method supported is currently `F.Fuzz()`.
+* `F.Add()` will not add seeds when fuzzing. To provide OSS-fuzz with a seed corpus, follow the documentation [here](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#seed-corpus).
+
+## Project files
+
+First, you need to write a Go fuzz target. This fuzz target should reside in your project
+repository
+([example](https://github.com/golang/go/blob/4ad13555184eb0697c2e92c64c1b0bdb287ccc10/src/html/fuzz.go#L13)).
+
+The structure of the project directory in OSS-Fuzz repository doesn't differ for
+projects written in Go. The project files have the following Go specific
+aspects.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: go
+```
+
+The only supported fuzzing engine and sanitizer are `libfuzzer` and `address`,
+respectively.
+[Example](https://github.com/google/oss-fuzz/blob/356f2b947670b7eb33a1f535c71bc5c87a60b0d1/projects/syzkaller/project.yaml#L7):
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-go`
+
+The OSS-Fuzz builder image has the latest stable release of Golang installed. In
+order to install dependencies of your project, add `RUN git clone ...` command to
+your Dockerfile.
+[Example](https://github.com/google/oss-fuzz/blob/356f2b947670b7eb33a1f535c71bc5c87a60b0d1/projects/syzkaller/Dockerfile#L23):
+
+```dockerfile
+# Dependency for one of the fuzz targets.
+RUN git clone --depth 1 https://github.com/ianlancetaylor/demangle
+```
+
+go-fuzz will then automatically download the dependencies based on the go.mod file
+
+### build.sh
+
+In order to build a Go fuzz target, you need to call `go-fuzz`
+command first, and then link the resulting `.a` file against
+`$LIB_FUZZING_ENGINE` using the `$CXX $CXXFLAGS ...` command.
+
+For go-fuzz fuzzers, the best way to do this is by using the [`compile_go_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_go_fuzzer), and for native Go 1.18 fuzzers it is recommended to use the [`compile_native_go_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_native_go_fuzzer). Both of these also support coverage builds.
+
+`compile_native_go_fuzzer` requires two dependencies which can be installed with:
+```bash
+go install github.com/AdamKorcz/go-118-fuzz-build@latest
+go get github.com/AdamKorcz/go-118-fuzz-build/testing
+```
+
+A usage example from go-dns project is
+
+```sh
+compile_go_fuzzer github.com/miekg/dns FuzzNewRR fuzz_newrr fuzz
+```
+
+Arguments are :
+* path of the package with the fuzz target
+* name of the fuzz function
+* name of the fuzzer to be built
+* optional tag to be used by `go build` and such

local-test-commons-compress-delta-03/fuzz-tooling/docs/getting-started/new-project-guide/javascript_lang.md

@@ -0,0 +1,140 @@
+---
+layout: default
+title: Integrating a JavaScript project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 4
+permalink: /getting-started/new-project-guide/javascript-lang/
+---
+
+# Integrating a JavaScript project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in JavaScript for Node.js 
+with OSS-Fuzz is very similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a JavaScript project are outlined below.
+
+## Jazzer.js
+
+JavaScript fuzzing in OSS-Fuzz is powered by
+[Jazzer.js](https://github.com/CodeIntelligenceTesting/jazzer.js), which is
+installed during the build step. As Jazzer.js operates directly on the JavaScript
+source code level, it can be applied to any project written in a language that 
+can be transpiled into JavaScript such as TypeScript. More information on how Jazzer.js
+fuzz targets look like can be found in its
+[README's Usage section](https://github.com/CodeIntelligenceTesting/jazzer.js#usage).
+
+## Project files
+
+### Example project
+
+We recommend viewing
+[javascript-example](https://github.com/google/oss-fuzz/tree/master/projects/javascript-example)
+as an example of a simple JavaScript fuzzing project. We also recommend having a look at
+[typescript-example](https://github.com/google/oss-fuzz/tree/master/projects/typescript-example)
+as an example of how to fuzz TypeScript projects. This example also demonstrates how to use 
+Jazzer.js fuzzed data provider.
+
+### project.yaml
+
+The `language` attribute must be specified as follows:
+
+```yaml
+language: javascript
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). So far, native sanitizers such as 
+AddressSanitizer (`address`) and UndefinedBehaviorSanitizer (`undefined`) are not supported. 
+They would only be needed for projects that have native addons, which is a rather infrequent
+use case for JavaScript projects. If you have a project where you need ASan or UBSan, please 
+create open an issue on [Jazzer.js GitHub repo](https://github.com/CodeIntelligenceTesting/jazzer.js). None (`none`) is the default sanitizer for 
+JavaScript projects, so setting it up in `project.yaml` is optional.
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - none
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-javascript`
+
+The OSS-Fuzz base Docker images already come with Node.js 19 and `npm` pre-installed.
+Apart from that, you should usually not need to do more than to clone the
+project, set a `WORKDIR`, and copy any necessary files, or install any
+project-specific dependencies here as you normally would.
+
+### Fuzzers
+
+In the simplest case, every fuzzer consists of a single JavaScript file that exports
+a function named `fuzz` taking a single argument of type [Buffer](https://nodejs.org/api/buffer.html). 
+An example fuzz target could thus be a file `fuzz_string_compare.js` with contents:
+
+```javascript
+/**
+ * @param { Buffer } data
+ */
+module.exports.fuzz = function (data) {
+    const s = data.toString();
+    if (s.length !== 16) {
+        return;
+    }
+    if (
+        s.slice(0, 8) === "Awesome " &&
+        s.slice(8, 15) === "Fuzzing" &&
+        s[15] === "!"
+    ) {
+        throw Error("Welcome to Awesome Fuzzing!");
+    }
+};
+```
+
+### build.sh
+
+The OSS-Fuzz base docker image for JavaScript comes with the [`compile_javascript_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_javascript_fuzzer) preinstalled. In `build.sh`, you should install dependencies for your project, and if necessary compile the code into JavaScript. Then, you can use the script to build the fuzzers. The script ensures that [@Jazzer.js/core](https://www.npmjs.com/package/@jazzer.js/core) is installed so that its CLI can be used to execute your fuzz tests. It also generates a wrapper script that can be used as a drop-in replacement for libFuzzer. This means that the generated script accepts the same command line flags for libFuzzer. Under the hood these flags are simply forwarded to the libFuzzer native addon used by Jazzer.js.
+
+A usage example from the javascript-example project is
+
+```shell
+compile_javascript_fuzzer example fuzz_string_compare.js --sync
+```
+
+Arguments are:
+* relative path of the project in the $SRC directory
+* relative path to the fuzz test inside the project
+* remaining arguments are forwarded to the [Jazzer.js CLI](https://github.com/CodeIntelligenceTesting/jazzer.js/blob/main/docs/fuzz-targets.md#running-the-fuzz-target)
+
+The [javascript-example](https://github.com/google/oss-fuzz/blob/master/projects/javascript-example/build.sh)
+project contains an example of a `build.sh` for JavaScript projects.
+
+## FuzzedDataProvider
+
+Jazzer.js provides a `FuzzedDataProvider` that can simplify the task of creating a
+fuzz target by translating the raw input bytes received from the fuzzer into
+useful primitive JavaScript types. Its functionality is similar to
+`FuzzedDataProviders` available in other languages, such as
+[Java](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html) and
+[C++](https://github.com/google/fuzzing/blob/master/docs/split-inputs.md).
+
+A fuzz target using the `FuzzedDataProvider` would look as follows:
+
+```javascript
+const { FuzzedDataProvider } = require("@jazzer.js/core");
+
+/**
+ * @param { Buffer } fuzzerInputData
+ */
+module.exports.fuzz = function (fuzzerInputData) {
+    const data = new FuzzedDataProvider(fuzzerInputData);
+    const i = data.consumeIntegral(4);
+    const s = data.consumeRemainingAsString();
+    exploreMe(i, s);
+};
+```

local-test-commons-compress-delta-03/fuzz-tooling/docs/getting-started/new-project-guide/jvm_lang.md

@@ -0,0 +1,185 @@
+---
+layout: default
+title: Integrating a Java/JVM project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 4
+permalink: /getting-started/new-project-guide/jvm-lang/
+---
+
+# Integrating a Java/JVM project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Java or any other language
+running on the Java Virtual Machine (JVM) with OSS-Fuzz is very similar to the
+general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a JVM project are outlined below.
+
+## Jazzer
+
+Java fuzzing in OSS-Fuzz depends on
+[Jazzer](https://github.com/CodeIntelligenceTesting/jazzer), which is
+pre-installed on the OSS-Fuzz base docker images. As Jazzer operates directly
+on the bytecode level, it can be applied to any project written in a JVM-based
+language. More information on how Jazzer fuzz targets look like can be found in
+its
+[README's Usage section](https://github.com/CodeIntelligenceTesting/jazzer#usage).
+
+## Project files
+
+### Example project
+
+We recommend viewing
+[json-sanitizer](https://github.com/google/oss-fuzz/tree/master/projects/json-sanitizer)
+as an example of a simple Java-only fuzzing project. Additional examples,
+including one for a Java project with native dependencies, are part of the
+[java-example](https://github.com/google/oss-fuzz/tree/master/projects/java-example)
+project.
+
+### project.yaml
+
+The `language` attribute must be specified as follows:
+
+```yaml
+language: jvm
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). So far the only
+supported sanitizers are AddressSanitizer (`address`) and
+UndefinedBehaviorSanitizer (`undefined`). For pure Java projects, specify
+just `address`:
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-jvm`
+
+The OSS-Fuzz base Docker images already come with OpenJDK 15 pre-installed. If
+you need Maven to build your project, you can install it by adding the following
+line to your Dockerfile:
+
+```docker
+RUN apt-get update && apt-get install -y maven
+```
+
+Apart from this, you should usually not need to do more than to clone the
+project, set a `WORKDIR`, and copy any necessary files, or install any
+project-specific dependencies here as you normally would.
+
+### Fuzzers
+
+In the simplest case, every fuzzer consists of a single Java file with a
+filename matching `*Fuzzer.java` and no `package` directive. An example fuzz
+target could thus be a file `ExampleFuzzer.java` with contents:
+
+```java
+public class ExampleFuzzer {
+    public static void fuzzerTestOneInput(byte[] input) {
+        ...
+        // Call a function of the project under test with arguments derived from
+        // input and throw an exception if something unwanted happens.
+        ...
+    }
+}
+```
+
+### build.sh
+
+For JVM projects, `build.sh` does need some more significant modifications
+over C/C++ projects. Below is an annotated example build script for a
+Java-only project with single-file fuzz targets as described above:
+
+```sh
+# Step 1: Build the project
+
+# Build the project .jar as usual, e.g. using Maven.
+mvn package
+# In this example, the project is built with Maven, which typically includes the
+# project version into the name of the packaged .jar file. The version can be
+# obtained as follows:
+CURRENT_VERSION=$(mvn org.apache.maven.plugins:maven-help-plugin:3.2.0:evaluate \
+-Dexpression=project.version -q -DforceStdout)
+# Copy the project .jar into $OUT under a fixed name.
+cp "target/sample-project-$CURRENT_VERSION.jar" $OUT/sample-project.jar
+
+# Specify the projects .jar file(s), separated by spaces if there are multiple.
+PROJECT_JARS="sample-project.jar"
+
+# Step 2: Build the fuzzers (should not require any changes)
+
+# The classpath at build-time includes the project jars in $OUT as well as the
+# Jazzer API.
+BUILD_CLASSPATH=$(echo $PROJECT_JARS | xargs printf -- "$OUT/%s:"):$JAZZER_API_PATH
+
+# All .jar and .class files lie in the same directory as the fuzzer at runtime.
+RUNTIME_CLASSPATH=$(echo $PROJECT_JARS | xargs printf -- "\$this_dir/%s:"):\$this_dir
+
+for fuzzer in $(find $SRC -name '*Fuzzer.java'); do
+  fuzzer_basename=$(basename -s .java $fuzzer)
+  javac -cp $BUILD_CLASSPATH $fuzzer
+  cp $SRC/$fuzzer_basename.class $OUT/
+
+  # Create an execution wrapper that executes Jazzer with the correct arguments.
+  echo "#!/bin/bash
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+if [[ \"\$@\" =~ (^| )-runs=[0-9]+($| ) ]]; then
+  mem_settings='-Xmx1900m:-Xss900k'
+else
+  mem_settings='-Xmx2048m:-Xss1024k'
+fi
+LD_LIBRARY_PATH=\"$JVM_LD_LIBRARY_PATH\":\$this_dir \
+\$this_dir/jazzer_driver --agent_path=\$this_dir/jazzer_agent_deploy.jar \
+--cp=$RUNTIME_CLASSPATH \
+--target_class=$fuzzer_basename \
+--jvm_args=\"\$mem_settings:-Djava.awt.headless=true\" \
+\$@" > $OUT/$fuzzer_basename
+  chmod +x $OUT/$fuzzer_basename
+done
+```
+
+The [java-example](https://github.com/google/oss-fuzz/blob/master/projects/java-example/build.sh)
+project contains an example of a `build.sh` for Java projects with native
+libraries.
+
+## FuzzedDataProvider
+
+Jazzer provides a `FuzzedDataProvider` that can simplify the task of creating a
+fuzz target by translating the raw input bytes received from the fuzzer into
+useful primitive Java types. Its functionality is similar to
+`FuzzedDataProviders` available in other languages, such as
+[Python](https://github.com/google/atheris#fuzzeddataprovider) and
+[C++](https://github.com/google/fuzzing/blob/master/docs/split-inputs.md).
+
+On OSS-Fuzz, the required library is available in the base docker images under
+the path `$JAZZER_API_PATH`, which is added to the classpath by the example
+build script shown above. Locally, the library can be obtained from
+[Maven Central](https://search.maven.org/search?q=g:com.code-intelligence%20a:jazzer-api).
+
+A fuzz target using the `FuzzedDataProvider` would look as follows:
+
+```java
+import com.code_intelligence.jazzer.api.FuzzedDataProvider;
+
+public class ExampleFuzzer {
+    public static void fuzzerTestOneInput(FuzzedDataProvider data) {
+        int number = data.consumeInt();
+        String string = data.consumeRemainingAsString();
+        // ...
+    }
+}
+```
+
+For a list of convenience methods offered by `FuzzedDataProvider`, consult its
+[javadocs](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html).

local-test-commons-compress-delta-03/fuzz-tooling/docs/getting-started/new-project-guide/python_lang.md

@@ -0,0 +1,137 @@
+---
+layout: default
+title: Integrating a Python project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 3
+permalink: /getting-started/new-project-guide/python-lang/
+---
+
+# Integrating a Python project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+
+The process of integrating a project written in Python with OSS-Fuzz is very
+similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Python project are outlined below.
+
+## Atheris
+
+Python fuzzing in OSS-Fuzz depends on
+[Atheris](https://github.com/google/atheris). Fuzzers will depend on the
+`atheris` package, and dependencies are pre-installed on the OSS-Fuzz base
+docker images.
+
+## Project files
+
+### Example project
+
+We recommend viewing [ujson](https://github.com/google/oss-fuzz/tree/master/projects/ujson) as an
+example of a simple Python fuzzing project, with both plain-Atheris and
+Atheris + Hypothesis harnesses.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: python
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). The supported
+sanitizers are AddressSanitizer (`address`) and
+UndefinedBehaviorSanitizer (`undefined`). These must be explicitly specified.
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+  - undefined
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-python`
+
+Because most dependencies are already pre-installed on the images, no
+significant changes are needed in the Dockerfile for Python fuzzing projects.
+You should simply clone the project, set a `WORKDIR`, and copy any necessary
+files, or install any project-specific dependencies here as you normally would.
+
+### build.sh
+
+For Python projects, `build.sh` does need some more significant modifications
+over normal projects. The following is an annotated example build script,
+explaining why each step is necessary and when they can be omitted.
+
+```sh
+# Build and install project (using current CFLAGS, CXXFLAGS). This is required
+# for projects with C extensions so that they're built with the proper flags.
+pip3 install .
+
+# Build fuzzers into $OUT. These could be detected in other ways.
+for fuzzer in $(find $SRC -name '*_fuzzer.py'); do
+  fuzzer_basename=$(basename -s .py $fuzzer)
+  fuzzer_package=${fuzzer_basename}.pkg
+
+  # To avoid issues with Python version conflicts, or changes in environment
+  # over time on the OSS-Fuzz bots, we use pyinstaller to create a standalone
+  # package. Though not necessarily required for reproducing issues, this is
+  # required to keep fuzzers working properly in OSS-Fuzz.
+  pyinstaller --distpath $OUT --onefile --name $fuzzer_package $fuzzer
+
+  # Create execution wrapper. Atheris requires that certain libraries are
+  # preloaded, so this is also done here to ensure compatibility and simplify
+  # test case reproduction. Since this helper script is what OSS-Fuzz will
+  # actually execute, it is also always required.
+  # NOTE: If you are fuzzing python-only code and do not have native C/C++
+  # extensions, then remove the LD_PRELOAD line below as preloading sanitizer
+  # library is not required and can lead to unexpected startup crashes.
+  echo "#!/bin/sh
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+LD_PRELOAD=\$this_dir/sanitizer_with_fuzzer.so \
+ASAN_OPTIONS=\$ASAN_OPTIONS:symbolize=1:external_symbolizer_path=\$this_dir/llvm-symbolizer:detect_leaks=0 \
+\$this_dir/$fuzzer_package \$@" > $OUT/$fuzzer_basename
+  chmod +x $OUT/$fuzzer_basename
+done
+```
+
+## Hypothesis
+
+Using [Hypothesis](https://hypothesis.readthedocs.io/), the Python library for
+[property-based testing](https://hypothesis.works/articles/what-is-property-based-testing/),
+makes it really easy to generate complex inputs - whether in traditional test suites
+or [by using test functions as fuzz harnesses](https://hypothesis.readthedocs.io/en/latest/details.html#use-with-external-fuzzers).
+
+> Property based testing is the construction of tests such that, when these tests are fuzzed,
+  failures in the test reveal problems with the system under test that could not have been
+  revealed by direct fuzzing of that system.
+
+We recommend using the [`hypothesis write`](https://hypothesis.readthedocs.io/en/latest/ghostwriter.html)
+command to generate a starter fuzz harness.  This "ghostwritten" code may be usable as-is,
+or provide a useful template for writing more specific tests.
+
+See [here for the core "strategies"](https://hypothesis.readthedocs.io/en/latest/data.html),
+for arbitrary data, [here for Numpy + Pandas support](https://hypothesis.readthedocs.io/en/latest/numpy.html),
+or [here for a variety of third-party extensions](https://hypothesis.readthedocs.io/en/latest/strategies.html)
+supporting everything from protobufs, to jsonschemas, to networkx graphs or geojson
+or valid Python source code.
+Hypothesis' integrated test-case reduction also makes it trivial to report a canonical minimal
+example for each distinct failure discovered while fuzzing - just run the test function!
+
+To use Hypothesis in OSS-Fuzz, install it in your Dockerfile with
+
+```shell
+RUN pip3 install hypothesis
+```
+
+See [the `ujson` structured fuzzer](https://github.com/google/oss-fuzz/blob/master/projects/ujson/hypothesis_structured_fuzzer.py)
+for an example "polyglot" which can either be run with `pytest` as a standard test function,
+or run with OSS-Fuzz as a fuzz harness.

local-test-commons-compress-delta-03/fuzz-tooling/docs/getting-started/new-project-guide/rust_lang.md

@@ -0,0 +1,148 @@
+---
+layout: default
+title: Integrating a Rust project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 2
+permalink: /getting-started/new-project-guide/rust-lang/
+---
+
+# Integrating a Rust project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Rust with OSS-Fuzz is very
+similar to the general [Setting up a new project]({{ site.baseurl
+}}/getting-started/new-project-guide/) process. The key specifics of integrating
+a Rust project are outlined below.
+
+## cargo-fuzz support
+
+Rust integration with OSS-Fuzz is expected to use [`cargo
+fuzz`](https://github.com/rust-fuzz/cargo-fuzz) to build fuzzers. The `cargo
+fuzz` tool will build code with required compiler flags as well as link to the
+correct libFuzzer on OSS-Fuzz itself. Note that using `cargo fuzz` also makes it
+quite easy to run the fuzzers locally yourself if you get a failing test case!
+
+## Project files
+
+First you'll want to follow the [setup instructions for `cargo fuzz`
+itself](https://rust-fuzz.github.io/book/). Afterwards your project should have:
+
+* A top-level `fuzz` directory.
+* A `fuzz/Cargo.toml` manifest which pulls in necessary dependencies to fuzz.
+* Some `fuzz/fuzz_targets/*.rs` files which are the fuzz targets that will be
+  compiled and run on OSS-Fuzz.
+
+Note that you can customize this layout as well, but you'll need to edit some
+the scripts below to integrate into OSS-Fuzz.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: rust
+```
+
+The only supported fuzzing engine and sanitizer are `libfuzzer` and `address`,
+respectively.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/project.yaml#L3-L6)
+
+```yaml
+sanitizers:
+  - address
+fuzzing_engines:
+  - libfuzzer
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-rust`
+
+The OSS-Fuzz builder image has the latest nightly release of Rust as well as
+`cargo fuzz` pre-installed and in `PATH`. In the `Dockerfile` for your project
+all you'll need to do is fetch the latest copy of your code and install any
+system dependencies necessary to build your project.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/Dockerfile#L18-L20)
+
+```dockerfile
+RUN git clone --depth 1 https://github.com/serde-rs/json json
+```
+
+### build.sh
+
+Here it's expected that you'll build the fuzz targets for your project and then
+copy the final binaries into the output directory.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/build.sh#L20):
+
+```sh
+cd $SRC/json
+cargo fuzz build -O
+cp fuzz/target/x86_64-unknown-linux-gnu/release/from_slice $OUT/
+```
+
+Note that you likely want to pass the `-O` flag to `cargo fuzz build` which
+builds fuzzers in release mode. You may also want to pass the
+`--debug-assertions` flag to enable more checks while fuzzing. In this example
+the `from_slice` binary is the fuzz target.
+
+With some bash-fu you can also automatically copy over all fuzz targets into
+the output directory so when you add a fuzz target to your project it's
+automatically integrated into OSS-Fuzz:
+
+```sh
+FUZZ_TARGET_OUTPUT_DIR=target/x86_64-unknown-linux-gnu/release
+for f in fuzz/fuzz_targets/*.rs
+do
+    FUZZ_TARGET_NAME=$(basename ${f%.*})
+    cp $FUZZ_TARGET_OUTPUT_DIR/$FUZZ_TARGET_NAME $OUT/
+done
+```
+
+## Writing fuzzers using a test-style strategy
+
+In Rust you will often have tests written in a way so they are only 
+compiled into the final binary when build in test-mode. This is, achieved by
+wrapping your test code in `cfg(test)`, e.g.
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    ...
+```
+
+Cargo-fuzz automatically enables the `fuzzing` feature, which means you can
+follow a similar strategy to writing fuzzers as you do when writing tests.
+Specifically, you can create modules wrapped in the `fuzzing` feature:
+```rust
+#[cfg(fuzzing)]
+pub mod fuzz_logic {
+    use super::*;
+
+    ...
+```
+and then call the logic within `fuzz_logic` from your fuzzer. 
+
+Furthermore, within your `.toml` files, you can then specify fuzzing-specific
+dependencies by wrapping them as follows:
+```
+[target.'cfg(fuzzing)'.dependencies]
+```
+similar to how you wrap test-dependencies as follows:
+```
+[dev-dependencies]
+```
+
+Finally, you can also combine the testing logic you have and the fuzz logic. This
+can be achieved simply by using 
+```rust
+#[cfg(any(test, fuzzing))]
+```
+
+A project that follows this structure is Linkerd2-proxy and the project files can be
+seen [here](https://github.com/google/oss-fuzz/tree/master/projects/linkerd2-proxy).

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+insert_final_newline = true

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/.eslintignore

@@ -0,0 +1 @@
+build/

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/.gitignore

@@ -0,0 +1,6 @@
+out
+build
+dist
+node_modules
+.vscode-test/
+*.vsix

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/.prettierrc.js

@@ -0,0 +1,18 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+module.exports = {
+  ...require('gts/.prettierrc.json')
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/cifuzz.ts

@@ -0,0 +1,70 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {println} from './logger';
+
+/**
+ * Creates a CIFuzz template
+ * @param language
+ * @param projectName
+ * @param secondToRun
+ * @returns
+ */
+export function cifuzzGenerator(
+  language: string,
+  projectName: string,
+  secondToRun: Number
+) {
+  println('Exporting cifuzz logic ' + language);
+
+  const cifuzzTemplate = `name: CIFuzz
+on: [pull_request]
+permissions: {}
+jobs:
+    Fuzzing:
+    runs-on: ubuntu-latest
+    permissions:
+        security-events: write
+    steps:
+    - name: Build Fuzzers
+        id: build
+        uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+        with:
+        oss-fuzz-project-name: '${projectName}'
+        language: ${language}
+    - name: Run Fuzzers
+        uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+        with:
+        oss-fuzz-project-name: '${projectName}'
+        language: ${language}
+        fuzz-seconds: ${secondToRun}
+        output-sarif: true
+    - name: Upload Crash
+        uses: actions/upload-artifact@v3
+        if: failure() && steps.build.outcome == 'success'
+        with:
+        name: artifacts
+        path: ./out/artifacts
+    - name: Upload Sarif
+        if: always() && steps.build.outcome == 'success'
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+        # Path to SARIF file relative to the root of the repository
+        sarif_file: cifuzz-sarif/results.sarif
+        checkout_path: cifuzz-sarif`;
+
+  return cifuzzTemplate;
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdListFuzzers.ts

@@ -0,0 +1,42 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+
+import {listFuzzersForProject} from '../utils';
+import {println} from '../logger';
+import {extensionConfig} from '../config';
+
+/**
+ * Lists all the fuzzers for a project.
+ */
+export async function listFuzzersHandler() {
+  // Lists all of the fuzzers from a project.
+  const projectName = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type a project name',
+  });
+  if (!projectName) {
+    console.log('Failed to get project name');
+    return;
+  }
+  println('Listing fuzzers for project ' + projectName);
+
+  await listFuzzersForProject(
+    projectName?.toString(),
+    extensionConfig.ossFuzzPepositoryWorkPath
+  );
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdRedo.ts

@@ -0,0 +1,35 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {commandHistory} from '../commandUtils';
+
+/**
+ * Rerun the latest command
+ */
+export async function cmdDispatcherRe() {
+  if (commandHistory.length === 0) {
+    console.log('command history is empty');
+    return false;
+  }
+
+  const commandObj: any = commandHistory[commandHistory.length - 1];
+
+  console.log('Redoing');
+  console.log(commandObj.commandType);
+  await commandObj.dispatcherFunc(commandObj.Arguments);
+  //await commandObj.dispatcherFunc(commandObj.args);
+  return true;
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdTestFuzzer.ts

@@ -0,0 +1,90 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {println} from '../logger';
+import {runFuzzerHandler, buildFuzzersFromWorkspace} from '../ossfuzzWrappers';
+import {setStatusText} from '../utils';
+import {commandHistory} from '../commandUtils';
+import {extensionConfig} from '../config';
+
+/**
+ * Does an end-to-end test of a project/fuzzer. This is done by
+ * first building the project and then running the fuzzer.
+ * @param context
+ * @returns
+ */
+
+export async function cmdInputCollectorTestFuzzer() {
+  setStatusText('Testing specific fuzzer: getting input');
+  // Get the project name and fuzzer name to test.
+  const ossFuzzProjectNameInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'The OSS-Fuzz project name',
+  });
+  if (!ossFuzzProjectNameInput) {
+    println('Did not get a ossFuzzTargetProject');
+    return;
+  }
+  println('Project name: ' + ossFuzzProjectNameInput);
+
+  // Get the fuzzer to run
+  const fuzzerNameInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type a fuzzer name',
+  });
+  if (!fuzzerNameInput) {
+    println('Failed to get fuzzer name');
+    return;
+  }
+
+  // Create the args object for the dispatcher
+  const args = new Object({
+    projectName: ossFuzzProjectNameInput.toString(),
+    fuzzerName: fuzzerNameInput.toString(),
+  });
+
+  // Create a dispatcher object.
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.TestFuzzer',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchTestFuzzerHandler,
+  });
+  commandHistory.push(commandObject);
+
+  await cmdDispatchTestFuzzerHandler(args);
+}
+
+async function cmdDispatchTestFuzzerHandler(args: any) {
+  // Build the project
+  setStatusText('Test specific fuzzer: building fuzzers in workspace');
+  if (!(await buildFuzzersFromWorkspace(args.projectName, '', false))) {
+    println('Build projects');
+    return;
+  }
+
+  // Run the fuzzer for 10 seconds
+  println('Running fuzzer');
+  setStatusText('Test specific fuzzer: running fuzzer ' + args.fuzzerName);
+  await runFuzzerHandler(
+    args.projectName,
+    args.fuzzerName,
+    extensionConfig.numberOfSecondsForTestRuns.toString(),
+    ''
+  );
+  setStatusText('Test specific fuzzer: test completed of ' + args.fuzzerName);
+  return;
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/config.ts

@@ -0,0 +1,37 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {println} from './logger';
+
+export class ExtensionConfig {
+  /** Path to the repository that will be used. */
+  ossFuzzPepositoryWorkPath: string = '/tmp/oss-fuzz';
+
+  /** The directory where crash info is stored. */
+  crashesDirectory = process.env.HOME + '/oss-fuzz-crashes';
+
+  /** Number of seconds used for running quick test fuzzers */
+  numberOfSecondsForTestRuns = 20;
+
+  async printConfig() {
+    println('Config:');
+    println('- OSS-Fuzz repository path: ' + this.ossFuzzPepositoryWorkPath);
+    println('- Crashes directory: ' + this.crashesDirectory);
+    println('- numberOfSecondsForTestRuns: ' + this.numberOfSecondsForTestRuns);
+  }
+}
+
+export const extensionConfig = new ExtensionConfig();

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/logger.ts

@@ -0,0 +1,31 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+export const vscodeOutputChannel =
+  vscode.window.createOutputChannel('oss-fuzz');
+
+export function println(line: string) {
+  vscodeOutputChannel.appendLine(line);
+}
+
+export function printRaw(line: string) {
+  vscodeOutputChannel.append(line);
+}
+
+export function debugPrintln(line: string) {
+  console.log(line);
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/ossfuzzWrappers.ts

@@ -0,0 +1,385 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+const fs = require('fs');
+import * as vscode from 'vscode';
+import {
+  hasOssFuzzInWorkspace,
+  getOssFuzzWorkspaceProjectName,
+  listFuzzersForProject,
+  systemSyncLogIfFailure,
+} from './utils';
+import {println} from './logger';
+import {extensionConfig} from './config';
+
+export async function buildFuzzersFromWorkspaceClusterfuzzLite() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    println('No workspace folder, exiting');
+    return false;
+  }
+
+  // Build the fuzzers using OSS-Fuzz infrastructure.
+  const cmdToExec = 'python3';
+  const args = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'build_fuzzers',
+  ];
+
+  args.push('--external');
+  args.push(workspaceFolder[0].uri.path);
+  println('Building fuzzers');
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to build fuzzers');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Builds the fuzzers for a given workspace.
+ *
+ * There are two options:
+ *  1) The fuzzers are build using the OSS-Fuzz set up in the folder
+ *  2) The fuzzers are build using the workspace and then copies that over.
+ */
+export async function buildFuzzersFromWorkspace(
+  projectNameArg: string,
+  sanitizer: string,
+  toClean: boolean
+) {
+  // println('Building fuzzers locally');
+
+  // Check if there is an OSS-Fuzz set up, and exit if not.
+  if (
+    (await isPathValidOssFuzzPath(
+      extensionConfig.ossFuzzPepositoryWorkPath
+    )) === false
+  ) {
+    println('No valid oss-fuzz path');
+    return false;
+  }
+
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    println('No workspace folder, exiting');
+    return false;
+  }
+
+  let ossFuzzProjectName = '';
+  if (await hasOssFuzzInWorkspace()) {
+    /**
+     * The fuzzers are in the workspace, as opposed to e.g. the oss-fuzz dirctory.
+     */
+    ossFuzzProjectName = await getOssFuzzWorkspaceProjectName();
+
+    /**
+     * The workspace has an OSS-Fuzz directory. We use this for the build.
+     * This is done by copying over the relevant files to the oss-fuzz repository
+     * folder. Notice that we will do a forceful copy overwriting the existing
+     * project foler if it exists.
+     */
+    println('Found project folder: ' + ossFuzzProjectName);
+
+    // Copy over the workspace oss-fuzz set up to the oss-fuzz folder.
+    let cmdToExec = 'cp';
+    let args: Array<string> = [
+      '-rfT',
+      workspaceFolder[0].uri.path + '/OSS-Fuzz/' + ossFuzzProjectName,
+      extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/',
+    ];
+
+    if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+      println('Failed to copy project');
+      return false;
+    }
+
+    // Build the fuzzers using OSS-Fuzz infrastructure.
+    cmdToExec = 'python3';
+    args = [
+      extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+      'build_fuzzers',
+    ];
+    println('DECIDING ABOUT SANITIZER');
+    if (sanitizer !== '') {
+      println('ADDING CODE COVERAGE SANITIZER');
+      args.push('--sanitizer=' + sanitizer);
+    }
+
+    if (toClean) {
+      args.push('--clean');
+    }
+
+    args.push(ossFuzzProjectName);
+    println('Building fuzzers');
+    if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+      println('Failed to build fuzzers');
+      return false;
+    }
+  } else {
+    ossFuzzProjectName = projectNameArg;
+
+    const targetOssFuzzProject = vscode.Uri.file(
+      extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName
+    );
+    // Check if the folder exists.
+    let projectHasOssFuzzFolder = false;
+    try {
+      await vscode.workspace.fs.readDirectory(targetOssFuzzProject);
+      projectHasOssFuzzFolder = true;
+    } catch {
+      projectHasOssFuzzFolder = false;
+    }
+
+    /**
+     * The workspace does not have a OSS-Fuzz specific folder but has
+     * a folder in the OSS-Fuzz/projects/* directory. As such, we build
+     * the project using that build.sh set up, but, instead of cloning
+     * the repository we mount the workspace root onto what would normally
+     * be cloned.
+     */
+    if (projectHasOssFuzzFolder) {
+      // println('Found a target directory');
+
+      // Build the fuzzers using OSS-Fuzz infrastructure.
+      // First, Set up a temporary workpath that will be cleanup after
+      const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+      const cmdToExec2 = 'cp';
+      const temporaryProjectPath =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/temporary-project';
+
+      const args2: Array<string> = [
+        '-rfT',
+        wsPath.toString(),
+        temporaryProjectPath,
+      ];
+
+      if (!(await systemSyncLogIfFailure(cmdToExec2, args2))) {
+        println('Failed to build fuzzers');
+        return false;
+      }
+
+      //const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+      const temporaryDockerPath =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/Dockerfile';
+      const temporaryDockerPath2 =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/Dockerfile2';
+
+      const args3: Array<string> = [temporaryDockerPath, temporaryDockerPath2];
+      if (!(await systemSyncLogIfFailure('cp', args3))) {
+        println('Failed to copy Dockerfile');
+        return false;
+      }
+
+      // Append COPY command to Dockerfile
+      fs.appendFileSync(
+        temporaryDockerPath,
+        'COPY temporary-project /src/' + ossFuzzProjectName
+      );
+
+      // Second, build the actual fuzzers using the temporarily created project path for mount.
+      const cmdToExec = 'python3';
+      const args = [
+        extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+        'build_fuzzers', // command
+      ];
+
+      // Add sanitizer if needed.
+      if (sanitizer !== '') {
+        args.push('--sanitizer=' + sanitizer);
+      }
+
+      // Add clean flag if needed.
+      if (toClean) {
+        args.push('--clean');
+      }
+
+      args.push(ossFuzzProjectName);
+      /*
+      Previously we used OSS-Fuzz logic that supports mounting paths for getting
+      the workspace into the Dockerfile.
+      This approach, however, has limitations in that most builds will modify
+      the contents of the folder they're working in. This can cause issues and also
+      make it not possible to build several versions of the project with changing
+      sanitizers in a sequence. As such, we disbanded.
+      */
+      println('Building fuzzers');
+      if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+        println('Failed to copy Dockerfile');
+        // Move back the modified Dockerfile
+        const args5: Array<string> = [
+          temporaryDockerPath2,
+          temporaryDockerPath,
+        ];
+        if (!(await systemSyncLogIfFailure('mv', args5))) {
+          println('Failed to copy back Dockerfile');
+          return false;
+        }
+        return false;
+      }
+
+      // Move back the modified Dockerfile
+      const args5: Array<string> = [temporaryDockerPath2, temporaryDockerPath];
+      if (!(await systemSyncLogIfFailure('mv', args5))) {
+        println('Failed to copy back Dockerfile');
+        return false;
+      }
+    } else {
+      println('OSS-Fuzz does not have the relevant project folder');
+      return false;
+    }
+  }
+
+  // If we go to here we successfully build the project. Give information.
+  vscode.window.showInformationMessage('Successfully build project');
+
+  // List the fuzzers build
+  await listFuzzersForProject(
+    ossFuzzProjectName,
+    extensionConfig.ossFuzzPepositoryWorkPath
+  );
+  return true;
+}
+
+/**
+ * Runs the fuzzer for a given CFLite project
+ */
+export async function runFuzzerHandlerCFLite(
+  projectNameArg: string,
+  fuzzerNameArg: string,
+  secondsToRunArg: string
+) {
+  // The fuzzer is run by way of OSS-Fuzz's helper.py so we use python3 to launch
+  // this script.
+  const cmdToExec = 'python3';
+
+  // Set the arguments correctly. The ordering here is important for compatibility
+  // with the underlying argparse used by OSS-Fuzz helper.py.
+  const args: Array<string> = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'run_fuzzer',
+  ];
+
+  args.push('--external');
+  args.push(projectNameArg);
+  args.push(fuzzerNameArg);
+  args.push('--');
+  args.push('-max_total_time=' + secondsToRunArg);
+
+  println(
+    'Running fuzzer' +
+      fuzzerNameArg +
+      ' from project ' +
+      projectNameArg +
+      ' for ' +
+      secondsToRunArg +
+      ' seconds.'
+  );
+
+  // Run the actual command
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to run fuzzer');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Runs the fuzzer for a given project.
+ */
+export async function runFuzzerHandler(
+  projectNameArg: string,
+  fuzzerNameArg: string,
+  secondsToRunArg: string,
+  fuzzerCorpusPath: string
+) {
+  // Check there is a valid OSS-Fuzz path. If not, bail out.
+  if (
+    (await isPathValidOssFuzzPath(
+      extensionConfig.ossFuzzPepositoryWorkPath
+    )) === false
+  ) {
+    println('Missing valid OSS-Fuzz path.');
+    return;
+  }
+  // The fuzzer is run by way of OSS-Fuzz's helper.py so we use python3 to launch
+  // this script.
+  const cmdToExec = 'python3';
+
+  // Set the arguments correctly. The ordering here is important for compatibility
+  // with the underlying argparse used by OSS-Fuzz helper.py.
+  const args: Array<string> = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'run_fuzzer',
+  ];
+  if (fuzzerCorpusPath !== '') {
+    args.push('--corpus-dir');
+    args.push(fuzzerCorpusPath);
+  }
+  args.push(projectNameArg);
+  args.push(fuzzerNameArg);
+  args.push('--');
+  args.push('-max_total_time=' + secondsToRunArg);
+
+  println(
+    'Running fuzzer' +
+      fuzzerNameArg +
+      ' from project ' +
+      projectNameArg +
+      ' for ' +
+      secondsToRunArg +
+      ' seconds.'
+  );
+
+  // Run the actual command
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to run fuzzer');
+    return false;
+  }
+  return true;
+}
+
+// Validates if a directory is a valid oss-fuzz path.
+export async function isPathValidOssFuzzPath(path: string) {
+  try {
+    if (await vscode.workspace.fs.readDirectory(vscode.Uri.file(path))) {
+      // println('Is a directory');
+      // const helperPath = vscode.Uri.file(path + '/infra/helper.py');
+      const helperPath = path + '/infra/helper.py';
+      //console.log('Checking ' + helperPath.toString());
+      if (fs.existsSync(helperPath.toString())) {
+        return true;
+      }
+    }
+  } catch {
+    /* empty */
+  }
+  return false;
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/projectIntegrationHelper.ts

@@ -0,0 +1,761 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+const fs = require('fs');
+import path = require('path');
+import {println} from './logger';
+import * as fuzzTemplate from './commands/cmdTemplate';
+
+export async function setupProjectInitialFiles(isClusterfuzzLite: boolean) {
+  const wsedit = new vscode.WorkspaceEdit();
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  let projectGithubRepository = '';
+
+  const isOssFuzz = isClusterfuzzLite === false;
+
+  // Get the repository if this is not ClusterfuzzLite
+  if (isOssFuzz) {
+    const tmpProjectGithubRepository = await vscode.window.showInputBox({
+      value: '',
+      placeHolder: 'Github repository for the project.',
+    });
+    if (!tmpProjectGithubRepository) {
+      return false;
+    }
+    projectGithubRepository = tmpProjectGithubRepository;
+  }
+
+  const projectNameFromRepo = path
+    .parse(projectGithubRepository)
+    .base.toLocaleLowerCase();
+
+  let pathOfLocal = '';
+  if (workspaceFolder) {
+    pathOfLocal = path
+      .parse(workspaceFolder[0].uri.fsPath)
+      .base.toLocaleLowerCase();
+    println('path of local: ' + pathOfLocal);
+  }
+  if (isOssFuzz) {
+    println('Derived project name: ' + projectNameFromRepo);
+  }
+
+  const pythonFiles = await vscode.workspace.findFiles('**/*.py');
+  const cppFiles = await vscode.workspace.findFiles('**/*.c++');
+  const cppFiles2 = await vscode.workspace.findFiles('**/*.cpp');
+  const cppFiles3 = await vscode.workspace.findFiles('**/*.cc');
+  const cfiles = await vscode.workspace.findFiles('**/*.c');
+  const hfiles = await vscode.workspace.findFiles('**/*.h');
+  const rustFiles = await vscode.workspace.findFiles('**/*.rust');
+  const golangFiles = await vscode.workspace.findFiles('**/*.go');
+  const javaFiles = await vscode.workspace.findFiles('**/*.java');
+
+  println('Number of python files: ' + pythonFiles.length);
+  println('Number of C++ files: ' + cppFiles.length + cppFiles2.length);
+  println('Number of C files: ' + cfiles.length);
+  println('Number of rustFiles files: ' + rustFiles.length);
+  println('Number of golangFiles files: ' + golangFiles.length);
+  println('Number of H files: ' + hfiles.length);
+
+  const cppFilesCount = cppFiles.length + cppFiles2.length + cppFiles3.length;
+
+  const maxCount = Math.max(
+    pythonFiles.length,
+    cppFilesCount,
+    cfiles.length,
+    rustFiles.length,
+    golangFiles.length,
+    javaFiles.length
+  );
+  let target = '';
+  if (maxCount > 0) {
+    if (maxCount === pythonFiles.length) {
+      target = 'python';
+    } else if (maxCount === cppFilesCount) {
+      target = 'cpp';
+    } else if (maxCount === cfiles.length) {
+      target = 'c';
+    } else if (maxCount === javaFiles.length) {
+      target = 'java';
+    } else {
+      println('Target is not implemented');
+      return true;
+    }
+  } else {
+    if (hfiles.length > 0) {
+      target = 'cpp';
+    } else {
+      return true;
+    }
+  }
+
+  println('Target language: ' + target);
+
+  let baseFolder = '.clusterfuzzlite';
+  if (isOssFuzz) {
+    baseFolder = 'OSS-Fuzz';
+  }
+
+  if (workspaceFolder) {
+    const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+    // Create workflow file for ClusterFuzzLite
+    if (isOssFuzz === false) {
+      println('Creating the workflow file');
+      const clusterfuzzWorkflowFile = vscode.Uri.file(
+        wsPath + '/' + '.github' + '/' + 'workflows/cflite_pr.yml'
+      );
+
+      let tmp_target = target;
+      if (tmp_target === 'cpp') {
+        tmp_target = 'c++';
+      }
+
+      //println('Workflow pth: ' + clusterfuzzWorkflowFile);
+
+      const cflite_workflow_yaml = `name: ClusterFuzzLite PR fuzzing
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [ main ]
+permissions: read-all
+jobs:
+  PR:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        sanitizer: [address]
+    steps:
+    - name: Build Fuzzers (\${{ matrix.sanitizer }})
+      id: build
+      uses: google/clusterfuzzlite/actions/build_fuzzers@v1
+      with:
+        sanitizer: \${{ matrix.sanitizer }}
+        language: ${tmp_target}
+        bad-build-check: false
+    - name: Run Fuzzers (\${{ matrix.sanitizer }})
+      id: run
+      uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+      with:
+        github-token: \${{ secrets.GITHUB_TOKEN }}
+        fuzz-seconds: 100
+        mode: 'code-change'
+        report-unreproducible-crashes: false
+        sanitizer: \${{ matrix.sanitizer }}
+`;
+
+      // Create the file and add the contents
+      if (fs.existsSync(clusterfuzzWorkflowFile.path) === false) {
+        wsedit.createFile(clusterfuzzWorkflowFile, {ignoreIfExists: true});
+        wsedit.insert(
+          clusterfuzzWorkflowFile,
+          new vscode.Position(0, 0),
+          cflite_workflow_yaml
+        );
+      }
+    }
+
+    const ossfuzzDockerFilepath = vscode.Uri.file(
+      wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/Dockerfile'
+    );
+
+    vscode.window.showInformationMessage(ossfuzzDockerFilepath.toString());
+    //wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+
+    if (target === 'python') {
+      await setupPythonProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'cpp') {
+      await setupCPPProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'c') {
+      await setupCProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'java') {
+      await setupJavaProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        isOssFuzz
+      );
+    }
+    vscode.workspace.applyEdit(wsedit);
+    vscode.window.showInformationMessage('Created a new file: hello/world.md');
+  }
+  return true;
+}
+
+function createProjectYamlContent(
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean,
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  language: string
+) {
+  const projectYamlFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/project.yaml'
+  );
+  if (fs.existsSync(projectYamlFilepath.path) === false) {
+    vscode.window.showInformationMessage(projectYamlFilepath.toString());
+    wsedit.createFile(projectYamlFilepath, {ignoreIfExists: true});
+    const projectYamlTemplate = `homepage: "${projectGithubRepository}"
+language: ${language}
+primary_contact: "<primary_contact_email>"
+main_repo: "${projectGithubRepository}"
+file_github_issue: true
+    `;
+
+    const projectYamlTemplateCFLite = `language: ${language}`;
+
+    const yamlContentToWrite = isOssFuzz
+      ? projectYamlTemplate
+      : projectYamlTemplateCFLite;
+
+    wsedit.insert(
+      projectYamlFilepath,
+      new vscode.Position(0, 0),
+      yamlContentToWrite
+    );
+  }
+}
+
+function getLicenseHeader() {
+  const todaysDate = new Date();
+  const currentYear = todaysDate.getFullYear();
+
+  const licenseHeader = `# Copyright ${currentYear} Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+`;
+
+  return licenseHeader;
+}
+
+function getBaseDockerFile(language: string) {
+  const languageToBasebuilder: {[id: string]: string} = {
+    java: 'ghcr.io/aixcc-finals/base-builder-jvm',
+    cpp: 'ghcr.io/aixcc-finals/base-builder',
+    c: 'ghcr.io/aixcc-finals/base-builder',
+    python: 'ghcr.io/aixcc-finals/base-builder-python',
+  };
+  let dockerFileContent = getLicenseHeader();
+  dockerFileContent += '\n' + 'FROM ' + languageToBasebuilder[language] + '\n';
+
+  return dockerFileContent;
+}
+
+function createReadmeFile(
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean
+) {
+  const readmeFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + '/README.md'
+  );
+  //vscode.window.showInformationMessage(readmeFile.toString());
+  if (fs.existsSync(readmeFile.path) === false) {
+    const readmeContents = `# OSS-Fuzz set up
+This folder is the OSS-Fuzz set up.
+    `;
+
+    const readmeContentsCFLite = `# ClusterFuzzLite set up
+This folder contains a fuzzing set for [ClusterFuzzLite](https://google.github.io/clusterfuzzlite).
+        `;
+
+    const readmeContentsToWrite = isOssFuzz
+      ? readmeContents
+      : readmeContentsCFLite;
+
+    wsedit.createFile(readmeFile, {ignoreIfExists: true});
+
+    wsedit.insert(readmeFile, new vscode.Position(0, 0), readmeContentsToWrite);
+  }
+}
+
+async function setupJavaProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  const dockerfileTemplate =
+    getBaseDockerFile('java') +
+    ` 
+RUN curl -L https://archive.apache.org/dist/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.zip -o maven.zip && \\
+    unzip maven.zip -d $SRC/maven && \\
+    rm -rf maven.zip
+
+ENV MVN $SRC/maven/apache-maven-3.6.3/bin/mvn
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.java $SRC/`;
+  wsedit.insert(
+    ossfuzzDockerFilepath,
+    new vscode.Position(0, 0),
+    dockerfileTemplate
+  );
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+  wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+  const buildTemplate =
+    `#!/bin/bash -eu
+  ` +
+    getLicenseHeader() +
+    `
+# Supply build instructions
+# Copy all fuzzer executables to $OUT/
+`;
+  wsedit.insert(ossfuzzBuildFilepath, new vscode.Position(0, 0), buildTemplate);
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'jvm'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath +
+      '/' +
+      baseFolder +
+      '/' +
+      projectNameFromRepo +
+      '/fuzzer_example.java'
+  );
+
+  wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+  const sampleFuzzFileContents = fuzzTemplate.javaLangBareTemplate;
+
+  wsedit.insert(
+    sampleFuzzFile,
+    new vscode.Position(0, 0),
+    sampleFuzzFileContents
+  );
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupCProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('cpp') +
+      `
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.cpp $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite = `FROM ghcr.io/aixcc-finals/base-builder
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+COPY . $SRC/${baseName}
+COPY .clusterfuzzlite/build.sh $SRC/build.sh
+WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    // Create the file and add the contents
+    wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CFLAGS $LIB_FUZZING_ENGINE $SRC/fuzzer_example.c -o $OUT/fuzzer_example
+`;
+
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CC $CFLAGS $LIB_FUZZING_ENGINE \\
+  $SRC/${baseName}/.clusterfuzzlite/fuzzer_example.c \\
+  -o $OUT/fuzzer_example
+`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'c'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/fuzzer_example.c'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.cLangSimpleStringFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupCPPProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  // Only create a new Dockerfile if it doesn't already exist
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('cpp') +
+      ` 
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.cpp $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite = `FROM ghcr.io/aixcc-finals/base-builder
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+COPY . $SRC/${baseName}
+COPY .clusterfuzzlite/build.sh $SRC/build.sh
+WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    // Create the file and add the contents
+    wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CXXFLAGS $LIB_FUZZING_ENGINE $SRC/fuzzer_example.cpp -o $OUT/fuzzer_example
+`;
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CXXFLAGS $LIB_FUZZING_ENGINE \\
+  $SRC/${baseName}/.clusterfuzzlite/fuzzer_example.cpp \\
+  -o $OUT/fuzzer_example
+`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'c++'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath +
+      '/' +
+      baseFolder +
+      '/' +
+      projectNameFromRepo +
+      '/fuzzer_example.cpp'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.cppLangFDPTemplateFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupPythonProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Only write to Dockerfile if it doesn't already exist
+  // Dockerfile
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('python') +
+      ` 
+  RUN python3 -m pip install --upgrade pip
+  RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+  WORKDIR ${projectNameFromRepo}
+  COPY build.sh *.py $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite =
+      getBaseDockerFile('python') +
+      ` 
+  RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+  COPY . $SRC/${baseName}
+  COPY .clusterfuzzlite/build.sh $SRC/build.sh
+  WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+python3 -m pip install .
+
+# Build fuzzers (files prefixed with fuzz_) to $OUT
+for fuzzer in $(find $SRC -name 'fuzz_*.py'); do
+  compile_python_fuzzer $fuzzer
+done`;
+
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+python3 -m pip install .
+
+# Build fuzzers (files prefixed with fuzz_) to $OUT
+for fuzzer in $(find $SRC -name 'fuzz_*.py'); do
+  compile_python_fuzzer $fuzzer
+done`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'python'
+  );
+
+  // Sample template fuzzer
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/fuzz_ex1.py'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.pythonLangFileInputFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  // README.md
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/utils.ts

@@ -0,0 +1,306 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {extensionConfig} from './config';
+import {getApi, FileDownloader} from '@microsoft/vscode-file-downloader-api';
+
+const fs = require('fs');
+const {spawn} = require('node:child_process');
+const statusBarComp = vscode.window.createStatusBarItem(
+  vscode.StatusBarAlignment.Right,
+  100
+);
+
+import {println, printRaw, debugPrintln} from './logger';
+
+export async function setStatusText(statusText: string) {
+  //let myStatusBarItem: vscode.StatusBarItem;
+  statusBarComp.text = '$(megaphone) OSS-Fuzz: ' + statusText;
+  statusBarComp.show();
+}
+
+export async function downloadRemoteURL(
+  urlString: string,
+  targetFile: string,
+  context: vscode.ExtensionContext
+) {
+  const fileDownloader: FileDownloader = await getApi();
+  println('URL: ' + urlString);
+  let codeCoverageFile: vscode.Uri;
+  try {
+    codeCoverageFile = await fileDownloader.downloadFile(
+      vscode.Uri.parse(urlString),
+      targetFile,
+      context
+    );
+  } catch (err) {
+    println('Could not get the coverage summary file');
+    return false;
+  }
+  return codeCoverageFile;
+}
+
+export async function getLocalOutBuildDir(projectName: string) {
+  const summaryCovPath =
+    extensionConfig.ossFuzzPepositoryWorkPath + '/build/out/' + projectName;
+  return summaryCovPath;
+}
+
+export async function getOSSFuzzCloudURL(projectName: string) {
+  const currentDate = new Date();
+  const yesterday = new Date(currentDate);
+  yesterday.setDate(yesterday.getDate() - 1);
+
+  const day = yesterday.getDate();
+  const month = yesterday.getMonth();
+  const year = yesterday.getFullYear();
+
+  let urlString =
+    'https://storage.googleapis.com/oss-fuzz-coverage/' +
+    projectName +
+    '/reports/' +
+    year.toString();
+
+  if (month < 10) {
+    urlString += '0';
+  }
+  urlString += month.toString();
+  if (day < 10) {
+    urlString += '0';
+  }
+  urlString += day.toString();
+
+  return urlString;
+}
+
+/**
+ * Checks if the current workspace has a generated OSS-Fuzz folder. This is the
+ * generated folder from our auto-generation capabilities.
+ *
+ * @returns boolean
+ */
+export async function hasOssFuzzInWorkspace() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+
+  if (!workspaceFolder) {
+    return false;
+  }
+
+  // Identify if the workspace folder has a OSS-Fuzz set up.
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+  const ossfuzzDockerFilepath = vscode.Uri.file(wsPath + '/OSS-Fuzz/');
+  try {
+    if (await vscode.workspace.fs.readDirectory(ossfuzzDockerFilepath)) {
+      for (const [name, type] of await vscode.workspace.fs.readDirectory(
+        ossfuzzDockerFilepath
+      )) {
+        // If it's a directory then we know we have the project set up in there.
+        if (type === 2) {
+          // We assume this is the project folder for now.
+          println('Found the relevant directory: ' + name);
+          return true;
+        }
+      }
+    }
+  } catch {
+    /* empty */
+  }
+  return false;
+}
+
+/**
+ * Gets the project name of the integrated OSS-Fuzz project.
+ * @returns string
+ */
+export async function getOssFuzzWorkspaceProjectName() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return 'N/A';
+  }
+
+  // Identify if the workspace folder has a OSS-Fuzz set up.
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+  const ossfuzzDockerFilepath = vscode.Uri.file(wsPath + '/OSS-Fuzz/');
+  try {
+    if (await vscode.workspace.fs.readDirectory(ossfuzzDockerFilepath)) {
+      for (const [name, type] of await vscode.workspace.fs.readDirectory(
+        ossfuzzDockerFilepath
+      )) {
+        if (type === 2) {
+          // println('Is a directory');
+          // We assume this is the project folder for now.
+          return name;
+        }
+      }
+    }
+  } catch {
+    /* empty */
+  }
+
+  return 'N/A';
+}
+
+/**
+ * Lists the fuzzers available in the OSS-Fuzz build project.
+ *
+ * @param projectName
+ * @param ossFuzzRepositoryPath
+ * @returns
+ */
+export async function listFuzzersForProject(
+  projectName: string,
+  ossFuzzRepositoryPath: string
+) {
+  const projectOssFuzzBuildPath = vscode.Uri.file(
+    ossFuzzRepositoryPath + '/build/out/' + projectName
+  );
+  const fuzzersInProject: Array<string> = [];
+  for (const [name, type] of await vscode.workspace.fs.readDirectory(
+    projectOssFuzzBuildPath
+  )) {
+    // Is it a file?
+    if (type === 1) {
+      const filepath =
+        ossFuzzRepositoryPath + '/build/out/' + projectName + '/' + name;
+      const binary = fs.readFileSync(filepath);
+
+      // Check if fuzzer entrypoint exists in file. This is similar to how OSS-Fuzz
+      // checks whether a file is fuzzer or not.
+      if (binary.lastIndexOf('LLVMFuzzerTestOneInput') !== -1) {
+        fuzzersInProject.push(name);
+      }
+    }
+  }
+  println('Successfully build the project.');
+  println('The fuzzers in project');
+  for (const fuzzName of fuzzersInProject) {
+    println(fuzzName);
+  }
+  return fuzzersInProject;
+}
+
+/**
+ * Helper functions for identifying the primary programming language of the workspace.
+ *
+ * This is achieved by identifying the suffix of files and then sorting
+ * based on those with most of a given language supported by OSS-Fuzz.
+ *
+ * @returns
+ */
+export async function determineWorkspaceLanguage() {
+  const pythonFiles = await vscode.workspace.findFiles('**/*.py');
+  const cppFiles = await vscode.workspace.findFiles('**/*.c++');
+  const cfiles = await vscode.workspace.findFiles('**/*.c');
+  const rustFiles = await vscode.workspace.findFiles('**/*.rust');
+  const golangFiles = await vscode.workspace.findFiles('**/*.go');
+
+  println('Number of python files: ' + pythonFiles.length);
+  println('Number of C++ files: ' + cppFiles.length);
+  println('Number of C files: ' + cfiles.length);
+  println('Number of rustFiles files: ' + rustFiles.length);
+  println('Number of golangFiles files: ' + golangFiles.length);
+
+  const maxCount = Math.max(
+    pythonFiles.length,
+    cppFiles.length,
+    cfiles.length,
+    rustFiles.length,
+    golangFiles.length
+  );
+  let target = '';
+  if (maxCount === pythonFiles.length) {
+    target = 'python';
+  } else if (maxCount === cppFiles.length) {
+    target = 'c++';
+  } else if (maxCount === cfiles.length) {
+    target = 'c';
+  } else if (maxCount === rustFiles.length) {
+    target = 'rust';
+  } else if (maxCount === golangFiles.length) {
+    target = 'golang';
+  } else {
+    target = 'not implemented';
+  }
+
+  println('Target language: ' + target);
+  return target;
+}
+
+/**
+ * Helper method to execute commands on the system.
+ */
+export async function systemSync(cmd: string, args: Array<string | undefined>) {
+  debugPrintln('Running command');
+  debugPrintln(cmd);
+  debugPrintln(args.toString());
+  debugPrintln('<<<<<<<<<<<<');
+
+  // Launch the command
+  const command = spawn(cmd, args);
+
+  // Callbacks for output events, to capture stdout and stderr live.
+  command.stdout.on('data', (x: {toString: () => string}) => {
+    printRaw(x.toString());
+  });
+  command.stderr.on('data', (x: {toString: () => string}) => {
+    printRaw(x.toString());
+  });
+
+  // Monitor for child exit.
+  let hasChildExited = 0;
+  let childExitCode = 0;
+  command.on('exit', (code: any, signal: any) => {
+    // println('child process exited with ' + `code ${code} and signal ${signal}`);
+    childExitCode = code;
+    hasChildExited = 1;
+  });
+
+  // Block until the child process has exited.
+  const snooze = (ms: number) =>
+    new Promise(resolve => setTimeout(resolve, ms));
+
+  let idx = 0;
+  const maxSeconds = 1800;
+  debugPrintln('Child exited: ' + hasChildExited);
+
+  // I think we can convert the following loop to a Promise wrapping the command
+  // exeuction. TODO(David).
+  while (hasChildExited === 0 && idx < maxSeconds) {
+    idx += 1;
+    await snooze(1000);
+  }
+
+  // Command execution is done, return appropriately if success/error.
+  if (childExitCode !== 0) {
+    println('Command execution errored');
+    return [false, command.toString()];
+  }
+  // println('Succes');
+  return [true, command.toString()];
+}
+
+export async function systemSyncLogIfFailure(
+  cmd: string,
+  args: Array<string | undefined>
+): Promise<boolean> {
+  const [res, cmdMsg] = await systemSync(cmd, args);
+  if (res === false) {
+    println(cmdMsg);
+    return false;
+  }
+  return true;
+}